À la différence des éléments, un attribut ne peut être que de type simple. Cela signifie que les attributs, comme avec les DTD, ne peuvent contenir d'autres éléments ou attributs. De plus, les déclarations d'attributs doivent être placées après les définitions des types complexes, autrement dit, après les éléments xsd:sequence, xsd:choice et xsd:all (voir plus loin). Pour mémoire, rappelons que dans une DTD, l'ordre des déclarations n'a pas d'importance.

L'exemple suivant montre la déclaration d'un attribut maj de type xsd:date (un autre type simple) qui indique la date de dernière mise à jour de la liste des contacts.

<?xml version="1.0" encoding="ISO-8859-1"?>
	<xsd:schema xmlns:xsd="http://www.w3.org/2000/10/XMLSchema">   <xsd:element name="contacts" type="typeContacts" />
	  <xsd:element name="remarque" type="xsd:string">     <!-- déclarations de types ici -->
	    <xsd:complexType>
	    <!-- déclarations du modèle de contenu ici -->
	      <xsd:attribute name="maj" type="xsd:date" />
	    </xsd:complexType>
	</xsd:element>
	</xsd:schema>

Tout comme dans une DTD, un attribut peut avoir un indicateur d'occurences.

L'élément attribute d'un Schema XML peut avoir trois attributs optionnels : use, default et fixed. Des combinaisons de ces trois attributs permettent de paramétrer ce qui est acceptable ou non dans le fichier XML final (attribut obligatoire, optionnel, possédant une valeur par défaut...). Par exemple, la ligne suivante permet de rendre l'attribut maj optionnel, avec une valeur par défaut au 11 octobre 2003 s'il n'apparaît pas (le format de date est standardisé : cette date s'écrit donc à l'anglo-saxonne année-mois-jour ; cela permet en outre de plus facilement classer les dates).

<xsd:attribute name="maj" type="xsd:date" use="optional" default="2003-10-11" />

Quand l'attribut fixed est renseigné, la seule valeur que peut prendre l'attribut déclaré est celle de l'attribut fixed. Cet attribut permet de "réserver" des noms d'attributs pour une utilisation future, dans le cadre d'une mise à jour du schéma.

Le tableau suivant présente une comparaison entre le format DTD et le XML Schema.

Table 1. Contraintes d'occurences fixables par les attributs use et default.

Il est à noter que la valeur de l'attribut default doit être conforme au type déclaré. Par exemple...

<xsd:attribute name="maj" type="xsd:date" use="optional" default="-43" />

... produirait une erreur à la validation du schéma.

Un autre type de déclaration d'attributs dans les DTD, la liste de choix, est possible grâce à une restriction de type ; nous y reviendrons.

XML Schema propose une fonctionnalité supplémentaire, permettant de déclarer des groupes d'attributs (groupes auxquels il est possible de faire appel lors d'une déclaration d'éléments). Cela permet d'éviter de répéter des informations de déclarations.

Un tel élément est de type complexe, car il contient au moins un attribut. Afin de spécifier qu'il peut contenir également du texte, on utilise l'attribut mixed de l'élément xsd;complexType. Par défaut, mixed="false"; il faut dans ce cas forcer mixed="true". Par exemple,

<xsd:element name="elt">
	  <xsd:complexType mixed="true">
	    <xsd:attribute name="attr" type="xsd:string" use="optional" />
	  </xsd:complexType>
	</xsd:element>

Les types de données simples ne peuvent comporter ni attributs, ni éléments enfants. Il en existe de nombreux, prédéfinis, mais il est également possible d'en "dériver" de nouveaux (nous reviendrons plus loin sur cette fonctionnalité). Enfin, il est possible de déclarer des "listes" de types.

Nombreux sont les types prédéfinis dans la bibliothèque de types intégrés de XML Schema. la figure suivante en donne la hiérarchie, et leur liste détaillée figure sur le site du W3C.

Les types de données les plus simples (les chaînes de caractères) que permettaient les DTDs sont conservés, mais d'autres ont fait leur apparition. On pourra envisager, par exemple, dans un schéma décrivant un bon de commande, la déclaration d'un attribut quantite :

<xsd:attribute name="quantite" type="xsd:positiveInteger" use="default" value="1" />

