Stockage de données XML

(1)

Schémas de données semi- structurées (XML)

Données et Web / B. Amann et P. Rigaux – p.8/173

Plan

Schémas de données XML

Grammaires d’arbres

DTD et XML Schema

Langages d’interrogation: XQuery Stockage de données XML

Bibliographie : Bases de données et XML V. Vianu, A Web Odyssey: from Codd to XML, PODS’2001

S. Abiteboul, P. Buneman, D. Suciu: Data on the Web - from relations to semi-structured data and XML

A. Doucet et G. Jomier (eds.), Bases de données et Internet, Hermes.

R. Bourret,

http://www.rpbourret.com/xml/XMLDBLinks.htm Ecole d’été EDBT’02, http://www-

lsr.imag.fr/EDBT2002/Other/programme.html

La vision “base de données” de XML XML permet de représenter des données et des documents (modèle de données

“semi-structurées”).

On veut stocker, gérer et interroger des grands volumes de données XML :

Langages d’interrogation

Schémas de données XML

Stockage, optimisation et indexation

Situations mixtes

Dans un serveur Web la séparation

données/document n’est pas toujours très nette.

Un part de description textuelle est de nature

« document »

Exemple : tout le texte présentant un cinéma, ses activités, etc

Une part est contenue dans une base de données

Exemple : les films

Données et documents

Les données sont

structurées,

typées,

volumineuses,

avec une granularité fine.

et dans un document,

les structures sont plus souples,

la notion de type est moins forte,

il y beaucoup de texte.

Gestion de Données XML

Nous avons deux technologies complémentaires : Bases de Données:

interrogation

mises-à-jour et transactions Documents XML:

publication et échange

XML et les bases de données

Bernd Amann et Philippe Rigaux

amann@cnam.fr et rigaux@lri.fr

CNAM/Paris XI

(2)

Interpretation

Une interpretation d’un arbre

vers une grammaire d’arbres est une “mapping”

de chaque noeud , noté

, dans vers un non-terminal tel que :

est un symbole dans , et

pour chaque noeud et ses enfants , il existe une règle de production telle que (1)

, (2) le terminal (étiquette) de

est , et (3) est dans .

Grammaires d’arbre/ B. Amann – p.16/173

Grammaire d’arbre: Exemple 2

Grammaire d’arbres :

1 N = {Doc, Para1, Para2, Pcdata}

2 T = {doc, para, pcdata}

3 S = {Doc}

4 Doc -> doc (Para1, Para2*)

5 Para1 -> para (Pcdata)

6 Para2 -> para (Pcdata)

7 Pcdata -> pcdata

Grammaire d’arbre: Exemple 1

Grammaire d’arbres :

1 N = {Doc, Section, Titre, Para, Pcdata}

2 T = {doc, section, titre, para, pcdata}

3 S = {Doc}

4 Doc -> doc (Titre, Section+)

5 Titre -> titre (Pcdata)

6 Section -> section (Titre, Para*)

7 Para -> para (Pcdata)

8 Pcdata -> pcdata

Normalisation : Il n’existe pas deux règles

et .

Grammaires d’arbres

Une grammaire d’arbres (régulière) est un quadruple

, où

est un ensemble fini de non-terminaux,

est un ensemble fini de terminaux,

est un sous-ensemble de ,

est un ensemble fini de règles de production ou , où ,

et est une expression régulière sur ( est appelé le modèle de contenu de ).

Grammaires d’arbre

Exemple: Stockage d’un document XML dans une Base de Données

DTD :

