XML Chap3 Schema XML3

Schéma XML
2018-2019 XML 1
Objectif
 Définir ce qui est autorisé, correct et compréhensible

dans le contexte du document
 Il y a 2 solutions pour préciser les balises et attributs

auxquels on a droit pour rédiger un document XML :
 Les DTD (Document Type Definition)
 Les schémas XML
2018-2019 XML 2
Objectif
 Définir ce qui est autorisé, correct et compréhensible

dans le contexte du document
 Il y a 2 solutions pour préciser les balises et attributs

auxquels on a droit pour rédiger un document XML :
 Les DTD (Document Type Definition)
 Les schémas XML
2018-2019 XML 3
Exemple de schéma XML
<?xml version="1.0"?> <!ELEMENT note (to,from,heading,body)>
<xs:schema <!ELEMENT to (#PCDATA)>
xmlns:xsd="http://www.w3.org/2001/XMLSche <!ELEMENT from (#PCDATA)>
ma"> <!ELEMENT heading (#PCDATA)>
<xsd:element name="note"> <!ELEMENT body (#PCDATA)>
<xsd:complexType>
<xsd:sequence>
<xsd:element name="to" type="xsd:string"/>
<xsd:element name="from"
type="xsd:string"/>
<xsd:element name="heading"
type="xsd:string"/>
<xsd:element name="body"
type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
2018-2019 XML 4
Structure générique
<xml version="1.0" encoding="UTF-8"?>
<xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema">

...
</xsd:schema>
 Pour pouvoir mélanger des balises provenant de grammaires

différentes, on utilise des espaces de noms pour éviter
d'éventuelles ambiguïtés.
 L'espace de noms des schémas XML est identifié par l'URI
http://www.w3.org/2001/XMLSchema.
2018-2019 XML 5
Schéma XML : déclarations d'éléments
2018-2019 XML 6
Déclarations d'éléments
 Pour déclarer un élément il faut utiliser la balise <xsd:element>

 La forme la plus simple est la suivante :
– <xsd:element name="element" type="type"/>
 La valeur de l'attribut name = nom qu'aura l'élément dans le doc
xml
 La valeur de l'attribut type = le type de l'élément.
 Le type de l'élément peut être :
– un type simple prédéfini (e.g. xsd:string, xsd:integer, …)
– un type défini par nous même ailleurs dans le schéma
2018-2019 XML 7
 Exemple avec un type prédéfini :
<xsd:element name="entier" type="xsd:integer"/>
2018-2019 XML 8
 Exemple avec un type défini par nous-même.

 On doit utiliser l'élément <xsd:simpleType> ou <xsd:complexType>
selon que le type soit simple ou complexe (cf. plus loin dans le cours).
 La déclaration de ce type doit être globale, i.e., <xsd:simpleType>
(resp. <xsd:complexType>) doit être un enfant de <xsd:schema>.
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:simpleType name=''outside''>
...
</xsd:simpleType>
...
<xsd:element name="element" type=''outside''/>
...
</xsd:schema>
2018-2019 XML 9
Déclarations d'éléments : valeur
par défaut (resp. fixe)
 Lorsque le type de l'élément déclaré est prédéfini ou

simple (cf. <xsd:simpleType>), on peut lui donner une
valeur par défaut via l'attribut default.
– <xsd:element name="entier" type="xsd:integer"
default=''7''/>
 On peut aussi obliger un élément a avoir un attribut qui
a toujours la même valeur via l'attribut fixed.
– <xsd:element name="nombre" type="xsd:integer"
fixed=''7''/>
2018-2019 XML 10
Déclarations d'éléments sans
référence explicite à un type
 Il n'est pas obligatoire de faire référence explicitement à un

type via l'attribut type dans l'élément xsd:element.
 Dans ce cas, le type de l'élément doit être décrit dans la
balise xsd :element.
 La syntaxe est alors une des deux suivantes selon que le
type est simple ou complexe.
<xsd:element name="item"> <xsd:element name="item">
<xsd:simpleType> <xsd:complexType>
... ...
</xsd:simpleType> </xsd:complexType>
</xsd:element> </xsd:element>
2018-2019 XML 11
Schéma XML : définitions de types
2018-2019 XML 12
Définitions de types
 Les types peuvent se classer en 2 catégories :

– Les types simples.
• Ils ne définissent que des contenus textuels.
• Ils peuvent être utilisés pour typer des attributs et des éléments
• Ils se subdivisent en 2 sous-catégories :
– les prédéfinis.
– Les non-prédéfinis.
– Les types complexes
• Ils sont utilisés uniquement pour typer des attributs
• Ils se subdivisent en 2 sous-catégories :
– Les types complexe à contenu simple.
– Les types complexes à contenu complexe.
2018-2019 XML 13
Définitions de types : les types
prédéfinis
 A quelques exceptions près, on peut classer les types

prédéfinis en 3 grandes classes :
– Les chaînes de caractères
– Les dates et heures
– Les nombres et booléens
2018-2019 XML 14
2018-2019 XML 15
Nombres et booléens
 xsd:boolean : true ou false (resp. 1 ou 0)

 xsd:byte : entier signé sur 8 bits
 xsd:unsignedByte : entier non signé sur 8 bits
 xsd:short : entier signé sur 16 bits
 xsd:unsignedShort : entier non signé sur 16 bits
 xsd:int : entier signé sur 32 bits
 xsd:unsignedInt : entier non signé sur 32 bits
 xsd:long : entier signé sur 64 bits.
 xsd:unsignedLong : entier non signé sur 64 bits
2018-2019 XML 16
Nombres et booléens
 xsd:integer : entier de longueur arbitraire.

 xsd:positiveInteger : entier strictement positif de longueur arbitraire
 xsd:negativeInteger : entier strictement négatif de longueur arbitraire
 xsd:nonPositiveInteger : entier négatif ou nul de longueur arbitraire
 xsd:nonNegativeInteger : entier positif ou nul de longueur arbitraire
 xsd:float : nombre flottant sur 32 bits
 xsd:double : nombre flottant sur 64 bits
 xsd:decimal : nombre décimal de longueur arbitraire
2018-2019 XML 17
Les chaînes de caractères
 xsd:string : chaîne de caractères.

 xsd:normalizedString : chaîne de caractères ne contenant pas de tabulation, de saut
de ligne, ou de retour chariot.
 xsd:token : comme xsd:normalizedString avec la condition supplémentaire de pas
avoir d'espace en début ou en fin de chaîne ou plusieurs espaces consécutifs.
 xsd:Name : nom XML
Pour attributs uniquement
 xsd:ID : nom xml utilisé pour un attribut servant à identifier un élément dans un
document XML
 xsd:IDREF : nom XML qui fait référence à une valeur de type xsd:ID existant dans le
document
 xsd:IDREFS : liste de noms XML (références à des identifiants) séparés par des
espaces
 xsd:NMTOKEN : jeton
 xsd:NMTOKENS : liste de jetons séparés par des espaces
2018-2019 XML 18
Les dates et heures
 xsd:time : heure au format hh:mm:ss.

 xsd:date : date au format YYYY-MM-DD.
 xsd:dateTime : date et heure au format YYYY-MM-DDThh:mm:ss.
 xsd:duration : durée spécifiée selon le format PnYnMnDTnHnMnS
– Commence toujours par P
– nY, nM, nD spécifient le nombre d'année, mois et jours
– La lettre T est obligatoire si on veut décrire des heures, minutes ou secondes
– nhnMnS spécifient le nombre d'heures, minutes et secondes.
– exemple P8Y4M5D, P7M9DT10H5S et PT3H10S.
 xsd:dayTimeDuration : durée spécifiée selon le format PnDTnHnMnS.
 xsd:yearMonthDuration : durée spécifiée selon le format PnYnM comme P1Y6M.
 xsd:gYear : année au format YYYY.
 xsd:gYearMonth : année et mois au format YYYY-MM.
 xsd:gMonth : mois au format MM (de 01 à 12).
 xsd:gMonthDay : jour et mois au format MM-DD.
 xsd:gDay : jour au format DD.
2018-2019 XML 19
Les types simples non-prédéfinis
 Comme pour les types prédéfinis, les types simples non-

prédéfinis permettent uniquement de décrire des contenus
''texte''.
 Ils sont introduits par l'élément xsd:simpleType et sont
obtenus :
– soit à partir d'un autre type simple via une
opération de restriction (cf. plus loin).
– soit à partir de plusieurs autres types simples via
les opérateurs xsd:union ou xsd:list (cf. plus loin).
2018-2019 XML 20
Les types simples non-prédéfinis
 Exemple de déclaration de type simple :
<xsd:simpleType name="majeur">
<xsd:restriction base="xsd:unsignedByte">
<xsd:minInclusive value="18"/>
</xsd:restriction>
</xsd:simpleType>
2018-2019 XML 21
Les types complexes
 Les types complexes se divisent en 2 catégories.

– Les types complexe à contenu simple : ils sont similaires aux types simple non-
prédéfini mais avec un ajout supplémentaire : la définition d'attributs via l'élément
xsd:attribute. Au moins un attribut doit être décrit.
– Les types complexes à contenu complexe : ils définissent des contenus constitués
d'autres éléments. Le contenu est soit mixte (i.e., éléments + texte), soit homogène
(i.e., uniquement un ensemble d'éléments éventuellement vide). Ils peut également
comprendre des description d'attributs mais cela n'est pas obligatoire.
 Les types complexes peuvent seulement être utilisés pour décrire le type des éléments. Ils
ne peuvent pas servir à typer des attributs.
 Un type complexe peut être construit de 2 manières :
– explicitement (voir diapo suivante)
– implicitement en le dérivant d'un autre type simple ou complexe (cf. les opérations
d'extension ou de restrictions).
 Dans tous les cas, pour définir un type complexe il faut utiliser l'élément xsd:complexType.
2018-2019 XML 22
Les types complexes
 Pour construire un type complexe de manière explicite, on

utilise les opérateurs suivants :
– xsd:sequence
– xsd:choice
– xsd:all. <xsd:element name="livre">
<xsd:complexType>
 Exemple : <xsd:sequence>
<xsd:element name="auteur" type="xsd:string"/>
<xsd:element name="titre" type="xsd:string"/>
<xsd:element name="résumé" type="xsd:string"/>
<xsd:element name="contenu" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
2018-2019 XML 23
Les types complexes
 Pour construire un type complexe de manière implicite via une

dérivation l'élément xsd:complexType doit contenir un élément
xsd:simpleContent (resp. xsd:complexContent) permettant d'indiquer
si le type complexe obtenu sera à contenu simple ou contenu
complexe.
 Ci-dessous les 2 déclarations génériques possibles d'un type
complexe.
 complexe-->
<xsd:complexType ...> <xsd:complexType ...>
<xsd:simpleContent> <xsd:complexContent>
 
... ...
</xsd:simpleContent> </xsd:complexContent>
</xsd:complexType> </xsd:complexType>
2018-2019 XML 24
Les contenu mixtes
 Pour contruire un type mixte (qui est nécessairement un

type complexe à contenu complexe), il faut utiliser l'attribut
mixed de l'élément xsd:complexType.
 Ainsi lorsqu'un type X est défini avec mixed=''true'', chaque
éléments fils d'un élément valide pour X peut être entouré
de texte autre que des caractères d'espacement.
 Le contenu d'un élément de type mixte est valide si et
seulement si son contenu ''nettoyé'' du texte entre ses
éléments fils serait valide si mixed valait ''false''.
2018-2019 XML 25
Les contenu mixtes
 Exemple de type avec contenu mixte :

<xsd:element name="livre">
<xsd:complexType mixed="true">
<xsd:sequence>
<xsd:element name="titre" type="xsd:string"/>
<xsd:element name="auteur" type="xsd:string"/>
<xsd:element name="contenu" type="xsd:string"/>
</xsd:sequence>
</xsd:complex>
 Exemple de document valide :
<livre>
titre : <titre>The shortest book ever</titre>,
Auteur : <auteur>Duschmol</auteur>.
Contenu : <contenu> :-) </contenu>
</livre>
2018-2019 XML 26
Schéma XML : construction de types
simples (non prédéfinis) ou complexes
2018-2019 XML 27
Constructions de
types complexes : élément vide
 Un élément (à contenu) vide est considéré comme un type complexe.
 Exemple de déclaration :
Schéma DTD
<xsd:element name="vide" type="Vide"/> <vide/>

<xsd:complexType name="Vide">
</xsd:complexType>
 Un élément vide peut éventuellement avoir des attributs : la déclaration d'attributs sera
abordée plus loin
2018-2019 XML 28
Constructions de types
complexes : opérateur de
séquence
Schéma DTD
<xsd:element name="personne"> <!ELEMENT personne
<xsd:complexType> (nom, prénom, âge,
<xsd:sequence> nationalité)>
<xsd:element name="nom"
type="xsd:string"/>
<xsd:element name="prénom"
type="xsd:string"/>
<xsd:element name="âge"
type="xsd:string"/>
<xsd:element name="nationalité"
type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
2018-2019 XML 29
complexes : opérateur de choix
Schéma DTD
<xsd:element name="couleur"> <!ELEMENT couleur (rouge | bleu |
<xsd:complexType> jaune)>
<xsd:choice>
<xsd:element ref="rouge"/>
<xsd:element ref="bleu"/>
<xsd:element ref="jaune"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
2018-2019 XML 30
Constructions de
types complexes : élément vide
 L'attribut ref de l'élément xsd:element permet de faire référence un élément défini uniquement
globalement (i.e., qui est fils de l'élément xsd:schema). Un exemple plus complet est donc le suivant
:
<xsd:element name="rouge">
<xsd:complexType/>
</xsd:element>
<xsd:element name="bleu">
<xsd:complexType/>
</xsd:element>
<xsd:element name="jaune">
<xsd:complexType/></xsd:element>
<xsd:element name="couleur">
<xsd:complexType>
<xsd:choice>
<xsd:element ref="bleu"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
2018-2019 XML 31
complexes : opérateur d'ensemble
 L'opérateur xsd:all permet de spécifier que chacun des éléments
enfants peut apparaître dans n'importe quel ordre.
<xsd:element name="couleurs">
<xsd:complexType>
<xsd:all>
<xsd:element ref="bleu" />
</xsd:all>
</xsd:complexType>
</xsd:element>
2018-2019 XML 32
Constructions de types : opérateur
d'ensemble
 Restrictions d'usage :
– xsd:all ne peut pas être le père ou le fils d'un élément
xsd:sequence, xsd:choice ou d'un autre élément xsd:all
– Les indications d'occurrences minOccurs et maxOccurs
apparaissant en attribut de xsd:all ou dans ses fils ne peut
pas avoir n'importe quelle valeur. L'attribut minOccurs (resp.
maxOccurs) vaut forcément 0 ou 1 (resp. forcément 1).
2018-2019 XML 33
d'ensemble
 Dans l'exemple de gauche, les fils de l'élément couleurs peuvent
apparaître 0 ou 1 fois dans un ordre quelconque. Dans l'exemple de
droite, les fils de couleurs doivent apparaître exactement 1 fois (sauf
rouge qui peut ne pas apparaître), et ce dans n'importe quel ordre.
<xsd:element name="couleurs"> <xsd:element name="couleurs">
<xsd:complexType> <xsd:complexType>
<xsd:all minOccurs='0'> <xsd:all>
<xsd:element ref="rouge"/> <xsd:element ref="rouge"
<xsd:element ref="bleu"/> minOccurs='0'/>
<xsd:element ref="jaune"/> <xsd:element ref="bleu"/>
</xsd:all> <xsd:element ref="jaune"/>
</xsd:complexType> </xsd:all>
</xsd:element> </xsd:complexType>
</xsd:element>
2018-2019 XML 34
Constructions de types simples (non-
prédéfinis) : opérateur d'union
 Le constructeur xsd:union permet de définir un nouveau type simple
via l'union d'autres types simples.
 Dans l'exemple ci-dessous, l'élément limite peut avoir comme contenu
un entier, la chaîne +infini ou la chaîne -infini.
<xsd:element name="limite" type="EntierOuInfini"/>
<xsd:simpleType name="EntierOuInfini">
<xsd:union memberTypes="xsd:integer Infini"/>
</xsd:simpleType>
<xsd:simpleType name="Infini">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="+infini"/>
<xsd:enumeration value="-infini"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
2018-2019 XML 35
Constructions de types simples :
opérateur d'union
 Les types simples composant l'union n'ont pas nécessairement besoin
d'être référencés explicitement via l'attribut memberTypes : dans ce
cas ils doivent être défini directement dans l'élément xsd :union.
<xsd:element name="limite" type="EntierOuInfini"/>
<xsd:simpleType name="EntierOuInfini">
<xsd:union memberTypes="xsd:integer">
<xsd:simpleType>
<xsd:enumeration value="+infini"/>
<xsd:enumeration value="-infini"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:union>
</xsd:simpleType>
</xsd:schema>
2018-2019 XML 36
de liste
 L'opérateur xsd:list permet de définir un nouveau type simple qui sera
une liste de valeur dont le type est renseigné via l'attribut itemType de
xsd:list.
 Pour limiter la longueur d'une liste, on passera par l'intermédiaire
d'une restriction de type (cf. plus loin).
Schéma Exemple valide
<xsd:schema <intvalues>100 34 56 -23</intvalues>
xmlns:xsd="http://www.w3.org/2001/XMLSchem
a">
<xsd:element name="intvalues"
type="valuelist"/>
<xsd:simpleType name="valuelist">
<xsd:list itemType="xsd:integer"/>
</xsd:simpleType>
</xsd:schema>
2018-2019 XML 37
Les indicateurs d'occurrences.
 L'attribut minOccurs (resp. maxOccurs) permet de spécifier le nombre

minimal (resp. maximal) de répétitions d'un élément. Ils peuvent être
attribut de xsd:(element|sequence|choice|all).
 La valeur est toujours un entier non négatif sauf pour maxOccurs qui
peut prendre la valeur unbounded (pour indiquer qu'il n'y a pas de
limite).
 La valeur par défaut de minOccurs et maxOccurs est toujours 1.
2018-2019 XML 38
Les répétitions : exemples
Schéma Equivalent DTD
<xsd:element name="items"> <!ELEMENT items (item1, item2+, item3?)>
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="item1"/>
<xsd:element ref="item2" minOccurs="1"
maxOccurs="unbounded"/>
<xsd:element ref="item3" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="items"> <!ELEMENT items (item1, item2)*>

<xsd:complexType>
<xsd:sequence minOccurs="0"
maxOccurs="unbounded">
</xsd:sequence>
</xsd:complexType>
</xsd:element>
2018-2019 XML 39
Schéma XML : déclarations d'attributs
2018-2019 XML 40
Déclarations d'attributs
 Déclarer un attribut est très similaire à la façon de déclarer un

élément.
 Pour la déclaration on utilise xsd:attribute. Les attributs name et type
de xsd:attribute définissent respectivement le nom et le type de
l'attribut.
 Le type de l'attribut peut être décrit à l'intérieur de l'élément
xsd:attribute (et donc on n'utilise pas l'attribut type). Le type d'un
attribut est toujours un type simple.
<xsd:attribute name="listeEntiers">
<xsd:attribute name="entier" <xsd:simpleType>
type="xsd:integer"/> <xsd:list itemType="xsd:integer"/>
</xsd:simpleType>
</xsd:attribute>
2018-2019 XML 41
 On place généralement les déclarations d'attributs dans les définitions

de types (qui sont nécessairement complexes). La définition du type
est alors composée de 2 parties : une première partie contenant la
description du contenu puis une seconde partie contenant la
description des attributs.
2018-2019 XML 42
<xsd:element name="section" type="Section"/>
<xsd:complexType name="Section">
<xsd:sequence maxOccurs="unbounded">
<xsd:element name="chapitre" type="xsd:string"/>
</xsd:sequence>
<xsd:attribute name="numero" type="xsd:nonNegativeInteger"/>
<xsd:attribute name="titre" type="xsd:string"/>
</xsd:complexType>
</xsd:schema>
2018-2019 XML 43
 Comme pour xsd:element, on peut faire référence (via l'attribut ref) à

un attribut défini de manière globale.

</xsd:sequence>

<xsd:attribute ref="titre"/>
</xsd:complexType>
</xsd:schema>
2018-2019 XML 44
 Via l'attribut use on peut rendre un attribut obligatoire (use= ''required''), optionnel
(use=''optional'') ou interdit (use=''prohibited''). Par défaut, un attribut est optionnel.
L'attribut use ne peut pas apparaître dans un attribut défini globalement.
 Les valeurs prohibited et optional sont utilisées principalement lors de restrictions de
type (cf. plus loin).

</xsd:sequence>

<xsd:attribute ref="titre" use="required"/>
</xsd:complexType>
</xsd:schema>
2018-2019 XML 45
 A tout attribut, on peut aussi donner une valeur par défaut via l'attribut
default (utile uniquement quand l'attribut est optionnel) ou alors une
valeur fixe via l'attribut fixed (équivalent de #FIXED dans les DTD).
<xsd:attribute name="entier" type="xsd:integer" default="0"/>
2018-2019 XML 46
Schéma XML : dérivation de types
2018-2019 XML 47
Dérivation de types : extension
 Le principe d'une extension de type est de définir un type à partir d'un autre en rajoutant du contenu
et/ou des attributs.
 L'extension peut se faire à partir d'un type simple ou complexe. Par contre, le résultat est toujours un
type complexe.
 L'opérateur central d'une extension est l'élément xsd:extension : son attribut base spécifie le type à
partir duquel va s'effectuer l'extension. C'est à l'intérieur de l'élément xsd:extension que l'on spécifie
les ajouts par rapport au type désigné par l'attribut base.
 Pour étendre un type simple ou un type complexe à contenu simple il faut utiliser la syntaxe
générique de gauche ci-dessous. Dans le cas contraire, il faut utiliser la syntaxe de droite.
 contenu complexe-->
<xsd:complexType ...> <xsd:complexType ...>
 
... ...
</xsd:complexType> </xsd:complexType>
2018-2019 XML 48
A partir d'un type simple
 L'extension d'un type simple permet uniquement d'ajouter des attributs

(pas d'élément fils) : le résultat est alors toujours un type complexe à
contenu simple.
 Remarque importante : un type complexe à contenu simple ne peut
être obtenu que par restriction ou extension d'un autre type complexe
à contenu simple.
2018-2019 XML 49
A partir d'un type prédéfini :
exemple
Schéma XML
<xsd:schema <objet
xmlns:xsd="http://www.w3.org/2001/XMLSchema prix="15.35">chemise</o
"> bjet>
<xsd:complexType name="Objet">
<xsd:simpleContent>
<xsd:extension base="xsd:string">

<xsd:attribute name="prix"
type="xsd:decimal"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<xsd:element name="objet" type="Objet"/>
</xsd:schema>
2018-2019 XML 50
A partir d'un type complexe à
contenu simple
 Idem que pour passer d'un type prédéfini à un type complexe à

contenu simple. En particulier on ne peut ajouter que des attributs
2018-2019 XML 51
contenu simple : exemple
<?xml version="1.0" encoding="iso-8859-1"?> 
<xsd:schema <xsd:complexType name="ObjetComplexe">
xmlns:xsd="http://www.w3.org/2001/XMLSchema" <xsd:simpleContent>
> <xsd:extension base="Objet">
 
<xsd:attribute name="matière"
type="xsd:string" use='required'/>
<xsd:complexType name="Objet"> <xsd:attribute name="forme"
<xsd:simpleContent> type="xsd:string"/>
<xsd:extension base="xsd:string"> </xsd:extension>
 </xsd:simpleContent>
<xsd:attribute name="prix" </xsd:complexType>
type="xsd:decimal"/>
</xsd:extension> <xsd:element name="objet"
</xsd:simpleContent> type="ObjetComplexe"/>
</xsd:complexType>
</xsd:schema>
La syntaxe suivante est valide pour le schéma du dessus :

<objet matière='soie' prix='12'>chemise</objet>
2018-2019 XML 52
contenu complexe
 Etendre un type complexe à contenu complexe revient à ajouter soit
du contenu soit des attributs (ou les deux à la fois).
 Le contenu et/ou les attributs supplémentaires doivent simplement
être décrits dans la balise xsd:extension. Dans le type complexe
résultat, le contenu viendra à la suite du contenu de base.
2018-2019 XML 53
contenu complexe : exemple
<xsd:schema 
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:complexType name="LivrePlus">
<xsd:complexContent>
<xsd:element name="livre" type="LivrePlus"/> <xsd:extension base="Livre">
 après l'élément titre -->
<xsd:complexType name="Livre"> <xsd:sequence>
<xsd:sequence> <xsd:element name="contenu"
<xsd:element name="titre" type="xsd:string"/> type="xsd:string"/>
</xsd:sequence> </xsd:sequence>
</xsd:complexType> 
<xsd:attribute name="nbpage"
type="xsd:nonNegativeInteger"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
</xsd:schema>
2018-2019 XML 54
(suite)
 Ci-dessous, un document xml valide pour le schéma précédent.
<livre nbpage="1">
<titre>N'importe quoi</titre>
<contenu>Vraiment n'importe quoi</contenu>
</livre>
2018-2019 XML 55
Dérivation de types : restriction
 L'autre façon de construire un type à partir d'un autre type est de

passer par la restriction. Le principe cette fois-ci, n'est plus d'indiquer
ce que l'on va ajouter mais simplement ce qui va changer (dans le
sens de la restriction).
 La restriction peut se faire à partir d'un type simple ou complexe.
 La logique principale à respecter pour la restriction est la suivante : ce
qui est valide pour le type restreint à partir d'un type de base, doit être
également valide pour le type de base.
2018-2019 XML 56
Dérivation de types : restriction
 L'opérateur central d'une restriction est l'élément xsd:restriction : son

attribut base spécifie le type à partir duquel va s'effectuer la restriction.
C'est à l'intérieur de l'élément xsd:restriction que l'on va spécifier les
contraintes restrictives par rapport au type désigné par l'attribut base.
 Pour restreindre un type simple, il faut utiliser la syntaxe générique de
gauche ci-dessous. Pour restreindre un type complexe à contenu
simple, il faut utiliser la syntaxe du milieu. Dans les autres cas, il faut
utiliser la syntaxe de droite.
<xsd:simpleType ...> <xsd:complexType ...> <xsd:complexType ...>
  
... ... ...
</xsd:complexType> </xsd:complexType> </xsd:complexType>
2018-2019 XML 57
 Restriction par borne. Elle s'applique uniquement aux types

numériques et types dates via les éléments minInclusive,
maxInclusive, minExclusive et maxExclusive.
Exemple avec type numérique Exemple avec type date
<xs:element name="age"> <xs:attribute name="date">
<xs:simpleType> <xs:simpleType>
<xs:restriction base="xs:integer"> <xs:restriction base="xsd:date">
<xs:minInclusive value="0"/> <xs:minExclusive value="2019-
<xs:maxInclusive value="120"/> 12-01"/>
</xs:restriction> </xs:restriction>
</xs:simpleType> </xs:simpleType>
</xs:element> </xs:attribute>
2018-2019 XML 58
 Restriction par énumération : peut s'appliquer à tous les types simples.
<xsd:element name="voiture">
<xsd:simpleType>
<xsd:enumeration value="Audi"/>
<xsd:enumeration value="Golf"/>
<xsd:enumeration value="BMW"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
2018-2019 XML 59
 Restriction par motif : peut s'appliquer à tous les types simples.

 La construction d'une expression régulière pour les schémas est
similaire à celles utilisées avec UNIX, Perl, PHP, …. Pour plus d'info,
consulter :
http://www.xmlschemareference.com/regularExpression.html
https://www.w3schools.com/xml/
<xs:element name="password">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="[a-zA-Z0-9]{8}"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
2018-2019 XML 60
 Restriction par longueur : peut s'appliquer uniquement aux types

chaîne et au type contruit via l'opérateur xsd:list. Pour cela on utilise
xsd:length, xsd:minLength ou xsd:maxLength.
<xs:element name="password">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:minLength value="6"/>
<xs:maxLength value="12"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
2018-2019 XML 61
contenu simple
 La restriction d'un type complexe à contenu simple peut porter sur le contenu ou/et
sur les attributs.
 Le résultat d'une restriction d'un type complexe à contenu simple est toujours un type
complexe à contenu simple.
 Le principe est toujours le même : ce qui est valide pour le type restreint à partir d'un
type de base, doit être également valide pour le type de base.
 Pour restreindre le contenu, l'élément xsd:restriction doit contenir l'élément fils
xsd:simpleType qui va décrire explicitement le nouveau type du contenu : ce dernier
devra être obtenu via une restriction du type définissant le contenu du type de base.
 Pour restreindre un attribut, il faut réécrire sa définition : il peut alors avoir un nouveau
type plus restreint, une option qui devient obligatoire, etc. Cette nouvelle définition est
également un fils de l'élément xsd:restriction et apparaît après l'élément
xsd:simpleType, s'il existe.
 Pour garder un attribut inchangé, il suffit de ne pas le mentionner dans la définition du
type restreint.
2018-2019 XML 62
On change le type de contenu mais on ne touche pas aux attributs
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <chaîne format="blabla">cette chaîne n'est
 pas un spam car elle est longue</chaîne>
<xsd:complexType name="Chaîne">
<xsd:simpleContent>
<xsd:extension base="xsd:string"> <spam format="blabla">un spam</spam>
<xsd:attribute name="format" type="xsd:string"/>
</xsd:extension>
</xsd:complexType>

<xsd:complexType name="Spam">
<xsd:simpleContent>
<xsd:restriction base="Chaîne">
<xsd:simpleType>
<xsd:maxLength value="25"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:restriction>
</xsd:complexType>
<xsd:element name="chaîne" type="Chaîne"/>
<xsd:element name="spam" type="Spam"/>
</xsd:schema>
2018-2019 XML 63
On change le type de contenu et le type des attributs
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <chaîne format="bla bla"> bla bla bla</chaîne>
 <spam format="blabla"> bla bla bla</spam>
<xsd:complexType name="Chaîne">
<xsd:simpleContent>
</xsd:extension>
</xsd:complexType>
<xsd:simpleContent>
<xsd:simpleType>
</xsd:restriction>
</xsd:simpleType>

<xsd:attribute name="format" type="xsd:Name"/>
</xsd:restriction>
</xsd:complexType>
<xsd:element name="spam" type="Spam"/>
</xsd:schema> 2018-2019 XML 64
On change le type de contenu et le type des attributs
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <chaîne format="bla bla"> bla bla
 bla</chaîne>
<xsd:complexType name="Chaîne"> <spam format="format1"> bla bla
<xsd:simpleContent> bla</spam>
</xsd:extension>
</xsd:complexType>
<xsd:simpleContent>
<xsd:simpleType>
</xsd:restriction>
</xsd:simpleType>

<xsd:attribute name="format">
<xsd:simpleType>
<xsd:enumeration value="format1"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
</xsd:restriction>
</xsd:complexType>
<xsd:element name="spam"
2018-2019type="Spam"/> XML 65
</xsd:schema>
contenu complexe
 Le principe est similaire à celui utilisé pour les types complexes à
contenu simple.
 En particulier, quand on veut restreindre un contenu complexe, il faut
décrire explicitement le nouveau contenu : ce dernier doit être un fils
direct de xsd:restriction (et non pas un petit fils comme c'est le cas
dans les types complexes à contenu simple) qui est lui-même un fils
de xsd:complexContent.
 Les attributs à modifier sont également fils direct de xsd:restriction et
viennent après la description du nouveau contenu, s'il existe.
 Comme d'habitude, un élément valide pour un type restreint devra être
valide pour le type de base ayant servi à faire la restriction.
2018-2019 XML 66
<xsd:complexType name="type_A"> <A valeur='-5'> bla bla bla</A>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="B" type="xsd:string"/> <A2 valeur='8'>blabla</A2>
<xsd:element name="C" type="xsd:string"/>
<xsd:element name="D" type="xsd:string"/>
</xsd:choice>
<xsd:attribute name="valeur" type="xsd:integer"/>
</xsd:complexType>
<xsd:complexType name="type_A2">
<xsd:complexContent>
<xsd:restriction base="type_A">
<xsd:choice minOccurs="1" maxOccurs="2">
<xsd:element name="B" type="xsd:token"/>
<xsd:element name="D" type="xsd:string"/>
</xsd:choice>
<xsd:attribute name="valeur"
type="xsd:nonNegativeInteger"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<xsd:element name="A" type="type_A"/>

<xsd:element name="A2" type="type_A2"/>
2018-2019 XML 67
Schéma XML : contraintes d'existence et
d'unicité
2018-2019 XML 68
Contraintes d'unicité
 On sait appliquer des contraintes d'unicité sur des attributs en utilisant le type
simple xsd:ID.
 Via l'opérateur xsd:key on peut appliquer des contraintes d'unicité beaucoup
plus générales (sur les attributs et les éléments).
 Au sein d'un schéma XML, l'élément xsd:key est toujours fils d'un élément
xsd:element et est composé :
– d'un élément xsd :selector pour indiquer sur quels éléments porte
la contrainte.
– d'un élément xsd :field pour indiquer ce qui doit être unique.
 Pour les deux éléments xsd:selector et xsd:field les informations sont
données via une expression XPath (voir cours suivant).
 A haut niveau, xsd:key permet de spécifier ce qui serait équivalent à une
contrainte de clé primaire dans une BD
2018-2019 XML 69
 Dans l'exemple, la contrainte d'unicité décrite dans l'élément

bibliothèque permet de spécifier que pour un élément bibliothèque
donné, deux éléments fils « livre » ne peuvent pas avoir le même
attribut « titre ». Par ailleurs, tout élément fils « livre » de
« bibliothèque » doit avoir un attribut « titre ».
<xsd:element name="bibliothèque"
type="Bibliothèque">
<xsd:key name="unicité">
<xsd:selector xpath="livre"/>
<xsd:field xpath="@titre"/>
</xsd:key>
</xsd:element>
2018-2019 XML 70
 La contrainte d'unicité ne peut apparaître qu'à la fin de la description

d'un élément (i.e., après la description éventuelle de son type).
<xsd:element name="bibliothèque">
<xsd:complextype>
…..
</xsd:complextype>
</xsd:key>
</xsd:element>
2018-2019 XML 71
 La valeur qui détermine l'unicité peut être constituée de plusieurs

champs. Il suffit pour cela de mettre plusieurs éléments xsd:field dans
l'élément xsd:key. Dans l'exemple ci-dessous, la contrainte est
respectée si pour tout élément « bibliothèque » donné, deux fils
« livre » ne peuvent pas avoir à la fois le même attribut « titre » et le
même attribut « auteur » (ils peuvent toutefois en avoir un des deux
qui est identique). Par ailleurs, tout élément fils « livre » de
« bibliothèque » doit avoir un attribut « titre » et un attribut « auteur ».
<xsd:element name="bibliothèque"
type="Bibliothèque">
<xsd:field xpath="@auteur"/>
</xsd:key>
</xsd:element>
2018-2019 XML 72
Contraintes d'existence
 On a vu que l'élément xsd:key possède un attribut name (qui est obligatoire). Ce dernier sert
principalement à y faire référence via l'élément xsd:keyref qui généralise la fonction qu'ont
les attributs de types IDREF et IDREFS dans les doctypes.
 L'élément xsd:keyref possède deux attributs : xsd :name et xsd:ref. Le premier donne le nom
de la contrainte et le second donne le nom de l'élément xsd :key (ou xsd:unique) auquel
xsd:keyref fait référence.
 Comme pour xsd:key, l'élément xsd:keyref est composé :
– d'un élément xsd :selector pour indiquer sur quels éléments porte la contrainte.
– d'un ou plusieur élément xsd :field pour indiquer ce qui devra correspondre à une
clé existante (celle renseignée via l'attribut xsd:ref).
 A haut niveau, xsd:keyref permet de spécifier ce qui serait équivalent à une contrainte de
clé étrangère dans une BD.
 Attention : la contrainte key pointée par l'attribut refer de keyref doit être un descendant
de l'élément dans lequel se trouve ce même keyref.
 Comme pour l'élément key, une contrainte de type keyref ne peut apparaître qu'à la fin de
la description d'un élément (i.e., après la description éventuelle de son type).
2018-2019 XML 73
Contraintes d'existence : exemple
 Dans l'exemple ci-dessous, on retrouve notre première contrainte

d'unicité introduite via xsd:key.
 La contrainte d'existence xsd:keyref permet d'indiquer que chaque
descendant ref_livre doit avoir un attribut ref qui doit être égal à un
attribut titre d'un élément livre.
</xsd:key>
<xsd:keyref name="existence" refer="unicité">

<xsd:selector xpath=".//ref_livre"/>
<xsd:field xpath="@ref"/>
</xsd:keyref>
2018-2019 XML 74
Avant de finir : référence à un
schéma XML
 Bien que les schémas XML soient écrits avec un langage de type
XML, le fichier n'a pas cette extension. Un fichier dans lequel est écrit
un schéma XML porte l'extension ".xsd".
 Pour faire référence à un schéma dans un document XML nous
utiliserons la syntaxe générique suivante :
<?xml version="1.0" encoding="UTF-8"?>
<racine xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance"
xsi:noNamespaceSchemaLocation="chemin_vers_fichier.xsd">

</racine>
2018-2019 XML 75

XML Chap3 Schema XML3

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

XML Chap3 Schema XML3

Transféré par

Droits d'auteur :

Formats disponibles

Schéma XML

 Définir ce qui est autorisé, correct et compréhensible

 Il y a 2 solutions pour préciser les balises et attributs

 Les schémas XML

 Définir ce qui est autorisé, correct et compréhensible

 Il y a 2 solutions pour préciser les balises et attributs

 Les schémas XML

<!-- Déclarations d'éléments, d'attributs et définitions de types

 Pour pouvoir mélanger des balises provenant de grammaires

 Pour déclarer un élément il faut utiliser la balise <xsd:element>

 Exemple avec un type prédéfini :

<xsd:element name="entier" type="xsd:integer"/>

 Exemple avec un type défini par nous-même.

 Lorsque le type de l'élément déclaré est prédéfini ou

 Il n'est pas obligatoire de faire référence explicitement à un

 Les types peuvent se classer en 2 catégories :

 A quelques exceptions près, on peut classer les types

 xsd:boolean : true ou false (resp. 1 ou 0)

 xsd:integer : entier de longueur arbitraire.

 xsd:string : chaîne de caractères.

 xsd:time : heure au format hh:mm:ss.

 Comme pour les types prédéfinis, les types simples non-

 Exemple de déclaration de type simple :

 Les types complexes se divisent en 2 catégories.

 Pour construire un type complexe de manière explicite, on

 Pour construire un type complexe de manière implicite via une

 Pour contruire un type mixte (qui est nécessairement un

 Exemple de type avec contenu mixte :

<xsd:element name="vide" type="Vide"/> <vide/>

 L'attribut minOccurs (resp. maxOccurs) permet de spécifier le nombre

<xsd:element name="items"> <!ELEMENT items (item1, item2)*>

 Déclarer un attribut est très similaire à la façon de déclarer un

 On place généralement les déclarations d'attributs dans les définitions

<xsd:element name="section" type="Section"/>

<xsd:attribute name="numero" type="xsd:nonNegativeInteger"/>

<xsd:attribute name="titre" type="xsd:string"/>

 Comme pour xsd:element, on peut faire référence (via l'attribut ref) à

<xsd:element name="section" type="Section"/>

<xsd:attribute name="numero" type="xsd:nonNegativeInteger"/>

<xsd:element name="section" type="Section"/>

<xsd:attribute name="numero" type="xsd:nonNegativeInteger"/>

<xsd:attribute name="entier" type="xsd:integer" default="0"/>

<!-- Type complexe dérivé à <!-- Type complexe dérivé à

 L'extension d'un type simple permet uniquement d'ajouter des attributs

 Idem que pour passer d'un type prédéfini à un type complexe à

La syntaxe suivante est valide pour le schéma du dessus :

 L'autre façon de construire un type à partir d'un autre type est de

 L'opérateur central d'une restriction est l'élément xsd:restriction : son

 Restriction par borne. Elle s'applique uniquement aux types

 Restriction par énumération : peut s'appliquer à tous les types simples.

 Restriction par motif : peut s'appliquer à tous les types simples.

 Restriction par longueur : peut s'appliquer uniquement aux types

<xsd:element name="A" type="type_A"/>

 Dans l'exemple, la contrainte d'unicité décrite dans l'élément

 La contrainte d'unicité ne peut apparaître qu'à la fin de la description

 La valeur qui détermine l'unicité peut être constituée de plusieurs

 Dans l'exemple ci-dessous, on retrouve notre première contrainte

<xsd:keyref name="existence" refer="unicité">

Vous aimerez peut-être aussi