Exemples!

<?xml version="1.0" ?>
<frac>
  <numerateur>1</numerateur>
  <denom>x <sup>n</sup></denom>
</frac>

<?xml version="1.0" ?>
<livre>
  <auteur>W. Shaekspeare</auteur>
  <titre>Hamlet </titre>
</livre>

<?xml version="1.0" ?>
<memo>
  <de>Président</de>
  <date>15/05/2006 </date>
  <message>
    <b>Rappeler</b>
    Premier Ministre
    <em>demain 10h</em>
  </message>
</memo>

Remarques

Donne une syntaxe mais pas de sémantique
Définit du contenu et de la structure
Un document XML peut être :
- Un fichier
- Un enregistrement dans un SGBD
- Un objet
- Un stream dans une socket

Standards XML et affiliés

Balisage : XML
Définition de format : DTD, XML Schema, RELAX NG
Liens : Namespace, XPointer, XLink
Styles : CSS, XSL
Transformation : XSLT, XSL-FO
Requêtes : XPath, XQL
APIs : DOM, SAX
Scripts : JavaScript, JScript
...

Quelques Acteurs incontournables

W3C : instance de standardisation des protocoles de l'internet
OASIS : Organization for the Advancement of Structured Information Standards (was SGML Open)
Fondation Apache
- Cocoon, Xerces, Xalan, FOP, Batik, XML Graphics, ...
- liste des projets Apache
...

XML pour quoi faire ?

Publication électronique
Applications WEB
Échanges de données entre applications
Bases de données
...

Xml en détails

Structure arborescente
Langage balisé à la HTML ( avec éléments et attributs)
Balises en minuscules
Toute balise ouverte est fermée
Choix des éléments libre
Valeurs des attributs 'quotés'
Identifiant unique des éléments (ID)
Contenu et noms internationalisés : Unicode

Exemple d'instance

<?xml version="1.0">
<memo xml:lang="fr">
	<a>D. Vador</a>
	<de>L. Skywalker</de>
	<date>20/03/24532</date>
	<message> 
		<p>Rendez-vous confirmé
		<em>demain 10h00</em></p>
	</message>
</memo>

La DTD

Document Type Definition
Contient la déclaration des éléments utilisés dans le document xml
Fournit une structure type de document
Permet de vérifier la validité des docs
Les DTD contiennent la définition des :
- Éléments
- Attributs des éléments
- Contenus des éléments

Exemple de DTD

<!ELEMENT MEMO (A, DE, DATE, SUJET?, MESSAGE) >
<!ATTLIST MEMO SECURITE (public|personnel) 'public'
                  STATUS (provisoire|final) #REQUIRED>