... qui force la valeur de l'attribut à un être un entier positif. Un bon de commande XML suivant ce schéma, ayant une commande spécifiant quantite="-3" sera alors automatiquement refusé par le système. Un document respectant un tel schéma peut dès lors être enregistré directement dans une base de données, sans contrôle supplémentaire sur ce point.

Les types listes sont des suites de types simples (ou atomiques). XML Schema possède trois types de listes intégrés : NMTOKENS, ENTITIES et IDREFS. Il est également possible de créer une liste personnalisée, par « dérivation » de types existants. Par exemple,

<xsd:simpleType name="numéroDeTéléphone">
	  <xsd:list itemType="xsd:unsignedByte" />
	</xsd:simpleType>

Un élément conforme à cette déclaration serait <téléphone>01 44 27 60 11</téléphone>.

Il est également possible d'indiquer des contraintes plus fortes sur les types simples ; ces contraintes s'appellent des « facettes ». Elles permettent par exemple de limiter la longueur de notre numéro de téléphone à 10 nombres. Nous reviendrons sur les facettes.

Les listes et les types simples intégrés ne permettent pas de choisir le type de contenu d'un élément. On peut désirer, par exemple, qu'un type autorise soit un nombre, soit une chaîne de caractères particuliers. Il est possible de le faire à l'aide d'une déclaration d'union. Par exemple, sous réserve que le type simple numéroDeTéléphone ait été préalablement défini (voir précédemment), on peut déclarer...

<xsd:simpleType name="numéroDeTéléphoneMnémoTechnique">
	  <xsd:union memberTypes="xsd:string numéroDeTéléphone" />
	</xsd:simpleType>

Les éléments suivants sont alors des "instances" valides de cette déclaration :

<téléphone>18</téléphone>
	<téléphone>Pompiers</téléphone>

Un élément de type simple ne peut contenir pas de sous-élément. Il est nécessaire pour cela de le déclarer de type complexe. On peut alors déclarer des séquences d'éléments, des types de choix ou des contraintes d'occurences

Nous savons déjà comment, dans une DTD, nous pouvons déclarer un élément comme pouvant contenir une suite de sous-éléments dans un ordre déterminé. Il est bien sûr possible de faire de même avec un schéma.

On utilise pour ce faire l'élément xsd:sequence, qui reproduit l'opérateur , du langage DTD. Ainsi...

<xsd:complexType>
	  <xsd:sequence>
	    <xsd:element name="nom" type="xsd:string" />
	    <xsd:element name="prénom" type="xsd:string" />
	    <xsd:element name="dateDeNaissance" type="xsd:date" />
	    <xsd:element name="adresse" type="xsd:string" />
	    <xsd:element name="adresseElectronique" type="xsd:string" />
	    <xsd:element name="téléphone" type="numéroDeTéléphone" />
	  </xsd:sequence>
	</xsd:complexType>

... est équivalent à une déclaration d'élément, dans une DTD, où apparaîtrait (nom, prénom, dateDeNaissance, adresse, adresseElectronique, téléphone).

On peut vouloir modifier la déclaration de type précédente en stipulant qu'on doive indiquer soit l'adresse d'une personne, soit son adresse électronique. Pour cela, il suffit d'utiliser un élément xsd:choice :

<xsd:complexType name="typePersonne">
	  <sequence>
	    <xsd:element name="nom" type="xsd:string" />
	    <xsd:element name="prénom" type="xsd:string" />
	    <xsd:element name="dateDeNaissance" type="xsd:date" />
	    <xsd:choice>
	      <xsd:element name="adresse" type="xsd:string" />
	      <xsd:element name="adresseElectronique" type="xsd:string" />
	    </xsd:choice>
	  </sequence>
	  <xsd:element name="téléphone" type="numéroDeTéléphone" />
	</xsd:complexType>

Ce connecteur a donc les mêmes effets que l'opérateur | dans une DTD.

Cet élément est une nouveauté par rapport aux DTD. Il indique que les éléments enfants doivent apparaître une fois (ou pas du tout), mais dans n'importe quel ordre. Cet élément xsd:all doit être un enfant direct de l'élément xsd:complexType. Par exemple...