1 <!ELEMENT Cours (Titre, NomProf, (Etudiant)* >

2 <!ELEMENT Etudiant NomEt >

3 <!ELEMENT Prof (NomProf, Salaire) >

Schéma relationnel : Cours(titre, nomProf) Etudiant(nomEt, titre) Prof(nomProf, salaire)

Exemple: Interrogation et Optimisation

DTD :

1 <!ELEMENT Personnes (Etudiant|Prof)*>

2 <!ELEMENT Etudiant Nom>

3 <!ELEMENT Prof (Nom, Salaire)>

Requête XQuery :

for $a in Personnes/* return $a/Salaire Version optimisée :

for $a in Personnes/Prof return $a/Salaire

Les besoins de schémas

Dans la gestion de données XML, un schéma est utile pour

naviguer et interroger, créer et modifier,

l’optimisation de requêtes, et le stockage des données.

Dans la gestion de documents XML, un schéma est utile pour

créer et modifier (éditeurs structurés), l’échange (vérification)

(3)

Parsing et Validation

On distingue entre deux modèles de parsing (validation) :

modèle d’arbre : le parseur crée un arbre dans la mémoire (DOM).

modèle par évènements : le parseur crée des évènements qui correspondent à des entrées et sorties des noeuds dans un parcours de l’arbre de gauche à droite en profondeur (SAX). Ce parcours correspond à une lecture sequentielle d’un fichier XML sans mémoire.

Clôture

les grammaires d’arbres régulières sont fermés sous l’union, l’intersection et la différence.

les grammaires locales, à types uniques et avec concurrence restreinte sont uniquement fermées sous l’intersection.

Expressivité Dans une grammaire

locale, tous les éléments d’un type sont associés à la même règle de production à types uniques, tous les fils de type d’un élément sont associés à la même règle de production

avec concurrence restreinte, il est possible d’identifier pour chaque élément une seule règle de production à partir de son parent et de ses frères de gauche.

locale type unique concurrence restreinte

Grammaires avec concurrence restreinte Une grammaire avec concurrence restreinte est une grammaire régulière telle que

pour chaque règle de production, le modèle de contenu restreint la concurrence entre ses non-terminaux et

les non-terminaux dans ne sont pas concurrents.

La grammaire précédente est une grammaire avec concurrence restreinte.

Non-terminaux concurrents

Un modèle de contenu restreint la

concurrence entre deux non-terminaux et concurrents s’il n’existe pas de séquences de non-terminaux , , et telles que génère

et .

Exemple : Le modèle de contenu de Doc -> doc (Para1* Para2*)ne restreint pas la concurrence entrePara1etPara2.

Grammaires à types uniques

Une grammaire à types uniques est une grammaire régulière telle que

pour chaque règle de production, les non-terminaux dans son modèle de contenu ne sont pas concurrents et

les symboles dans ne sont pas concurrents.

La grammaire précédente n’est pas une grammaire à types uniques.

Grammaires locales

Deux non-terminaux et différents sont concurrents entre eux s’il existe deux règles de production et .

Une grammaire locale est une grammaire régulière sans non-terminaux concurrents.

La grammaire précédente n’est pas une grammaire locale.

Géneration d’arbres et langages

Un arbre est généré par une grammaire d’arbres s’il existe une interprétation de dans .

Un langage d’arbres régulier est l’ensemble des arbres générés par une grammaire d’arbres régulièrs.

(4)

Exemple de type Type XML Schema :

<xsd:complexType name=’CinemaType’>

<xsd:sequence>

<xsd:element name=’nom’ type=’xsd:string’/>

<xsd:element name=’adresse’ type=’AdresseType’/>

<xsd:element name=’séance’ type=’SéanceType’

minOccurs=’0’

maxOccurs=’unbounded’/>

</xsd:sequence>

</xsd:complexType>

Expression d’arbre :

CinemaType -> Nom Adresse (Séance)*

Nom -> nom String

Adresse -> adresse AdresseType Séance -> séance SéanceType

Constructeurs de type

Le type (complexe) CinemaType est une séquence d’éléments (constructeur de typeséquence):

nom de type string

adresse de type AdresseType séances de type SéanceType

XML Schéma versus DTD

Un schéma XML est lui même un document XML.

Les types des éléménts (OfficielType) peuvent être déclarés indépendamment des éléments (officiel) : plusieurs éléments peuvent

partager le même type.

types complexes, abstraits et anonymes sous-typage par extension et restriction contraintes d’intégrité (clés, clés étrangères)

XML: Syntaxe pour Transfert de Données Problème: DTD sont trop “pauvres” pour représenter des modèles de données plus riches :

la relation élément/sous-élément n’a pas de sémantique précise (part-of,

instance-of, subclass-of, ...)

un ensemble limité de types atomiques

une DTD n’est pas un document XML

XML Schema

DTD comme grammaire d’arbre : Exemple

DTD: officiel.dtd

<!ELEMENT officiel (#PCDATA | cinéma | film)*>

<!ELEMENT cinéma (nom, adresse, (séance)*)>

Grammaire d’arbres :

Officiel -> officiel OfficielType OfficielType -> (Cinema|Film|Pcdata)*

Cinema -> cinema CinemaType Film -> film CinemaType

Langage de typage XML DTD: grammaire locale

XML Schéma: grammaire à types uniques DSD, XDuce, Relax Core, Trex: grammaire régulière sans restriction

Validation

Les grammaires d’arbres régulières permettent la validation par évènement.

Exemple : Grammaires à types uniques

1. entrée d’un noeud de type on cherche une règle :

(a) noeud = racine : il existe au maximum une règle de production

(b) noeud <> racine : soit la règle de production du parent de ; on cherche la règle tel que apparaît dans 2. sortie d’un noeud : on compare la séquence

des étiquettes des enfants de avec .

(5)

Eléments

Déclaration d’éléments:

<xsd:element name type contraintes [value]/>

ou

<xsd:element ref contraintes/>

Contraintes: minOccurs, maxOccurs, fixed Exemple:

<xsd:element name=’nom’

type=’xsd:string’

minOccurs=’0’

maxOccurs=’2’/>

Union de Types Simples Grammaire :

euroNumTél -> francTél | gerTél | belTél | ...

Schéma :

<xsd:simpleType name=’euroNumTél’>

<xsd:union memberTypes=’francTél gerTél belTél ...’/>

</xsd:simpleType>

Liste avec 5 numéros de téléphone Grammaire :

cinqNumTél -> (numTél, numTél, numTél, numTél, numTél)

Schéma :

<xsd:simpleType name=’cinqNumTél’>

<xsd:restriction base=’listNumTél’>

<xsd:length value=’5’/>

</xsd:restriction>

</xsd:simpleType>

Listes de Valeurs de Type Simple Grammaire :

listeNumTél -> (numTél)*

Schéma :

<xsd:simpleType name=’listeNumTél’>

<xsd:list itemType=’numTél’/>

</xsd:simpleType>

Restriction de Types Simples par Motifs

Numéro de téléphone: +33-(0)-1-34-45-67-89 DTD: #PCDATA

Schéma XML: Similaire aux expressions régulières de Perl

<xsd:simpleType name=’numTél’>

<xsd:restriction base=’xsd:string’>

<xsd:pattern value=’+33-(0)-\d(-\d{2}){3}’/>

</xsd:simpleType>

Restrictions de Types Simples On peut restreindre les types simples

par leur longueur (length, minLength, maxLength) (chaînes de caractères ou listes) par des motifs (chaînes de caractères), par énumération,

par des intervalles (maxInclusive, maxExclusive, minInclusive, minExclusive) et

autres (precision, scale, encoding, period, duration).

Restriction de Types Simples

L’année d’un film est un entier entre 1900 et 2002.

DTD: #PCDATA

XML schéma : Restriction de type

<xsd:simpleType name=’annéeFilm’>

<xsd:restriction base=’xsd:integer’>

<xsd:minInclusive value=’1900’/>

<xsd:maxInclusive value=’2002’/>

</xsd:simpleType>

Types Simples

DTD: un seul type simple (#PCDATA) et 10 types d’attributs

Schéma XML: 43 types simples

xsd:string,xsd:byte, ...

xsd:integer,xsd:long,xsd:float, xsd:double, ...

xsd:boolean

xsd:time,xsd:timeDuration, xsd:Date,xsd:year,xsd:month, ...

xsd:language,xsd:uriReference

xsd:ID,xsd:IDREF,xsd:NMTOKEN, ...

(6)

Extension de Types Complexes

Cinémas avec un site Web et un pays (fichier webcountry.xsd ):

<complexType name=’cybercinemaType’>

<complexContent>

<extension base=’officiel:cinemaType’>

<sequence>

<element name=’url’ type=’xsd:string’/>

</sequence>

</extension>

</complexContent>

</complexType>

Grammaire d’abres :

CybercinemaType -> Nom Adresse (Seance)* Url, Nom -> nom String, Url -> url String, ...

Valeurs Nulles

On distingue entre les éléments vides et les éléments avec un contenu inconnu :

Schéma XML:

<xsd:element name=’heureFilm’

type=’xsd:time’

nullable=’true’/>

Élément XML:

<heureFilm xsi:null=’true’/>

xsi:nullest défini dans l’espace de noms pour des instances (http://www.w3.org/2000/10/- XMLSchema-instance).

Groupes d’Attributs

L’adresse d’un cinéma ou d’une personne est composée des mêmes attributs (partage) :

<xsd:element name=’cinema’>

<xsd:attributeGroup ref=’Adresse’/>

</xsd:element>

<xsd:element name=’personne’>

<xsd:attributeGroup ref=’Adresse’/>

</xsd:element>

<xsd:attributeGroup name=’Adresse’>

<xsd:attribute name=’ville’ type=’xsd:string’/>

<xsd:attribute name=’rue’ type=’xsd:string’/>

<xsd:attribute name=’numéro’ type=’xsd:decimal’/>

</xsd:attribute>

Groupes: Exemple

DTD:((B|C)*,D)+

XML schéma:

<xsd:complexType>

<xsd:group minOccurs=’1’ maxOccurs=’unbounded’>

<xsd:sequence>

<xsd:group minOccurs=’0’ maxOccurs=’unbounded’>

<xsd:choice>

<xsd:element name=’B’ xsd:type=’xsd:string’/>

<xsd:element name=’C’ xsd:type=’xsd:string’/>

</xsd:choice>

</xsd:sequence>

</xsd:group>

<xsd:complexType>

Contenu Mélangé (mixed)

DTD:(#PCDATA | cinéma | film)*

Schéma XML :

<xsd:complexType name=’OfficielType’ mixed=’true’>

<xsd:choice minOccurs=’0’ maxOccurs=’unbounded’>

<xsd:element name=’cinema’ type=’CinemaType’ />

<xsd:element name=’film’ type=’FilmType’ />

</xsd:choice>

Type Complexe: Exemple

Modèle de contenu DTD:(titre, année) XML Schéma:

<xsd:complexType name=’FilmType’>

<xsd:sequence>

<xsd:element name=’titre’ type=’xsd:string’/>

<xsd:element name=’année’ type=’xsd:year’/>

</xsd:sequence>

Grammaire :

FilmType -> Titre Année Titre -> titre String Année -> année xsd:year

Types Complexes

Trois constructeurs de type:

xsd:sequence: séquence ordonnée d’éléménts

xsd:all: séquence non-ordonnée d’éléménts

xsd:choice: choix d’éléménts (DTD: ’ ’)

xsd:group: regroupement (DTD: ’(...)’).

Attributs

Déclaration d’attributs:

<xsd:attribute name use [value]/>

Use : required, optional, fixed, prohibited Exemple:

<xsd:attribute name=’langue’

type=’xsd:language’

optional=’true’/>

(7)

Bibliographie: Typage XML

M. Makoto, Taxonomy of XML Schema Languages using Formal Language Theory J. Siméon et P. Wadler, The Essence of XML Site W3C: http://www.w3.org/XML/Schema

Clés et Références

Une clé est unique (filmcli = clé):

<key name=’filmclé’>

<selector>film</selector>

<field>@film_id</field>

</key>

Référence (filmref = clé etrangère):

<keyref name=’filmref’ refer=’filmclé’>

<selector>séance</selector>

<field>@ref_film</field>

</keyref>

Valeur unique

L’attributfilm_idd’un film doit être unique:

<unique name=’toto’>

<selector>film</selector>

<field>@film_id</field>

</unique>

Les valeurs des element<selector>et

<field>sont des expressions XPath.

La valeur de<field>doit être unique à l’intérieur de chaque élément sélectionné par le sélecteur.

Groupes de substitution

Substitution d’éléments par d’autres éléments:

XML schéma:

<element name=’movieTheatre’

type=’cinemaType’

substitutionGroup=’cinéma’/>

L’élémentmovieTheatrepeut être utilisé à la place decinéma.

Restriction de Types Complexes

On définit un type spécifique pour les cinémas avec une à trois séances (fichier seance.xsd ):

<complexType name=’séanceobligType’>

<complexContent>

<restriction base=’cinemaType’>

<complexType content=’elementOnly’>

<sequence minOccurs=’1’ maxOccurs=’3’>

<element ref=’seance’/>

</sequence>

<element name=’nom’ type=’string’/>

<element ref=’adresse’/>

</complexType>

</complexContent>

</complexType>

Utilisation de Types Étendus

Par défaut, les élémentscinemasont de type cinemaType.

Le type d’un élément est indiqué explicitement avec l’attribut xsi:type.

XML Schéma permet de définir des

grammaires sans concurrence restreinte l’attributxsi:typeindique la règle de production à choisir

Utilisation de Types Étendus

On indique explicitement la règle de production pour le type :

<cinema xsi:type=’CybercinemaType’>

<nom>St André des Arts</nom>

<officiel:adresse>

<ville> Paris </ville>

<rue> rue St. André des Arts </rue>

<numéro> 13 </numéro>

</officiel:adresse>

<url>http://www.st-andré.com</url>

</cinema>

Extension de Types Complexes

Chaque occurrence de CinemaType dans le modèle de contenu d’une règle est remplacée par (CinemaType|CybercinemaType)

Le remplacement automatique peut être empeché par les attributs block et final. Ces deux attributs peuvent prendre comme valeurs

#allou une liste contenant les valeurs restriction,^extensionet/ousubstitution:

<xsd:complexType name=’CinemaType’

block=’restriction’>

...

(8)

Exemple Base 2 Base 2 :

: , , , ...

: , , ,

,

: , , ,

,

: , ,

,

: = (point fixe)

le noeud n’a pas pu être typé

Exemple Base 1 Base 1 :

: , , ...

:

,

:

,

= (point fixe)

Point-fixe maximal

Le résultat des règles précédentes est vide dans les deux cas si on applique la sémantique du point fixe minimal (Nom, Sal, Personne, Employe et Root sont vides au départ)

Point fixe maximal:

: chaque prédicat intensionel (type) contient tous les faits (objets) de la base ;

contient tous les faits qui peuvent être dérivé de

Exemple : Deux Bases de données

&1

&4 &5

"Toto" "Lulu"

&3

&2

&a

&b

&6 123

&d

"Lulu"

&c

"Toto"

Base 1: Base 2:

Exemple: Règles Datalog

Schéma ;

Nom(x) :- Personne(y), parent(x,y), string(x);

Sal(x) :- Personne(y), parent(x,y), integer(x);

Personne(x) :- Nom(y), parent(y,x);

Employe(x) :- Nom(y), parent(y,x), Sal(z), parent(y,z);

Root(x):- Personne(y), parent(y,x);

Root(x):- Employe(y), parent(y,x);

Exemple: Classification avec Datalog Règles :

Si est le fils d’un élément de typePersonne et de type string, alors est de typeNom; Si est le fils d’un élément de type^Employéet de type integer, alors est de typeSal; Si a des fils de type^Nom, alors est un élément de type^Personne;

Si a des fils de typeNomet de type Salaire alors est un élément de typeEmployé.

Exemple: Inférence de type avec Datalog Etant donné un graphe de données et un graphe de schéma (type) on peut se poser deux questions :

Est-ce que est conforme à ? (validation) Quel noeud dans appartient à quelle classe dans ? (classification)

Inférence de type

(9)

Interrogation de documents XML Comment interroger des documents XML ? Solutions :

SQL : il faut stocker XML dans une BD relationnel

expressions XPath : extraction de fragments règles XSLT : extraction + transformation (règles)

XQuery : vrai langage de requêtes pour XML

XQuery/ B. Amann – p.72/173

Interroger XML: XQuery 1.0

Bibliographie

S. Abiteboul, P. Buneman, D. Suciu, Data on the Web

S. Nestorov, S. Abiteboul, R. Motwani, Inferring Structure in Semistructured Data

Comparaison de schémas

On veut vérifier si toutes les bases de données qui sont conforme à un schéma , sont aussi

conforme à un schéma ? ( subsume/inclue ) : Si et , alors

où

.

S’il existe une simulation de vers , et est conforme à , alors est conforme à .

Simulation: Exemple

Il peut y avoir plusieurs simulation de dans : Si et , alors

: il existe toujours une simulation maximale de vers

Un objet appartient à un concept , si

où est la simulation maximale de dans . Remarque : le calcul de la simulation maximale est similaire au calcul du point fixe maximal du programme Datalog.

Simulation: Schéma et Simulation

&r1 Root

&p1 Person

&c1 Company

String String

Person Company

Root

employee

person company

works_for

position name name

&p2 Person

&s0 String

&s1 String

&s2 String

&s3 String

&s4 String

&s5 String String

addr

schema Simulation

Simulation: Données

data

&s0 &s1 &s2

&c1

&s3 &s4 &s5

&p2

&r1

&p1

person person

employee

address name

employee

works_for position

name name position

company

Simulation

Schémas et données sont des graphes avec des arcs étiquettés :

Une relation est une simulation de dans ( ) si pour chaque arc

dans et chaque pair , il existe un arc

dans , tel que

et

.

(10)

Exemples de valeurs

Chaque valeur a un type : 47 xsd:int

(1, 2, 3) xsd:int, xsd:int, xsd:int (47, ‘‘toto’’) xsd:int, xsd:string

<a/> element a {()}

<a>toto</a> element a {text}

() () ERROR

Noeuds

Chaque noeud a une identité

Les éléments et les attributs sont annotés par un type (XMLSchema)

Chaque noeud a une valeur typée:

une séquence de valeurs atomiques (ou ERROR)

de type inconnu (“anySimpleType”) Les noeuds sont triés dans l’ordre du document

Valeurs

XQuery ne fait pas la distinction entre un item et une séquence de longueur 1

Il n’existe pas de séquence imbriqués Il n’existe pas de valeur nulle

Une séquence peut être vide

Une séquence peut contenir des valeurs hétérogènes

Toutes les séquences sont triées

Exemples de valeurs

47

’’toto’’

<a/>

(1, 2, 3)

(47, <a/>, ‘‘toto’’) un document XML (): liste vide

ERROR: valeur d’erreur

Noeuds et Valeurs Atomiques

XQuery est un langage fortement typé : types de noeuds XML:

document

élément, attribut

text

commentaire, instruction de traitement, espace de nom

types atomiques XML Schéma:

xsd:string,^xsd:int, ...

Modèle de données de XQuery

On a besoin d’un modèle de données pour définir le sens (la sémantique) des expressions XQuery:

Requête qex:

document("bib.xml")/bib//book[1]/(editor union author)

Modèle de données :

Une valeur est une séquence ordonnée de zéro ou plus d’items.

Un item est un noeud ou une valeur atomique.

Modèle abstrait d’un traitement XML

Parseur XML Validateur

Document XML Schéma XML

XML Modèle

de données XQuery

Résultat Infoset

PSV Infoset

Remplacement entités Insertion de valeurs par défaut Document bien formé Document valide PSV: Post−schema validated Infoset (avec annotations de types)

La place de XQuery dans le monde XML

XQuery

XPath Schema

XML

XQuery XSLT

XPath 2.0 XML

Schema Modèles et Langages: Groupes de travail:

(Don Chamberlin)

(11)

Expressions de chemins: XPath 2.0

Dans XPath 2.0, chaque étape est une expression XQuery ( XPath 1.0) :

//book[1]/author //book[1]/publisher

//book[1]/(author,publisher)(!) //book[author/la=’’Scholl’’]

//book[author/la=’’Suciu’’]/publisher //book[position() lt last()]

Expressions de chemins Requête q1:

document("bib.xml")//author

Résultat:

<author><la>Amann</la><fi>B.</fi></author>,

<author><la>Rigaux</la><fi>P.</fi></author>,

<author><la>Scholl</la><fi>M.</fi></author>,

<author><la>Voisard</la><fi>A.</fi></author>,

<author><la>Abiteboul</la><fi>S.</fi></author>,

<author><la>Buneman</la><fi>P.</fi></author>,

<author><la>Suciu</la><fi>D.</fi></author>

Nous supposons la connaissance de XPath 1.0...

Expressions simples Requête qar:

1+2

Résultat:

3

Requête qel:

(1, (2, 6), "toto", <toto/>)

Résultat:

1, 2, 6, toto, <toto/>

Document Exemple: bib.xml

<bib>

<book title="Comprendre XSLT">

<author><la>Amann</la><fi>B.</fi></author>

<author><la>Rigaux</la><fi>P.</fi></author>

<publisher>O’Reilly</publisher>

<price>28.95</price>

</book>

<book year="2001" title="Spatial Databases">

<author><la>Scholl</la><fi>M.</fi></author>

<author><la>Voisard</la><fi>A.</fi></author>

<publisher>Morgan Kaufmann Publishers</publisher>

</book>

<book year="2000" title="Data on the Web">

<author><la>Abiteboul</la><fi>S.</fi></author>

<author><la>Buneman</la><fi>P.</fi></author>

</book>

</bib>

DTD Exemple: bib.dtd

<!ELEMENT bib (book* )>

<!ELEMENT book (author+ | editor+ ), publisher, price )>

<!ATTLIST book year CDATA #IMPLIED title CDATA #REQUIRED>

<!ELEMENT author (la, fi )>

<!ELEMENT title (#PCDATA )>

<!ELEMENT la (#PCDATA )>

<!ELEMENT fi (#PCDATA )>

<!ELEMENT affiliation (#PCDATA )>

<!ELEMENT publisher (#PCDATA )>

<!ELEMENT price (#PCDATA )>

Expressions XQuery (suite)

expressions de chemins: XPath 2.0 opérateurs de comparaison pour valeurs atomiques, noeuds et séquences expressions logiques:and or not() appels de fonctions

constructeurs de noeuds boucles (for-let-where-return) tests (if-then-return-else-return)

Expressions XQuery

litéraux (valeurs atomiques): 46, “Salut”

valeurs construites:true(), date(‘‘2002-10-23’’) variables:$x,$y, ...

opérateurs arithmétiques:⁺ ^- ^* ^div ^mod séquences:(1,2),(1, ‘‘toto’’, <toto/>) union, intersection, différence de séquences de noeuds

XQuery: Langage Fonctionnel

XQuery est un langage fonctionnel :

une requête XQuery est une composition d’expressions

il existe 21 sortes d’expressions chaque expression a une valeur

les expressions n’ont pas d’effets de bord les expressions peuvent être composées librement

la valeur^ERRORest propagée (exception)

(12)

Opérateurs arithmétiques opérateurs unaires :+ -

opérateurs binaires :+ - * div mod Requête qari:

document("bib.xml")//book[1]/price * 1.2

Résultat:

3.474E1

Construction de séquences Requête q5a:

<livre>

Le prix suivi des auteurs:

{ document("bib.xml")//book[1]/(price,author) }

</livre>

Résultat:

<livre>

Le prix suivi des auteurs:

</livre>

On a changé l’ordre des noeuds ( union)...

Différence de séquences de noeuds Requête q4:

<livre>

Tous les sous-elements sauf les auteurs:

{ document("bib.xml")//book[1]/(* except author) }

</livre>

Résultat:

<livre>

Tous les sous-elements sauf les auteurs:

</livre>

Union de séquences de noeuds Requête q3:

<Livre>

Les auteurs et le prix du premier livre:

{ document("bib.xml")//book[1]/(author union price) }

</Livre>

Résultat:

<Livre>

Les auteurs et le prix du premier livre:

</Livre>

Les trois opérateursûnion,întersectetêxcept éliminent les duplicats.

Construction de noeuds XML (4) Requête q2c:

element livre {

attribute {concat("auteur_", string(1+2))} {

"toto"

} }

Résultat:

<livre auteur_3="toto"/>

Construction de noeuds XML (3)

Nom et contenu calculé:

element {expr-nom} {expr-contenu} attribute {expr-nom} {expr-contenu} Requête q2b:

element {concat("a_",string(1+4))} {9+3}

Résultat:

<a_5>12</a_5>

Nom connu, contenu calculé:{ expr } Requête q2:

<auteurs>

{ document("bib.xml")//author/la }

</auteurs>

Résultat:

<?xml version="1.0"?>

<auteurs>

<la>Amann</la>

<la>Rigaux</la>

<la>Scholl</la>

<la>Voisard</la>

<la>Abiteboul</la>

<la>Buneman</la>

<la>Suciu</la>

</auteurs>

Nom et contenu connu:

Requête q2a:

<livre auteur="L. Carroll">

<titre>Alice au Pays de Merveilles</titre>

</livre>

Résultat:

<livre auteur="L. Carroll"><titre>Alice au Pays de Merveilles</titre></livre>

(13)

Boucles: for-where-return

La clausewhereexp permet de filtrer le résultat par rapport au résultat booléen de l’expression exp (= prédicat dans l’expression de chemin).

Requête qforwhere:

for $a in document("bib.xml")//author where $a/la eq "Abiteboul"

return $a

Résultat:

<?xml version="1.0"?>

<author>

<la>Abiteboul</la>

<fi>S.</fi>

</author>

Boucles: for-return

La clausefor$varinexp affecte la variable $var succéssivement avec chaque item dans la

séquence retournée par exp.

Requête qfor:

for $a in document("bib.xml")//author[la eq "Voisard"]

return $a

Résultat:

Comparaisons par la position

Comparaison de la positition de deux noeuds :

<< ( << ) si apparaît avant (après) dans le document.

Requête qord:

document("bib.xml")//book[author[la="Abiteboul"] <<

author[la="Suciu"]]

Résultat:

<book year="2000"

title="Data on the Web">

<author><la>Abiteboul</la><fi>S.</fi></author>

<author><la>Buneman</la><fi>P.</fi></author>

</book>

Comparaisons de noeuds

Comparaison de l’identité de deux noeuds : is

si est identique à . Requête qis:

document("bib.xml")//book[author[2] is author[last()]]

Résultat:

<book title="Comprendre XSLT">

</book>

Comparaison de séquences

Comparaison de séquences : = s’il existe au moins un élément dans qui est égal à un élément dans .

Requête qeqex:

document("bib.xml")//book[author/la = "Scholl"]

Résultat:

<book year="2001"

title="Spatial Databases">

<author><la>Scholl</la><fi>M.</fi></author>

</book>

Comparaison de valeurs atomiques Requête qeq:

distinct-values(document("bib.xml")//

book/author[la eq "Rigaux"])

Résultat:

Requête qeqerror:

document("bib.xml")//book[author/la eq "Rigaux"]

Résultat:

ERROR

L’expressionauthor/ladans le prédicat ne retourne pas une valeur atomique.

Expressions de Comparaisons Comparaison de valeurs atomiques:

eq ne gt ge lt le

Comparaison de séquences de valeurs avec quantificateur éxistentiel:

= != > >= < <=

Comparaison de noeuds:

is isnot

Comparaison de noeuds par rapport à leur position dans le document:

<< >>

Transformation noeud valeur Requête q6:

<auteurs>

{ document("bib.xml")//book[2]/author/la }

<noms>

{ document("bib.xml")//book[2]/author/xf:string(la) }

</noms>

</auteurs>

Résultat:

<auteurs>

<la>Rigaux</la>

<la>Scholl</la>

<la>Voisard</la>

<noms>Rigaux Scholl Voisard</noms>

</auteurs>