<!ELEMENT A (#PCDATA)>
<!ELEMENT DE(#PCDATA)>
<!ELEMENT DATE (#PCDATA)>
<!ELEMENT SUJET (#PCDATA)>
<!ELEMENT MESSAGE (P+)>
<!ELEMENT P (#PCDATA|EM)*>
<!ELEMENT EM (#PCDATA)>

Pourquoi valider ?

La validation fournit une interface garantie
Les producteurs valident pour assurer qu'ils livrent ce qu'ils promettent
Les consommateurs valident pour vérifier ce qu'ils reçoivent
Les auteurs d'application valident pour simplifier leur tâche
La DTD permet / assure la validation

Documents biens formés / valides

Document bien formé :
- Respecte les règles syntaxiques d'XML :
  - Tout élément est inclus dans son père.
  - Il n'y a qu'un seul élément racine.
  - La structure est arborescente.
Document valide :
- Document bien formé
- Respecte une structure type définie explicitement dans une DTD ou dans un XMLSchema

Structure d'un document bien formé

Prologue (facultatif)
Arbre d'éléments
- Ensemble de balises structurées
- Sections littérales
- Entités prédéfinies
Des commentaires et autres instructions de traitement facultatives

Le Prologue

Déclaration XML
- Version du langage utilisé
- Déclaration de l'encodage
- Référence éventuelle à une DTD externe
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?>
Des instructions de traitement destinées aux applications

Déclaration de type de document

Avec le mot-clé DOCTYPE :
- Spécifie le type de document
- Permet l'appel d'une DTD externe ou la définition d'une DTD interne
- Autorise la validation du document

<!DOCTYPE ptmess SYSTEM "ptmess.dtd">
<!DOCTYPE ptmess [
<!ELEMENT MEMO (A, DE, DATE, SUJET?, MESSAGE) >
...
>

Les éléments

Même principe que pour html
- '<' + nom + '>' + contenu + '</' + nom + '>'
- '<' + nom + ' />'
Respectent la casse
[a-zA-Z_][a-zA-Z0-9-_.]*
':' réservé pour les namespaces
Pas d'espace
Ne débutant pas par xml ou XML

Les attributs

'<' + elem-nom [+ att-nom + '=' + "val-att" ]* + '>'
Les attributs sont propres à un élément
Ils décrivent certaines propriétés de l'élément
Quelques attributs prédéfinis
- xml:lang : déclaration de la langue utilisée dans l'élément
- xml:space : mode de gestion du blanc
- ...

Sections littérales

Avec le mot -clé CDATA
- Déclaration d'une section de "texte brut" qui ne sera pas analysé par le parser validant
- Peut tout contenir sauf ]] qui marque la fin

Exemple

<element>
<! [CDATA[ <tag>contenu</tag> ]]>
</element>

Réalisation
```
<tag>contenu</tag>
```

Entités prédéfinies et Caractères

Comme en HTML, permet d'insérer des caractères propres au langage dans le contenu.
- < : <
- > : >
- & : &
- ' : '
- " : "
Caractères diacritiques ou autres

Commentaires et Instructions

Les commentaires
- Débutent par
Les instructions de traitement
- <?cible [argi]* ?>
- cible : nom d'une application ou d'une fonction d'une application
- argi : chaîne de caractères que l'analyseur passera inchangée à l'application cible

Les namespaces

Domaines nominaux
Permettent de mélanger des éléments déclarés dans plusieurs DTD sans conflit de nommage
Déclaration par un attribut commençant par xmlns ou xmlns:
```
<html xmlns:html='http://www.w3.org/TR/REC-html40' >
```

Utilisation des éléments avec préfixe
```
<html:h1>Titre html </html:h1>
```

Les namespaces

Tout élément peut être associé à un namespace, dans ce cas, le champ d'utilisation du namespace est associé au sous arbre délimité par l'élément
Facilite le travail normatif en sous-groupes
Évite de choisir des noms complexes
Facilite l'utilisation conjointes de recommandations XML composites comme XSLT, XSL et HTML sans risque de conflits de noms

Exemple d'utilisation de namespaces multiples (W3C)

<?xml version="1.0"?>
<!-- initially, the default namespace is "books" -->
<book xmlns='urn:loc.gov:books'
      xmlns:isbn='urn:ISBN:0-395-36341-6'>
  <title>Cheaper by the Dozen</title>
  <isbn:number>1568491379</isbn:number>
  <notes>
  <!-- make HTML the default namespace for some commentary -->
    <p xmlns='urn:w3-org-ns:HTML'>
     This is a <i>funny</i> book!
    </p>
  </notes>
</book>

Références

http://www.w3.org/TR/2004/REC-xml-20040204/
http://www.w3.org/TR/REC-xml-names/

Document Type Definition

Permet de passer à la validation d'un document bien formé
Un document valide est une instance de la structure définie dans une DTD
Déclare les éléments et définit leur utilisation (attributs et éléments internes)
C'est un outil de spécification

Déclaration d'un élément

Le mot-clé ELEMENT
- '<!ELEMENT ' + nom + modèle + '>'
Nom : nom de l'élément
Modèle : éléments fils possibles entre '(' et ')'
- séquence de noms d'éléments ou de type d'éléments
- peuvent être obligatoires ou facultatifs
- peuvent être ordonnés ou non
- séparateurs :
  - ',' : enchainement ordonné
  - '|' : choix parmi plusieurs possibilités

Contenu d'un élément

Chaque élément fils peut être :
- Obligatoire, non répétable (non marqué)
- Optionnel, non répétable : ?
- Optionnel, répétable : *
- Obligatoire, répétable : +

Exemple :

<!ELEMENT CHAPITRE (TITRE, SECTION+) >
<!ELEMENT LIVRE (TITRE, (TITRE,CHAPITRE)+, ANNEXE*) >

Contenu d'un élément

Données
- Mot-clé #PCDATA
- Flot quelconque de caractères
Mixage de données et d'éléments fils
Libre
- Mot-clé ANY
- Doit respecter la syntaxe générale du langage
Vide
- Mot-clé EMPTY

Déclaration d'une liste d'attributs

Le mot-clé ATTLIST
- Pour déclarer les attributs obligatoires ou non
- Pour donner des valeurs par défaut et un type

<!ATTLIST nom-élément nom-attribut
             type-attribut val-defaut>

Types d'attributs

CDATA : chaînes de caractères littérale
ID ou IDREF : renvois à l'intérieur des documents
ENTITY : nom d'une entité externe xml
NMTOKEN : nom symbolique quelconque formés de caractères alphanumériques
NOTATION : attribut de notation
Liste de choix : choix parmi plusieurs tokens

Déclaration de valeurs par défaut

'valeur' : valeur par défaut
#REQUIRED : attribut obligatoire
#IMPLIED : attribut facultatif
#FIXED 'valeur' : attribut fixé à une valeur

<!ELEMENT employe (#PCDATA)>
<!ATTLIST employe nom CDATA #REQUIRED
                  nb (1|2|3) '1'>

Attributs prédéfinis

xml:lang et xml:space
Doivent être déclarés en cas d'utilisation

<!ATTLIST poésie xml:lang NMTOKEN 'fr'>
<!ATTLIST poème xml:space (default|preserve)
                          'preserve'>

Structuration en entités

Pour déclarer des blocs d'information
Utilisation :
- Dans la DTD : entités paramètres
- Dans le document XML : entités générales
Origine :
- Internes : contenu associé à la déclaration
- Externes : contenu reférencé

Entités générales

Entités générales :

Déclaration dans la DTD

Utilisation dans l'instance

<!ATTLIST image href ENTITY #REQUIRED>
<!ENTITY maphoto SYSTEM "foto.png">

<image href="&maphoto;" />

Utilisées dans l'instance des documents
- Pour stocker des données non XML
- Pour modulariser un document

Entités générales internes

Permet de ne pas réécrire plusieurs fois la même chaîne de caractères
Référence : '&' + nom-entité +';'

<!DOCTYPE test [
     <!ENTITY ref "UFR S&T" >
  ]>

  <test>
  <p>&ref;</p>
  </test>

Entités générales externes

Pour intégrer un document XML bien formés à l'intérieur d'un autre document XML
Entités externes adressées par URL
- Mot-clé SYSTEM
- Références des entités externes

<!DOCTYPE bouquin [
  <!ENTITY chap1 SYSTEM "./chap1.xml">
  <!ENTITY chap2 SYSTEM "./chap2.xml">
]>

<bouquin> &chap1; &chap2; </bouquin>

Entités générales externes et FPI

Pour l'application traitant le document
- Mot-clé PUBLIC
- Adressé par FPI : Formal Public Identifier
<!ENTITY nom PUBLIC FPI URL>
- Nom : nom donné à l'entité
- L'url est utilisée ssi l'application ne sait pas résoudre la FPI

Un FPI est composé de 4 parties séparées par //

<!ENTITY rec-XML PUBLIC
"-//W3C//DOCUMENT Recommandation open-The recommandation
for XML 1.0//EN"
"http://www.w3.org/TR/1999/REC-xml-19992312.xml">

Entités générales externes et FPI

Type d'identificateur :
- Enregistré (+)
- Non enregistré (-)
- ISO (ISO 8879:1986)
Propriétaire de l'identificateur public :
- Ne s'applique pas aux identificateurs ISO
Texte public composé d'un mot-clé, et d'une description libre (DOCUMENT, DTD, ENTITIES, SHORTREF, SUBDOC, NOTATION)
Indication de la langue (ISO 639)

Entités générales externes (non xml)

Association au mot-clé NDATA
- Définition d'entités non XML
Déclaration du format de l'entité
- Pour une application capable de traiter ce format
Utilisation du mot-clé NOTATION
- Bloc non analysé par le parser XML
- Association à une application pour le traitement
- Uniquement pour une valeur d'attribut

<!DOCTYPE TEST [
<!ENTITY monimage SYSTEM "logo.png" NDATA GIF>
<!NOTATION GIF SYSTEM "/usr/bin/gimp"> ]>

Exemple

<!DOCTYPE test [
<!NOTATION vrml SYSTEM "/usr/bin/VRMLViewer">
<!ENTITY labyrinthe SYSTEM "lab.vrml" NDATA vrml>
]>

<test>
  <graph3D loc="labyrinthe" />
</test>

Entités paramètres

Entités paramètres :

Déclaration et utilisation dans la DTD

<!ENTITY % origine "Université du Havre">
<!ENTITY % rédacteur "DF - %origine;">

Pour paramétrer une DTD ou des déclarations de balisage
Entités locales
Utilisation de '%'
Déclaration et référence à l'intérieur d'une même DTD
Mot-clé NDATA interdit

Entités paramètres

<!ENTITY % nl "numérotée">
<!ENTITY % ol "ordonnée">
<!ELEMENT liste EMPTY>
<!ATTLIST liste type (%nl; | %ol;) "%nl;">
<!ENTITY % heading "h1|h2|h3|h4|h5|h6">
<!ELEMENT titre (%heading;)>

Possibilités de déclarer un élément de façon confidentielle ou publique (INCLUDE IGNORE )

<!ENTITY % confidentiel 'INCLUDE'>
<!ENTITY % public 'IGNORE'>
<![ %confidentiel; [ <!ELEMENT ... ]]>
<![ %public; [ <!ELEMENT ...]]>

2 instances d'une DTD possibles

Bilan sur les DTD

Modularité, réutilisabilité
Déclarations d'entités paramètres
- Pour la déclaration d'attributs
- Pour les modèles de contenu
Simplicité du modèle de contenu
Facilité d'insertion des commentaires
Typage des attributs très limité
Pas XML
Pas objet, et namespaces mal supportés
Vers XML Schema pour définir des formats XML

La prochaine étape

On sait :
- Définir un format XML
- Créer un document XML bien formé
Il reste :
- À vérifier sa validité à l'aide d'un parser pour :
  - Lire et analyser les DTDs
  - Lire et analyser les instances
- Quelques parsers disponibles :
  - Xerces (apache.org)
  - PHP XML Parser
  - Microsoft XML Parser,
  - ...

XML Schema

Vers une description précise des documents XML

D. Fournier

Inspiré du cours de C. Turbout

Références

La norme (recommandation depuis le 2 mai 2001) :
- http://www.w3.org/XML/Schema/
- Definition : http://www.w3.org/TR/xmlschema-0/
- Structures : http://www.w3.org/TR/xmlschema-1/
- Types : http://www.w3.org/TR/xmlschema-2/
Les outils de validation :
- XSV en ligne : http://www.w3.org/2001/03/webdata/xsv/
- Toutes plate-formes (java) : http://xerces.apache.org/xerces2-j/
- Autres outils : http://www.w3.org/XML/Schema#Tools
Transformation DTD XML Schema :
- https://www.freeformatter.com/xsd-generator.html

Fonctionnalités

XML Schema et DTD ont pour but de :
- structurer le contenu des documents ;
- fournir une documentation sur le contenu d'un document ;
- aider à la création de documents structurés.
Ils doivent permettre :
- Définition d'un ensemble d'éléments et d'attributs.
- Transformation du document.
- Validation du document.

Pourquoi ces fonctionnalités ?

Pour gagner du temps : la validation des entrées/sorties représente la part la plus importante d'un programme et bien souvent la plus buguée.
Simplifier les évolutions : le code à modifier le plus important est celui qui réalise les fonctionnalités, pas les entrées/sorties.
Pour gagner de l'argent : moins de temps de developpement signifie moins d'argent perdu et moins de bugs. Le processus d'entrée/sortie consiste simplement à valider le document avec le schéma pour être sûr de sa forme et de ses types.
Pour obtenir des informations sur les données : le XMLSchema contient une source de meta-donnees.
Accessoirement, si les noms des éléments (balises) sont bien définis, le document XML est humainement compréhensible.

XML Schema vs DTD (1/2)

Les DTD sont limitées :
- Définition d'une instance de document XML et de sa description avec des syntaxes différentes (la DTD n'est pas définie en XML).
- Spécification des types de donnees limitée (entier ∈[13;20000] est impossible).
- Types prédéfinis restreints (10) et incompatibles avec ceux des SGBD.

XML Schema vs DTD (2/2)

Les avantages de XML Schema :
- Écrit dans la même syntaxe que l'instance du document (XML Schema est en XML).
- Orienté objet : restriction ou extension possible des types existants.
- 44 types de données prédéfinis.
- Création de nouveaux types de données possible.
- Notion d'ordre modulable dans les fils d'un élément (ordre strict ou pas d'ordre).
- Occurrence des éléments modulable.
- Définition possible d'éléments ayant un contenu vide.

Transformation de la DTD librairie.dtd en librairie.xsd

<!ELEMENT Librairie (Livre)+>
<!ELEMENT Livre (Titre, Auteur, Date, ISBN, Editeur)>
<!ELEMENT Titre(#PCDATA)>
<!ELEMENT Auteur(#PCDATA)>
<!ELEMENT Date(#PCDATA)>
<!ELEMENT ISBN(#PCDATA)>
<!ELEMENT Editeur(#PCDATA)>

Langage utilisé pour les deux représentations

Librairie, Livre, Titre, Auteur, Date, ISBN, Editeur sont définis grâce au vocabulaire :
DTD : ELEMENT, ATTLIST, #PCDATA, ID, NMTOKEN, CDATA, ENTITY
XMLSchema : schema, element, sequence, complexType, boolean, string, integer
Principal différence entre DTD et XMLSchema :
- le vocabulaire des DTD est fixe.
- le vocabulaire des XMLSchema est associé à un espace de nom (namespace).
Le nouveau vocabulaire contenu dans un XMLSchema doit absolument etre associé à un espace de nom pour être défini de façon unique.

Librairie.xsd

<?xml version="1.0">
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.librairie.org"
            xmlns="http://www.librairie.org" elementFormDefault="qualified">
  <xsd:element name="Librairie">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="Livre" minOccurs="1" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
  <xsd:element name="Livre">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="Titre" minOccurs="1" maxOccurs="1"/>
        <xsd:element ref="Auteur" minOccurs="1" maxOccurs="1"/>
        <xsd:element ref="Date" minOccurs="1" maxOccurs="1"/>
        <xsd:element ref="ISBN" minOccurs="1" maxOccurs="1"/>
        <xsd:element ref="Editeur" minOccurs="1" maxOccurs="1"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
  <xsd:element name="Titre" type="xsd:string"/>
  <xsd:element name="Auteur" type="xsd:string"/>
  <xsd:element name="Date" type="xsd:string"/>
  <xsd:element name="ISBN" type="xsd:string"/>
  <xsd:element name="Editeur" type="xsd:string"/>
</xsd:schema>

Caractéristiques d'un XMLSchema

<?xml version="1.0" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.librairie.org"
            xmlns="http://www.librairie.org"
            elementFormDefault="qualified">
...
</xsd:schema>

Tout XMLSchema a comme racine l'élément xsd:schema
xmlns:xsd="http://www.w3.org/2001/XMLSchema" : les types utilisés pour construire ce schema viennent de ce namespace.
targetNamespace="http://www.librairie.org" : les éléments définis dans ce schema décrivent ce namespace.
xmlns="http://www.librairie.org" : le namespace par défaut.
elementFormDefault="qualified" : tous les documents qui vont répondre à ce schema doivent répondre au namespace défini.

Exemple de document XML

<?xml version="1.0" ?>
<Librairie xmlns="http://www.librairie.org"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.librairie.org
                               librairie.xsd">
  <Livre>
    <Titre>Le guide du routard Galactique</Titre>
    <Auteur>Douglas Adams</Auteur>
    <Date>1979</Date>
    <ISBN>0345391802</ISBN>
    <Editeur>Ballantine Books</Editeur>
  </Livre>
</Libraire>

xmlns="http://www.librairie.org" : le namespace qui est utilisé par défaut dans le document.
xsi:schemaLocation="http://www.librairie.org librairie.xsd" : c'est le schema qui valide le document (schemaLocation contient une paire de valeurs : le namespace et le nom du fichier qui contient les définitions de ce namespace).
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" : c'est une instance d'un XMLSchema.

Autres déclarations

Version équivalente à la première, mais plus compacte.

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="Livre" maxOccurs="unbounded">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="Titre" type="xsd:string"/>
            <xsd:element name="Auteur" type="xsd:string"/>
            <xsd:element name="Date" type="xsd:string"/>
            <xsd:element name="ISBN" type="xsd:string"/>
            <xsd:element name="Editeur" type="xsd:string"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>

Caractéristiques par défaut : minOccurs = 1 et maxOccurs = 1
xsd:complexType sont ici des types anonymes. Il est possible de faire des types nommés pour les réutiliser avec plusieurs éléments.

Utilisation de types nommés

<?xml version="1.0" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.librairie.org"
            xmlns="http://www.librairie.org"
            elementFormDefault="qualified">
  <xsd:element name="Librairie">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="Livre" type="typeLivre" maxOccurs="unbounded" />
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
  <xsd:complexType name="typeLivre">
    <xsd:sequence>
      <xsd:element name="Titre" type="xsd:string"/>
      <xsd:element name="Auteur" type="xsd:string"/>
      <xsd:element name="Date" type="xsd:string"/>
      <xsd:element name="ISBN" type="xsd:string"/>
      <xsd:element name="Editeur" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:schema>

Attention, la déclaration suivante est impossible ! ! ! Utiliser soit type, soit complexType interne.

<xsd:element name="Livre" type="typeLivre" maxOccurs="unbounded">
  <xsd:complexType> ... </xsd:complexType> </xsd:element>

Specialisation du schema

Le type string utilisé pour le numéro ISBN et la date n'est pas satisfaisant.

La date est de la forme "2002", nous allons utiliser le type prédéfini correspondant : gYear.

Le numero ISBN est de la forme : d-ddddd-ddd-d ou d-ddd-ddddd-d ou d-dd-dddddd-d, où 'd' est un chiffre. Le type sera de la forme :

<xsd:simpleType name="typeISBN">
  <xsd:restriction base="xsd:string">
    <xsd:pattern value="\d{1}-\d{5}-\d{3}-\d{1}"/>
    <xsd:pattern value="\d{1}-\d{3}-\d{5}-\d{1}"/>
    <xsd:pattern value="\d{1}-\d{2}-\d{6}-\d{1}"/>
  </xsd:restriction>
</xsd:simpleType>

ou encore

<xsd:simpleType name="typeISBN">
  <xsd:restriction base="xsd:string">
    <xsd:pattern value="\d{1}-\d{5}-\d{3}-\d{1}|\d{1}-\d{3}-\d{5}-\d{1}|\d{1}-\d{2}-\d{6}-\d{1}"/>
  </xsd:restriction>
</xsd:simpleType>

Type simple ou complexe ?

Les types simples ou complexes s'utilisent lors de la création de nouveaux types, chacun répondant à un cas précis :

type simple (simpleType) : modification d'un type prédéfini.
type complexe (complexType) : création d'éléments ou d'attributs d'éléments : modèle de contenu.

Les modèles de contenus avec ou sans contenus textuels :

	Type mixte	Type complexe	Type simple	Type vide
Présence d'un ou plusieurs noeuds d'éléments enfants	oui	oui	non	non
Présence d'un ou plusieurs noeuds textuels enfants	oui	non	oui	non

Les Types de données

Création de types personnalisés

Les types de données personnalisés se définissent à partir des types prédéfinis en spécifiant certaines caractéristiques et en posant des contraintes sur le type de base. Le type prédéfini string a six caractéristiques ou facettes modifiables :
- length : longueur de la chaîne.
- minLength : longueur minimale.
- maxLength : longueur maximale.
- pattern : permet de préciser des caracteristiques grâces à des expressions rationnelles.
- enumeration : énumération de valeurs possibles.
- whitespace : permet la gestion des espaces.

Exemple

<xsd:simpleType name="RVB">
  <xsd:restriction base="xsd:string">
    <xsd:enumeration value="bleu"/>
    <xsd:enumeration value="rouge"/>
    <xsd:enumeration value="vert"/>
  </xsd:restriction>
</xsd:simpleType >
<xsd:simpleType name="temperature">
  <xsd:restriction base="xsd:integer">
    <xsd:minInclusive value="-90"/>
    <xsd:maxInclusive value="60"/>
  </xsd:restriction>
</xsd:simpleType>

Spécificites sur les types

Les types définis par l'utilisateur peuvent à leur tour servir à créer de nouveaux types.

Une caractéristique d'un type peut être fixée, elle est considérée comme une constante et ne peut être modifiée par un nouveau type.

<xsd:simpleType name="temperatureFrance">
  <xsd:restriction base="temperature">
    <xsd:minInclusive value="-30" fixed="true"/>
    <xsd:maxInclusive value="40"/>
  </xsd:restriction>
</xsd:simpleType>

Attention ! ! ! La définition suivante est impossible ! ! ! Elle provoque une erreur.

<xsd:simpleType name="temperatureLeHavre">
  <xsd:restriction base="temperatureFrance">
    <xsd:minInclusive value="-20"/>
    <xsd:maxInclusive value="40"/>
  </xsd:restriction>
</xsd:simpleType>

Les formes d'extension d'un complexType

Deux formes d'extension pour un type complexe :
par restriction : on restreint un type existant sur
- le nombre d'occurrences ;
- l'intervalle de valeurs possibles.
par extension : ajout d'éléments à un typeComplex.

Exemple d'extension

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="Livre" type="typeLivreEdite" maxOccurs="unbounded" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
<xsd:complexType name="typeLivre">
  <xsd:sequence>
    <xsd:element name="Titre" type="xsd:string"/>
    <xsd:element name="Auteur" type="xsd:string"/>
    <xsd:element name="Date" type="xsd:string"/>
  </xsd:sequence>
</xsd:complexType>
<xsd:complexType name="typeLivreEdite">
 <xsd:ComplexContent>
  <xsd:extension base="typeLivre">
    <xsd:sequence>
      <xsd:element name="ISBN" type="xsd:string"/>
      <xsd:element name="Editeur" type="xsd:string"/>
    </xsd:sequence>
  <xsd:extension>
 </xsd:complexContent>
</xsd:complexType>

Exemple de restriction

<xsd:element name="Librairie">
  <xsd:complex Type>
    <xsd:sequence>
      <xsd:element name="Livre" type="typeLivreEdite" maxOccurs="unbounded" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
<xsd:complexType name="petiteLibrairie">
 <xsd:ComplexContent>
  <xsd:restriction base="Librairie">
    <xsd:sequence>
      <xsd:element name="Livre" type="typeLivreEdite" maxOccurs="1000" />
    </xsd:sequence>
  </xsd:restriction>
 </xsd:complexContent>
</xsd:complexType>

Attention ! ! ! Il est nécessaire de répéter tous les éléments. Si on ne répète pas un élément cela indique que l'on supprime l'élément du type de base.

Limitation des extensions

Les extensions sont réglementées, il est possible de les restreindre, voire même de les empêcher.
- Extension impossible :
```
<xsd:complexType name="Publication" final="#All">
```
- Restriction impossible, Dérivation permise :
```
<xsd:complexType name="Publication" final="restriction">
```
- Dérivation impossible, Restriction permise :
```
<xsd:complexType name="Publication" final="extension">
```

Substitution d'éléments

La substitution permet de remplacer un élément par un autre. Cela s'utilise pour :

Utiliser indifféremment des synonymes pour des éléments ayant le même sens (entre deux services ou deux entreprises par exemple)
Internationaliser les noms des éléments.

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element ref="Livre" type="typeLivreEdite" maxOccurs="unbounded" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
<xsd:element name="bouquin" substitutionGroup="Livre" type="typeLivreEdite"
             maxOccurs="unbounded" />

Elle peut être empéchée par l'utilisation de l'instruction block

<xsd:element ref="Livre" type="typeLivreEdite"
             maxOccurs="unbounded"  block="substitution"/>

Substitution et heritage

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element ref="publication" type="typePublication" maxOccurs="unbounded" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
<xsd:complexType name="typePublication">
  <xsd:sequence>
    <xsd:element name="Titre" type="xsd:string"/>
    <xsd:element name="Auteur" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
    <xsd:element name="Date" type="xsd:string"/>
  </xsd:sequence>
</xsd:complexType>
<xsd:element name="magazine" substitutionGroup="publication" type="typeMagazine" maxOccurs="unbounded" />
<xsd:element name="livre" substitutionGroup="publication" type="typeLivre" maxOccurs="unbounded" />
<xsd:complexType name="typeLivre">
 <xsd:complexContent>
   <xsd:extension base="typePublication">
     <xsd:sequence>
       <xsd:element name="ISBN" type="xsd:string"/>
       <xsd:element name="Editeur" type="xsd:string"/>
     </xsd:sequence>
   <xsd:extension>
 </xsd:complexContent>
</xsd:complexType>
<xsd:complexType name="typeMagazine">
 <xsd:complexContent>
    <xsd:restriction base="typePublication">
      <xsd:sequence>
        <xsd:element name="Titre" type="xsd:string"/>
        <xsd:element name="Auteur" type="xsd:string" minOccurs="0" maxOccurs="0"/>
        <xsd:element name="Date" type="xsd:string"/>
      </xsd:sequence>
    </xsd:restriction/">
  </xsd:complexContent>
</xsd:complexType>

Utilisation des attributs

Les attributs ne peuvent être que des simpleType (pas d'éléments fils)

<xsd:complexType name="typeLivre">
  <xsd:sequence>
    <xsd:element name="Titre" type="xsd:string"/>
    <xsd:element name="Auteur" type="xsd:string"/>
    <xsd:element name="Date" type="xsd:string"/>
    <xsd:element name="ISBN" type="xsd:string"/>
    <xsd:element name="Editeur" type="xsd:string"/>
  </xsd:sequence>
  <xsd:attributeGroup ref="attributsLivre" />
</xsd:complexType>
<xsd:attributeGroup name="attributsLivre">
  <xsd:attribute name="categorie" use="required">
    <xsd:simpleType>
      <xsd:restriction base="xsd:string">
        <xsd:enumeration value="policier"/>
        <xsd:enumeration value="science-fiction"/>
        <xsd:enumeration value="roman"/>
      </xsd:restriction>
    </xsd:simpleType>
  </xsd:attribute>
  <xsd:attribute name="enStock" type="xsd:boolean" default="false"/>
  <xsd:attribute name="relecteur" type="xsd:string" default=""/>
</xsd:attributeGroup>

Déclaration Globale / Locale

Les déclarations globales sont réutilisables
Les déclarations locales ne sont utilisables que pour l'élément ou elles sont appliquées.

Exemple : L'attribut use utilise précédemment n'est possible que lors d'une déclaration locale. L'exemple suivant n'est pas valide.

  <xsd:complexType name="typeLivre">
    <xsd:sequence>
      <xsd:element name="Titre" type="xsd:string"/>
...
    </xsd:sequence>
    <xsd:attributeGroup ref="attributsLivre">
  </xsd:complexType>
  <xsd:attribute name="categorie" use="required">
    <xsd:simpleType>
      <xsd:restriction base="xsd:string">
        <xsd:enumeration value="policier"/>
        <xsd:enumeration value="science-fiction"/>
        <xsd:enumeration value="roman"/>
      </xsd:restriction>
    </xsd:simpleType>
  </xsd:attribute>

Attributs "inline"

Comme pour les éléments, les attributs peuvent être décrits a l'intérieur d'un élément, leur portée est alors locale, la définition ne peut être utilisée par un autre élément.

<xsd:complexType name="typeLivre">
  <xsd:sequence>
    <xsd:element name="Titre" type="xsd:string" />
    <xsd:element name="Auteur" type="xsd:string" />
    <xsd:element name="Date" type="xsd:string" />
    <xsd:element name="ISBN" type="xsd:string" />
    <xsd:element name="Editeur" type="xsd:string" />
  </xsd:sequence>
  <xsd:attributeGroup name="attributsLivre">
    <xsd:attribute name="categorie" use="required">
      <xsd:simpleType>
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="policier" />
          <xsd:enumeration value="science-fiction" />
          <xsd:enumeration value="roman" />
        </xsd:restriction>
      </xsd:simpleType>
    </xsd:attribute>
    <xsd:attribute name="enStock" type="xsd:boolean" default="false" />
    <xsd:attribute name="relecteur" type="xsd:string" default="" />
  </xsd:attributeGroup>
</xsd:complexType>

Types simples et attributs ...

Prenons le cas où l'on souhaite utiliser le contenu d'un élément de type simple qui possède quand même un attribut.
```
<note matiere="XML">12</note>
```

On utilise l'élément simpleContent :

<xsd:element name="note">
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="typeNote">
        <xsd:attribute name="matiere" type="typeMatiere" use="required"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>
<xsd:simpleType name="typeNote">
  <xsd:restriction base="xsd:integer">
    <xsd:minInclusive value="0"/>
    <xsd:maxInclusive value="20"/>
  </xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="typeMatiere">
  <xsd:restriction base="xsd:string">
    <xsd:enumeration value="XML"/>
    <xsd:enumeration value="SGBD"/>
  </xsd:restriction></xsd:simpleType>

Utilisation des groupes

Il est possible de regrouper des éléments utilisés dans plusieurs définitions. On utilise alors l'instruction xsd:group. Attention ! ! !

aucun attribut ne doit être inclus dans un groupe
le groupe est toujours de portée globale.

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:sequence><xsd:element ref="publication" type="typePublication" maxOccurs="unbounded"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
<xsd:complexType name="typePublication">
  <xsd:group ref="groupPublication">
</xsd:complexType>
<xsd:group name="groupPublication">
  <xsd:sequence>
    <xsd:element name="Titre" type="xsd:string"/>
    <xsd:element name="Auteur" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
    <xsd:element name="Date" type="xsd:string"/>
  </xsd:sequence>
</xsd:group>

Alternative d'éléments

Pour exprimer une alternative sur un ensemble d'éléments, on utilise l'instruction xsd:choice :

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:choice minOccurs="0" maxOccurs="unbounded">
      <xsd:element name="Livre" type="xsd:string"/>
      <xsd:element name="Magazine" type="xsd:string"/>
      <xsd:element name="BD" type="xsd:string"/>
    </xsd:choice>
  </xsd:complexType>
</xsd:element>

ce qui permet d'exprimer :

<!ELEMENT Librairie(Livre|Magazine|BD)*>

xsd:choice s'utilise comme un élément, il peut donc être utilisé dans un xsd:sequence

Relation d'ordre

xsd:sequence implique d'avoir un ordre dans la position des éléments. Pour éviter l'ordre utiliser xsd:all

<xsd:complexType name="typeLivre">
  <xsd:all>
    <xsd:element name="Titre" type="xsd:string"/>
    <xsd:element name="Auteur" type="xsd:string"/>
    <xsd:element name="Date" type="xsd:string"/>
    <xsd:element name="ISBN" type="xsd:string"/>
    <xsd:element name="Editeur" type="xsd:string"/>
  </xsd:all>
</xsd:complexType>

Toutefois, il y a des contraintes :
- les éléments déclarés dans xsd:all ont obligatoirement maxOccurs=1 et minOccurs=0 ou 1.
- Si un complexType utilisé dans xsd:all hérite d'un autre type, ce dernier doit obligatoirement avoir un contenu vide.
- xsd:all ne peut être utilisé dans un xsd:sequence, un xsd:choice ou un autre xsd:all.
- xsd:all ne peut contenir que des éléments, pas xsd:sequence ni xsd:choice.

Contenu vide

Il est possible de définir un élément avec un contenu vide, par exemple :
```
<img src="http://www.univ-lehavre.fr/lehabre.png"/>
```

Ce qui donne comme schema :

<xsd:element name="img">
  <xsd:complexType>
    <xsd:attribute name="src" type="xsd:anyURI" use="required"/>
  </xsd:complexType>
</xsd:element>

Absence de Namespace

Il est possible de définir des schemas sans namespace, il n'y a plus de targetNamespace ni de xmlns.

<?xml version="1.0" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            elementFromDefault="qualified">
                     ...
</xsd:schema>

Dans l'instance, on remplace schemaLocation par noNamespaceSchemaLocation :

<?xml version="1.0" ?>
<Librairie xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:noNamespaceSchemaLocation="librairie.xsd">
  <Livre>
    <Titre>Le guide du routard Galactique</Titre>
    <Auteur>Doug las Adams</Auteur>
    <Date>1979</ Date>
    <ISBN>0345391802</ISBN>
    <Editeur>Ballantine Books</Editeur>
  </Livre>
</Libraire>

Assemblage de schemas

Il est possible d'importer des schemas dans un schema avec comme contraintes :

d'avoir un nampespace identique à celui en création pour tous les schemas inclus ;
la définition est identique à une définition dans un seul fichier.

<?xml version="1 .0" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.librairie.org"
            xmlns="http://www.librairie.org"
            elementFromDefault="qualified">
<xsd:include schemaLocation="librairie.xsd"/>
<xsd:include schemaLocation="editeur.xsd"/>
                     ...
</xsd:schema>

L'inclusion d'un schema sans namespace provoque quand même l'utilisation du namespace par defaut pour le schema inclus (effet caméléon).

Commenter un XMLSchema (1/2)

Les commentaires sont insérés grâce à l'élément annotation.
<documentation> permet de mettre des commentaires pour un humain.
<appinfo> met du commentaire pour une machine. Le contenu doit être un document XML bien formaté.

<xsd:annotation>
    <xsd:documentation>
        Du texte pour les humains.
    </xsd:documentation>
    <xsd:appinfo >
        <assert test="A > B">A est supérieur ou B</assert>
    </xsd:appinfo>
</xsd:annotation>

Commenter un XMLSchema (2/2)

Le positionnement des commentaires ne peut se faire partout. On peut commenter :
- entre tous les éléments globaux ;
- au début des éléments locaux.
Deux attributs pour <xsd:documentation>
- source : contient l'url d'un fichier contenant les informations ;
- xml:lang : indique la langue du commentaire.
```
<xsd:documentation source="http://www.univ-lehavre.fr/docs/" xml:lang="FR"/>
```

Un attribut pour <xsd:appinfo> (source)

<xsd:appinfo source="http://ici.bas.fr/enfer.xml"/>

Ou positionner un commentaire ?

<?xml version="1 .0" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="http://www.librairie.org"
            xmlns="http://www.librairie.org"
            elementFromDefault="qualified">
ici
  <xsd:element name="Librairie">
ici
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="Livre" minOccurs="1" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
ici
  <xsd:element name="Livre">
ici
   <xsd:sequence >
      <xsd:element name="Titre" type="xsd:string"/>
      <xsd:element name="Auteur" type="xsd:string"/>
      <xsd:element name="Date" type="xsd:string"/>
      <xsd:element name="ISBN" type="xsd:string"/>
      <xsd:element name="Editeur" type="xsd:string"/>
    </xsd:sequence>
  </xsd:element>
ici
</xsd:schema>

Utilisation d'éléments mixtes (1/2)

Un élément mixte est un élément qui contient à la fois du texte et d'autres éléments. Ces éléments sont, par exemple, utilisés pour réaliser les mises en formes matérielles comme par exemple :
```
Les définitions de XMLSchema sont disponibles aux adresses
<url>http://www.w3.org/TR/xmlschema-0/</url>,
<url>http://www.w3.org/TR/xmlschema-1/</url> et
<url>http://www.w3.org/TR/xmlschema-2/</url>.
```

Ces déclarations se font en utilisant l'attribut mixed pour <xsd:complexType> et en le positionnant à true :

<xsd:complexType name="typeTexte" mixed="true">
  <xsd:sequence>
       <xsd:element ref="url" minOccurs="0" maxOccurs="unbounded"/>
  </xsd:sequence>
</xsd:complexType>

Par défaut, il est positionné a false.

Utilisation d'éléments mixtes (2/2)

Attention, lors de l'extension ou de la restriction d'un type, il est nécessaire de préciser de nouveau si l'élément est mixte ou non.

<xsd:complexType name="typeTexte" mixed="true">
  <xsd:sequence>
       <xsd:element ref="url" minOccurs="0" maxOccurs="unbounded"/>
  </xsd:sequence >
</xsd:complexType>
<xsd:complexType name="typeItem" mixed="true">
 <xsd:complexContent>
  <xsd:extension base="typeTexte">
    <xsd:sequence>
       <xsd:element name="liste" type="typeListe" minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="libelle" type="xsd:string" use="optional"/>
  </xsd:extension>
 </xsd:complexContent>
</xsd:complexType>

Utilisation des listes (1/2)

Il est possible avec les XML Schema de décrire des listes d'éléments. Prenons l'exemple du loto :

<loto>
  <boule rang="1">19</boule>
  <boule rang="2">42</boule>
  <boule rang="3">24</boule>
  <boule rang="4">10</boule>
  <boule rang="5">6</boule>
  <boule rang="6">35</boule>
</loto>

peut aussi s'écrire :
```
<loto>19 42 24 10 6 35</loto>
```

Ce qui se définit par :

<xsd:simpleType name="loto">
  <xsd:list itemType="xsd:positiveInteger"/>
</xsd:simpleType>

Utilisation des listes (2/2)

Pour être plus précis, il faut restreindre les chiffres entre 1 et 49 et limiter la liste à 6 éléments :

<xsd:simpleType name="chiffreloto">
  <xsd:restriction base="xsd:positiveInteger">
    <xsd:maxInclusive value="49"/>
  </xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="listeloto">
  <xsd:list itemType="chiffreloto"/>
</xsd:simpleType >
<xsd:simpleType name="loto">
  <xsd:restriction base="listeloto">
    <xsd:length value="6"/>
  </xsd:restriction>
</xsd:simpleType>

Attention ! ! ! les listes ont des restrictions ou obligations :
- il est interdit de faire des listes de listes ;
- il est interdit de faire des listes de typeComplex ;
- il est obligatoire de séparer les éléments par un espace (espace, tabulation, retour chariot) ;
- les attributs d'une liste sont : length, minLength, maxLength, enumeration, pattern.

Union de typeSimple

Le mot clé union permet de faire l'union entre des types simples.

<xsd:simpleType name="chiffreloto">
  <xsd:restriction base="xsd:positiveInteger">
    <xsd:maxInclusive value="49"/>
  </xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="typeloto">
  <xsd:restriction base="xsd:string">
    <xsd:enumeration value="premier tirage"/>
    <xsd:enumeration value="deuxieme tirage"/>
  </xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="loto">
  <xsd:union memberTypes="chiffreloto typeloto"/>
</xsd:simpleType>

Différents types peuvent être utilisés conjointement.

Utilisation d'un élément vide

Il est parfois nécessaire de définir un élément comme ne contenant que des attributs. La définition d'un élément est toutefois nécessaire. C'est le rôle du type xsd:anyType. Plusieurs formes sont équivalentes :

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

<xsd:element name="videAvecAttributs">
  <xsd:complexType>
    <xsd:attribute name="attribut1" type="xsd:string"/>
    <xsd:attribute name="attribut2" type="xsd:string"/>
  </xsd:complexType>
</xsd:element>
<videAvecAttributs attribut1="un" attribut2="deux" />

Il est possible d'utiliser un xsd:complexType pour définir un élément vide car xsd:complexType hérite de xsd:anyType.
La définition d'un élément sans type aura quand même un type : xsd:ur-type, la base de tous les types. Attention : ur-type ne peut être utilisé, en revanche vous pouvez utiliser xsd:anyType.

Utilisation de valeur nulle

L'expression de l'absence de données est parfois nécessaire, l'absence n'étant pas forcément significative dans certains cas. Un mécanisme est disponible dans les XMLSchema grâce à l'attribut nillable :
```
<xsd:element name="estpresent" type="xsd:string" nillable="true" />

<estpresent xsi:nil="true"></estpresent>
```
Le contenu doit être vide, mais des attributs peuvent être utilisés.

Schemas avec des namespaces différents (1/3)

Les schemas différents sont utilisés grâce à la commande import :

<?xml version="1 .0" ?>
<xsd:schema
   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
   xmlns:entrepot="http://scott.univ-lehavre.fr/entrepot"
   xmlns:atm="http://infodoc.unicaen.fr/OhRAGE"
   targetNamespace="http://scott.univ-lehavre.fr/~fournier/XML/SRO.XMLSchema/"
   xmlns="http://scott.univ-lehavre.fr/~fournier/XML/SRO.XMLSchema/"
   elementFromDefault="qualified">
<xsd:import namespace="http://scott.univ-lehavre.fr/entrepot" schemaLocation="entrepot.xsd"/>
<xsd:import namespace="http://infodoc.unicaen.fr/OhRAGE" schemaLocation="atm.xsd"/>

Il est alors nécessaire d'utiliser les préfixes pour utiliser les éléments des autres XML Schema.

Schemas avec des namespaces différents (2/3)

<?xml version="1.0" ?>
<slides xmlns="http://scott.univ-lehavre.fr/~fournier/XML/SRO.XMLSchema/"
        xmlns:entrepot="http://scott.univ-lehavre.fr/entrepot"
        xmlns:atm="http://infodoc.unicaen.fr/OhRAGE"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://scott.univ-lehavre.fr/~fournier/XML/SRO.XMLSchema/slides.xsd">
<entete>
  <atm:auteur>
    <atm:prenom>Domininique</atm:prenom>
    <atm:nom>Fournier</atm:nom>
    <atm:adresse>B2004, UFR S&T</atm:adresse>
    <atm:url>http://scott.univ-lehavre.fr/~fournier</</atm:url>
    <atm:email>Domininique.Fournier@univ-lehavre.fr</atm:email>
  </atm:auteur>
  <titre>XML Schema : Intérêts et utilisations</titre>
  <soustitre>très fortement inspiré des cours de C. Turbout</soustitre>
  <soustitre>XML Technologies Course</soustitre>
  <version>1.0</version>
  <date>vendredi 15 décembre 2006</date>
  <circonstance>Master Pro SRO</circonstance>
  <entrepot:resume>Comment passez d'une DTD à un XMLSchéma, des exemples de créations de documents XML valides,
l'explication de ce qui est habituellement réalisé par une DTD en XMLSchema.
  </entrepot:resume>
</entete>
      ...

Schemas avec des namespaces différents (3/3)

<xsd:complexType name="typeEntete">
  <xsd:sequence>
    <xsd:element ref="atm:auteur" minOccurs="1" maxOccurs="unbounded"/>
    <xsd:element ref="titre" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="soustitre" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
    <xsd:element name="version" type="xsd:string" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="date" type="xsd:string" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="circonstance" type="xsd:string" minOccurs="1" maxOccurs="1"/>
    <xsd:element ref="entrepot:resume" minOccurs="1" maxOccurs="1"/>
  </xsd:sequence>
</xsd:complexType>

On peut utiliser les éléments déjà définis dans les autres schemas pour les réutiliser. De même, il est possible de réutiliser les types définis dans ces schemas.

Extension de document (1/4)

Il est parfois utile d'utiliser seulement une partie du document. Dans le cas d'une extension par une autre personne ou simplement d'une validation de certaines parties d'un document, il est donc nécessaire de préciser qu'il peut y avoir autre chose que ce qui est défini, c'est le rôle de any.

<xsd:complexType name="typeEntete">
  <xsd:sequence>
    <xsd:element ref="atm:auteur" minOccurs="1" maxOccurs="unbounded"/>
    <xsd:element ref="titre" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="soustitre" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
    <xsd:element name="version" type="xsd:string" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="date" type="xsd:string" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="circonstance" type="xsd:string" minOccurs="1" maxOccurs="1"/>
    <xsd:element ref="entrepot:resume" minOccurs="1" maxOccurs="1"/>
    <xsd:any minOccurs="0"/>
  </xsd:sequence>
</xsd:complexType>

Le document peut alors être étendu, le début sera validé par le schema et la fin non vérifiée.

Extension de document (2/4)

La même chose peut-être précisée pour les attributs :

<xsd:complexType name="typeEntete">
  <xsd:sequence>
    <xsd:element ref="atm:auteur" minOccurs="1" maxOccurs="unbounded"/>
    <xsd:element ref="titre" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="soustitre" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
    <xsd:element name="version" type="xsd:string" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="date" type="xsd:string" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="circonstance" type="xsd:string" minOccurs="1" maxOccurs="1"/>
    <xsd:element ref="entrepot:resume" minOccurs="1" maxOccurs="1"/>
    <xsd:any minOccurs="0" maxOccurs="unbounded"/>
  </xsd:sequence>
  <xsd:anyAttribute/>
</xsd:complexType>

On a aussi permis d'ajouter un nombre quelconque d'éléments.

Extension de document (3/4)

Les namespace peuvent aussi être précisés pour les éléments :
<anynamespace="##other" /> permet à l'instance de contenir des éléments d'un namespace autre que celui en cours de définition.
<anynamespace="http://quelquepart.fr" /> permet l'utilisation d'éléments définis dans un ou plusieurs namespace précisés (il peut y avoir une liste).
<anynamespace="##targetNamespace" /> il peut y avoir un élément fourni par le namespace en cours de définition.
<anynamespace="##any" /> ajout d'éléments de tout namespace (option par défaut).
<anynamespace="##local" /> ajout d'éléments d'un schema n'ayant pas de namespace.

Extension de document (4/4)

et pour les attributs :
<anyAttribute namespace="##other" /> permet à l'instance de contenir des attributs d'un namespace autre que celui en cours de définition.
<anyAttribute namespace = "http://quelquepart.fr" /> permet l'utilisation des attributs définis dans un ou plusieurs namespace précisés (il peut y avoir une liste).
<anyAttribute namespace="##targetNamespace" /> il peut y avoir un attribut fourni par le namespace en cours de définition.
<anyAttribute namespace="##any" /> ajout d'attributs de tout namespace (option par defaut).
<anyAttribute namespace="##local" /> ajout d'attributs d'un schema n'ayant pas de namespace.
Selon l'endroit où est placé un élément any, il peut être local ou global, dans un élément ou bien n'importe ou.

Éléments abstraits

Un élément peut être défini comme étant abstrait grâce à l'attribut abstract :

<xsd:element name="Librairie">
  <xsd:complexType>
    <xsd:sequence>
       <xsd:element name="Publication" type="typePublication" maxOccurs="unbounded" abstract="true"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
<xsd:element name="livre" substitutionGroup="Publication" type="typeLivreEdite" maxOccurs="unbounded" />
<xsd:element name="magazine" substitutionGroup="Publication" type="typeMagazine" maxOccurs="unbounded" />

Un élément déclaré abstrait :
- ne peut apparaître dans une instance d'un document ;
- les éléments d'un groupe de substitution peuvent apparaître a sa place.
Les complexType peuvent être définis comme abstract. Les éléments de ce type ne peuvent être utilisés dans l'instance, mais les éléments de types dérivés peuvent l'être.

Unicité et définition de clés

Tout comme les DTD, les XML Schema permettent la définition d'identifiants uniques. Il étend même ce concept puisqu'il permet :
- de définir le contenu d'un élément comme unique ;
- de définir un attribut non ID comme unique ;
- de définir une combinaison de contenu d'éléments et d'attributs comme unique ;
- de distinguer entre unicité (unique) et clé (key) ;
- de définir un ensemble de documents différenciés par quelquechose.

`<xsd:unique>` ou `<xsd:key>`

Une clé (key) est définissable sur un attribut, un élément ou une combinaison des deux, elle doit :
- être présente (minOccurs > 0) ;
- ne pas être nulle (nillable="false") ;
- être unique.

key implique unique, mais unique n'implique pas key.

<xsd:element name="Librairie">
 <xsd:complexType>
    ....
 </xsd:complexType>
  <xsd:key name="index">
    <xsd:selector xpath="Livre"/>
    <xsd:field xpath="ISBN"/>
  </xsd:key>
</xsd:element>

Voici une clé qui s'appelle index qui utilise le numéro ISBN d'un livre. La validation du document va vérifier si chaque livre a un numéro ISBN et s'il est unique.

Caractéristiques de `<xsd:key>`

le mot key fonctionne comme élément ;
- il doit apparaître à la fin de l'élément comme dernière déclaration ;
- la balise <selector> est utilisée dans l'élément key pour specifier quels sont les éléments concernés par la clé ;
- la balise <field> est utilisée dans l'élément key pour préciser qu'elle va être l'élément ou l'attribut qui sera la clé ;
- la balise <field> peut être utilisée plusieurs fois pour concatener des champs comme par exemple faire une clé du nom et des prénoms d'une personne (par forcement unique mais c'est un exemple ! ! !).

Caractéristiques de `<xsd:unique>`

La balise unique s'utilise exactement comme key. La différence est qu'elle vérifie l'unicité quand les éléments ou attributs sont présents. unique prend en compte les clés sur des éléments ou attributs optionnels.

<xsd:element name="Livre">
 <xsd:complexType>
  <xsd:sequence>
    <xsd:element name="ISBN" type="xsd:string" minOccurs="0"/>
    <xsd:element name="Editeur" type="xsd:string"/>
  </xsd:sequence >
 </xsd:complexType>
  <xsd:unique name="index">
     <xsd:selector xpath="Livre"/>
     <xsd:field xpath="ISBN"/>
  </xsd:unique>
</xsd:element>

Utilisation de `<xsd:keyref>` (1/2)

De la même facon que le parseur XML verifie qu'un ID et un IDREF sont identique, les XMLSchema permettent de vérifier qu'une keyref reference bien une key existante :

<?xml version="1 .0" ?>
<Librairie xmlns="http://www.librairie.org"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.librairie.org
                               librairie.xsd">
  <Livre>
    <Titre>Le guide du routard Galactique</Titre>
    <Auteur>Douglas Adams</Auteur>
    <Date>1979</Date>
    <ISBN>0345391802</ISBN>
    <Editeur>Ballantine Books</Editeur>
  </Livre>
  <Enstock>
    <Exemplaire isbn="0345391802"/>
  </Enstock>
</Libraire>

Utilisation de `<xsd:keyref>` (2/2)

<xsd:element name="Livre">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="ISBN" type="xsd:string"/>
      <xsd:element name="Editeur" type="xsd:string"/>
    </xsd:sequence>
         ....
  </xsd:complexType>
    <xsd:key name="index">
      <xsd:selector xpath="Livre"/>
      <xsd:field xpath="ISBN"/>
    </xsd:key>
</xsd:element>
<xsd:element name="Enstock">
  <xsd:complexType>
        ....
  </xsd:complexType>
  <xsd:keyref name="isbn" refer="index">
      <xsd:selector xpath="/Exemplaire"/>
      <xsd:field xpath="ISBN"/>
    </xsd:keyref>

</xsd:element>

Il faut utiliser autant de balises field dans le keyref que dans le key. Ces balises field doivent apparaître dans le même ordre.

Point route

Modèle relationnel : optimisation du modèle des données en vue d'assurer sa cohérence durable
XML : Modèle de document destinée à faciliter l'échange de données
Relationnel : limite au maximum les redondances
XML : ultra verbeux
Interrogation des données : SQL
Quid pour XML ?

BD XML

Adressage : XPath
Transformation : XSL et cie
Requête : XQuery

XPath

Langage (non XML !) pour localiser une portion de document XML.
Principe : une expression XPath est un chemin de localisation (similaire à un chemin dans un système de fichiers)
Un chemin est constitué de pas de localisation (séparés par des /)
Un pas de localisation est constitué de
1. un axe
2. un test de noeud
3. éventuellement des prédicats
Exemple : child::li[position()=1] décrit le premier enfant li du noeud contextuel
child est le nom de l'axe, li le noeud de test et [position()=1] un prédicat

XPath

Le document XML est vu comme un arbre
Les noeuds peuvent être de sept types différents : root, element, text, attribute, namespace, processing-instruction et comment
Le noeud racine est la racine de l'arbre
Chaque noeud élément possède un ensemble de noeuds d'attributs et un ensemble de noeuds namespace

Les axes

Il s'agit d'un préfixe à ajouter à une expression XPath afin de spécifier l'axe de parcours de l'arbre.
Par défaut l'axe est child ( /): parcourt depuis le noeud courant vers les noeuds fils
```
"child::commande"
"commande"
```
Autres axes disponibles :
- descendant ( ou //) : un descendant quelconque (toutes générations confondues),
- descendant-or-self ( ou .//) : un descendant quelconque ou lui-même,
- parent ( ou ..) : le noeud père,
- ancestor : un ancêtre quelconque,
- ancestor-or-self : un ancêtre quelconque ou lui-même,
- following-sibling : la fratrie suivante,
- preceding-sibling : la fratrie précédente,
- following : oncles et cousins suivants,
- preceding : oncles et cousins précédents,
- attribute ( ou @),
- self ( ou .),
- et namespace

Commande.xml

<?xml version="1.0" encoding="ISO-8859-1" ?>
<commande numero="312597">
 <date>2004/2/3</date>
 <client id="216A">société Anonyme</client> 
 <article>
  <numero_piece entrepot="E11">E16-25A</numero_piece>
  <description>boulon1</description>
  <quantite>16</quantité>
 </article>
</commande>

Chemins de localisation

Notion de racine de document != élément racine
Racine du document : "/"
Chemin de localisation : permet d'identifier un ou plusieurs éléments du document
Sélection de tout élément commande fils de la racine du document : "/commande"
"/commande/article/numero_piece"
Opérateur de descente recursive "//"
Tout élément client du document quelle que soit sa place : "//client"

Chemins de localisation spécialisés

"commande[client]" : identifie tout élément commande enfant du noeud contextuel et possédant au moins un enfant client
"commande[@numero]" : tout élément commande possédant un attribut numéro.
"commande[client = 'société Anonyme']"
Les [] servent de filtres (prédicats)
@ notation abrégée de attribute
"//commande[client/@id = '216A']"

Prédicats

Un prédicat filtre un ensemble de noeuds
Il apparaît entre crochets
L'expression du prédicat est évaluée dans le contexte du noeud filtré
Toute expression XPath peut manipuler les booléens (et les opérateurs usuels), les nombres (et les opérateurs arithmétiques) et les chaînes de caractères

Fonctions XPath pour les noeuds

name() : pour obtenir le nom du noeud
- name(.) renvoie le nom du noeud contextuel
node() : renvoie le noeud lui-même
processing-instruction() : retourne vrai pour toute processing-instruction, parametre optionnel : cible (ex: php)
comment() : renvoie les commentaires
data() : renvoie les données associées au noeud
text() : renvoie le contenue PCDATA d'un noeud

Fonctions XPath de position

position() : position du noeud parmi un ensemble
last() : position du dernier noeud d'un ensemble
count() : nombre de noeuds d'un ensemble

<noeuds>
 <noeud>a</noeud>
 <noeud>b</noeud>
 <noeud>c</noeud>
</noeuds>

"/noeuds/noeud"
"/noeuds/noeud[position()=2]"
"/noeuds/noeud[2]"
"/noeuds/noeud[position()=last()]"
    "count(noeud)"

Descriptif W3schools

Fonctions numériques et booléennes

number()
sum()
boolean()
not()
true()
false()
Descriptif W3schools fonctions booléennes
Descriptif W3schools fonctions numériques

Fonctions sur les chaînes

string() : fonction de conversion
string-length()
concat() : concatène un nombre qcq de chaînes
contains()
starts-with()
substring()
substring-after
substring-before()
translate()
Descriptif W3schools

XQuery

Langage de requêtes permettant d'extraire des informations de documents XML
Langage développé avec XSLT 2 avec qui il partage XPath 2
XQuery est à XML ce que SQL est aux données relationnelles
Il existe deux syntaxes pour ce langage
- la syntaxe FLWOR dite naturelle. Le nom est prononcé flower et provient des clauses for, let, where, order by et return.
- la syntaxe XQueryX (XML Syntax for XQuery) moins pratique mais destinée à être automatisée.
XQuery 3.0 : "W3C Recommendation" since 08 April 2014.
XQuery 3.1 : "W3C Recommendation" since 21 March 2017.
XQuery est un langage fonctionnel
Dans XQuery, toute valeur est manipulé sous forme d'une séquence d'items.
Un item peut être soit un noeud XML (document, element, attribute, text, comment et processing-instruction) ou un des 48 types définis dans XMLSchema.

Le langage FLWOR

Accepte les opérations usuelles : 2 + 2 (div ou idiv pour la division) (détails)
Accepte des fonctions prédéfinies (y compris les fonctions XPath) : current-time()
Accepte les expressions XPath : //titre[starts-with(.,'La')]
Accepte des expressions FLWOR qui permettent de "programmer" les requêtes
Les variables sont préfixées par $
Le résultat d'une requête est une séquence d'items (noeuds ou valeurs atomiques)
Une séquence peut être construite littéralement entre parenthèses et en séparant les items par des virgules :(1, 4, 6, 3, 12, 1)
Commentaires délimités par (: et :)

FLWOR 1/2

F pour For : permet de faire une itération sur une séquence.
```
for $i in 1 to 5
  return //auteur[@id=$i]
```

L pour Let : déclare une variable

let $i := 1
let $nbauteurs := /auteurs/auteur[starts-with(nom,'H')]

W pour Where : spécifie une condition de selection d'items, clause n'apparaissant qu'une fois après tous les for et tous les let

for $nomA in /auteurs/auteur/nom[starts-with(.,'A')]
for $nomprenom in /livre/auteur/nom
where $nomprenom/substring-after(.,' ') = $nomA
return $nomA

FLWOR 2/2

O pour Order By : permet de trier par ordre croissant (ascending) ou decroissant (descending)

R pour Return :

for $auteur in /auteurs/auteur
order by $auteur/nom, $auteur/prenom
return $auteur

De nombreuses clauses ont été ajouté avec XQuery 3.0 : group by, window, count (voir w3c)

Suppléments

Opérateur de positionnement
Cast XSchema
Production d'xml

for $aut at $pos in /auteurs/auteur
let $id := xs:int($aut/@id)
   where $pos mod 2 = 0
   order by $id
   return $aut

for $nom in /livre/auteurs/auteur/nom
return <nom> {$nom/substring-after(.," ")} </nom>
        <prenom>{$nom/substring-before(.," ")}</prenom>

Ouverture d'un document

La fonction doc() est utilisée pour ouvrir un document xml.
```
doc("commande.xml")
```
Cette fonction retourne le noeud document et non le noeud élément racine
Le noeud document peut préfixer un chemin XPath traditionnel :
```
doc("commande.xml")/commande[client = 'société Anonyme']
```

Fonctions

Syntaxe :

declare function prefix:function_name($parameter AS datatype)
as returnDatatype
{
 (: indtructions ... :)
    }

Exemple :

declare function local:prixTTC($prixHT as xs:decimal, $taux as xs:decimal)
as xs:decimal
{
 let $prixTTC := $prixHT * (1+$taux)
 return $prixTTC 
    };

Usage :
```
<h1>{local:prixTTC(20, .196)}</h1>
```

IF THEN ELSE

Attention le else est obligatoire ! Mais il est possible de renvoyer une séquence vide ()

Exemple :

declare function local:prixTTC($prixHT as xs:decimal, $taux as xs:decimal)
as xs:decimal
{
  let $prixTTC := if ($taux > 1) then
     $prixHT * ($taux) 
  else $prixHT * (1+$taux)
  return $prixTTC
    };

Usage :

<h1>{local:prixTTC(20, 1.196)} ou {local:prixTTC(20, .196)}</h1>

Quantifiers

Xquery met à disposition des mécanismes pour vérifier des tests sur des ensembles d'éléments à l'image des opérateurs ∃ et ∀

Vérification d'une condition pour au moins un élément d'un ensemble (∃)

for $l in .//livre
where some $t in $l//titre/text() satisfies
  contains($t, "étoiles")
return <numLivre> {$l/@id}</numLivre>

Vérification d'une condition pour tous les éléments d'un ensemble (∀)

for $livre in doc("/home/dominique/public_html/Master1/BDA/DocXML/lmsf040.xml")/livre
where every $t in $livre//titre/text() satisfies
  contains($t," ")
return  {$livre//titre}

Constructeurs

Xquery permet de générer des éléments et des attributs dont les noms sont calculés
Document HTML manipulé

Exemple :

for $numero in //tr/td[1]
return element meslivresimpaires{ 
  attribute num {$numero/data()},
  element titre {$numero/../td[3]/data()},
  element auteur {$numero/../td[2]/data()}
    }

Résultat :

<meslivresimpaires num="1">
  <titre>Le cerveau solitaire</titre>
  <auteur>Jeff, Sutton</auteur>
</meslivresimpaires>
<meslivresimpaires num="3">
  <titre>Les mutants</titre>
  <auteur>Henry, Kuttner</auteur>
</meslivresimpaires>
  ...

XML et ses applications

XML : généralités

Présentation

Origines de XML

Document électronique 4D

Pourquoi structurer un document ?

Avantage des 4D

Exemples!

Remarques

Standards XML et affiliés

Quelques Acteurs incontournables

XML pour quoi faire ?

Xml en détails

Exemple d'instance

La DTD

Exemple de DTD

Pourquoi valider ?

Documents biens formés / valides

Structure d'un document bien formé

Le Prologue

Déclaration de type de document

Les éléments

Les attributs

Sections littérales

Entités prédéfinies et Caractères

Commentaires et Instructions

Les namespaces

Les namespaces

Exemple d'utilisation de namespaces multiples (W3C)

Références

Document Type Definition

Déclaration d'un élément

Contenu d'un élément

Contenu d'un élément

Déclaration d'une liste d'attributs

Types d'attributs

Déclaration de valeurs par défaut

Attributs prédéfinis

Structuration en entités

Entités générales

Entités générales internes

Entités générales externes

Entités générales externes et FPI

Entités générales externes et FPI

Entités générales externes (non xml)

Exemple

Entités paramètres

Entités paramètres

Bilan sur les DTD

La prochaine étape

XML Schema

Vers une description précise des documents XML

D. Fournier

Inspiré du cours de C. Turbout

Références

Fonctionnalités

Pourquoi ces fonctionnalités ?

XML Schema vs DTD (1/2)

XML Schema vs DTD (2/2)

Transformation de la DTD librairie.dtd en librairie.xsd

Langage utilisé pour les deux représentations

Librairie.xsd

Caractéristiques d'un XMLSchema

Exemple de document XML

Autres déclarations

Utilisation de types nommés

Specialisation du schema

Type simple ou complexe ?

Les Types de données

Création de types personnalisés

Exemple

Spécificites sur les types

Les formes d'extension d'un complexType

Exemple d'extension

Exemple de restriction

Limitation des extensions

Substitution d'éléments

Substitution et heritage

Utilisation des attributs

Déclaration Globale / Locale

`<xsd:unique>` ou `<xsd:key>`

Caractéristiques de `<xsd:key>`

Caractéristiques de `<xsd:unique>`

Utilisation de `<xsd:keyref>` (1/2)

Utilisation de `<xsd:keyref>` (2/2)