<xsd:complexType>
	  <xsd:all>
	    <xsd:element name="nom" type="xsd:string" />
	    <xsd:element name="prénom" type="xsd:string" />
	    <xsd:element name="dateDeNaissance" type="xsd:date" />
	    <xsd:element name="adresse" type="xsd:string" />
	    <xsd:element name="adresseElectronique" type="xsd:string" />
	    <xsd:element name="téléphone" type="numéroDeTéléphone" />
	  </xsd:all>
	</xsd:complexType>

... indique que chacun de ces éléments peut apparaître une fois ou pas du tout (équivalent de l'opérateur ? dans une DTD), et que l'ordre des éléments n'a pas d'importance (cela n'a pas d'équivalent dans une DTD).

Dans une DTD, un indicateur d'occurence ne peut prendre que les valeurs 0, 1 ou l'infini. On peut forcer un élément sselt à être présent 378 fois, mais il faut pour cela écrire (sselt, sselt..., sselt, sselt) 378 fois. XML Schema permet de déclarer directement une telle occurence, car tout nombre entier non négatif peut être utilisé. Pour déclarer qu'un élément peut être présent un nombre illimité de fois, on utilise la valeur unbounded. Les attributs utiles sont minOccurs et maxOccurs, qui indiquent respectivement les nombres minimal et maximal de fois où un élément peut apparaître. Le tableau suivant récapitule les possibilités :

Table 2. Liste des indicateurs d'occurence.

Il est possible également de créer un type complexe à partir d'un type simple.

On peut avoir besoin de définir un élément contenant une valeur simple, et possédant un attribut, comme <poids unite="kg">67</poids>, par exemple. Un tel élément ne peut pas être déclaré de type simple, car il contient un attribut. Il faut dériver un type complexe à partir du type simple positiveInteger :

<xsd:complexType name="typePoids">
	  <xsd:simpleContent>
	    <xsd:extension base="xsd:positiveInteger">
	      <xsd:attribute name="unite" type="xsd:string" />
	    </xsd:extension>
	  </xsd:simpleContent>
	</xsd:complexType>

L'élément xsd:simpleContent indique que le nouvel élément ne contient pas de sous-élément.

Exercice 1. Déclaration d'éléments

Nous allons reprendre le texte d'un exercice sur les DTD, mais cette fois-ci avec un schéma. On ne déclarera, pour le moment, que des types de chaînes de caractères.

Rédiger un Schema XML pour une bibliographie. Cette bibliographie :

• contient des livres et des articles ;
• les informations nécessaires pour un livre (élément livre) sont :
  • son titre général (élément titre) ;
  • les noms des auteurs (éléments auteur) ;
  • ses tomes (élément tomes) et pour chaque tome (éléments tome), leur nombre de pages (élément pages) ;
  • des informations générales sur son édition (élément infosEdition)comme par exemple le nom de l'éditeur (élément editeur), le lieu d'édition (élément lieuEdition), le lieu d'impression (élément lieuImpression), son numéro ISBN (élément ISBN) ;
• les informations nécessaires pour un article (élément article) sont :
  • son titre (élément titre) ;
  • les noms des auteurs (éléments auteur) ;
  • ses références de publication (élément infosPublication) : nom du journal (élément nomJournal), numéro des pages (élément pages), année de publication (élément anneePublication) et numéro du journal (élément numéroJournal)
• on réservera aussi un champ optionnel, pour chaque livre et chaque article, pour un avis (élément avis) personnel.

Tester ce Schema XML avec un fichier XML que l'on écrira ex-nihilo et validera.

Correction

Exercice 2. Déclaration d'attributs

Modifier le Schéma précédent... On ne déclarera, pour le moment, que des types de chaînes de caractères.

• ... en ajoutant un attribut optionnel soustitre à l'élément titre ;
• ... en faisant de l'élément tome un élément vide et en lui ajoutant un attribut requis nbPages et un attribut optionnel sousTitre ;
• ... en faisant de l'élément nomJournal un attribut de l'élément infosPublication et en lui donnant comme valeur par défaut Feuille de Chou ;

Utiliser ce Schéma pour créer un fichier XML valide.

Correction

Exercice 3. Déclaration de types

Nous allons modifier le Schema précédent pour tirer parti des fonctionnalités additionnelles de ce format, relatives ayx types de données.

A. Utilisation des types intégrés

1. L'élément pages doit être un entier positif, ainsi que l'élément numéroJournal.
2. L'élément anneePublication doit être déclaré comme... une année.

B. Déclarations de types

Nous allons maintenant définir nos propres types de données, en les dérivant par rapport aux types intégrés.

1. Définir un type simple nommé typeISBN, basé sur une restriction du ype xsd:string, se limitant à une chaîne de caractères composée de 10 chiffres. L'utiliser dans la déclaration de l'élément ISBN.
2. En s'inspirant de l'exemple donné en cours du formatage d'une adresse électronique, déclarer un type typePages, basé sur une restriction du type xsd:string, se limitant à un nombre, puis la chaîne de caractères " à ", puis un autre nombre.

On vérifiera le fonctionnement à l'aide d'un fichier XML.

Correction

On peut appliquer une dérivation aussi bien à un type simple, qu'à un type complexe. La dérivation par restriction permet de créer de nouveaux types simples à partir des types simples prédéfinis par le format XML Schema. On utilise pour ce faire des facettes, qui sont des contraintes supplémentaires appliquées à un type simple particulier.

Une facette permet de placer une contrainte sur l'ensemble des valeurs que peut prendre un type de base. Par exemple, on peut souhaiter créer un type simple, appelé MonEntier, limité aux valeurs comprises entre 0 et 99 inclus. On dérive ce type à partir du type simple prédéfini nonNegativeInteger, en utilisant la facette maxExclusive.

<xsd:simpleType name="monEntier">
	  <xsd:restriction base="nonNegativeInteger">
	    <xsd:maxExclusive value="100" />
	  </xsd:restriction>
	</xsd:simpleType>

Il existe un nombre important de facettes qui permettent de :

• fixer, restreindre ou augmenter la longueur minimale ou maximale d'un type simple
• énumérer toutes les valeurs possibles d'un type
• prendre en compte des expressions régulières
• fixer la valeur minimale ou maximale d'un type (voir l'exemple ci-dessus)
• fixer la précision du type...

On peut utiliser cette fonctionnalité pour reproduire ce qui, dans les DTD, permettait de limiter les valeurs de certains attributs. Ainsi...

<xsd:attribute name="jour" type="typeJourSemaine" use="required" />
	<xsd:simpleType name="typeJourSemaine">
	  <xsd:restriction base="xsd:string">
	    <xsd:enumeration value="lundi" />
	    <xsd:enumeration value="mardi" />
	    <xsd:enumeration value="mercredi" />
	    <xsd:enumeration value="jeudi" />
	    <xsd:enumeration value="vendredi" />
	    <xsd:enumeration value="samedi" />
	    <xsd:enumeration value="dimanche" />
	  </xsd:restriction>
	</xsd:simpleType>

Pour limiter la longueur d'une chaîne :

<xsd:simpleType name="typeMotLangueFrancaise">
	  <xsd:restriction base="xsd:string">
	    <xsd:length value="21" />
	  </xsd:restriction>
	</xsd:simpleType>

Plus complexe, on peut utiliser des expressions régulières, qui permettent de spécifier quels sont les caractères autorisés, à l'aide de l'élément xsd:pattern. Par exemple...

<xsd:simpleType name="typeAdresseElectronique">
	  <xsd:restriction base="xsd:string">
	    <xsd:pattern value="(.)+@(.)+" />
	  </xsd:restriction>
	</xsd:simpleType>

Dans cet exemple, (.)+ signifie que l'on peut mettre n'importe quel caractère au moins une fois, et qu'entre les deux chaînes doit impérativement apparaître le caractère @.

Un numéro ISBN est un référent international pour une publication. Il s'agit d'un numéro à 10 ou 13 chiffres. On peut le déclarer ainsi :

<xsd:simpleType name="typeISBN">
	  <xsd:restriction base="xsd:string">
	    <xsd:pattern value="[0-9]{10}" />
	  </xsd:restriction>
	</xsd:simpleType>

Bien sûr, toutes les facettes ne sont pas acceptées par tous les types. Il serait fastidieux ici d'en donner la liste ; elle est accessible sur le site du W3C à l'adresse http://www.w3.org/TR/xmlschema-0/#SimpleTypeFacets.