====== A63 : Peristance des bases de données ======

===== Définitions de balises =====

===== SGML =====

A la fin des années 1960, Charles GOLDFOND, Edward MOSHER et Raymond LORIE (IBM) construisent un système puissant et portable pour interchanger et manopuler des documents légaux -> utilisation d'un langage de balises
Le langage informait de la nature abstraite des informations plutôt que leur mise en page.
Les informations de mise en page était spécifiée dans un format appelé feuille de style.

L'équipe d'IBM décida également de mettre en place un système capable de rejeter des documents invalides (documents avec des informations manquantes ou en surplus) La structure de chaque type de documents fût alors strictement définie dans un efichier appelé DTD (Document Type Definition).

1969: GML (Generaliszed Markup Language)\\
1974: SGML (Standard Generalized Markup Language)

HTML + CSS (Cascading Style Sheet) crée par le W3C (World Wide Web Consortium)

XML proposé par le W3C combine la puissance et l'extensibilité de son ancêtre SGML et la simplicité imposées par la communauté du Web.

Principes :\\
  * permet de créer des langages de balises pour décrire n'importe quel type de document et appartenant à n'importe quel type de domaine d'une manière structurée : hiérarchique
  * permet de créer de nouvelles balises

Analyse de document XML :\\
  * Lire le document
  * Contrôle de la syntaxe
  * Indique les erreurs

Syntaxe : \\
  * Un seul élément racine
  * Chaque élément doit avoir une balise de début et de fin
  * Les balises doivent être correctement imbriquées
  * La valeur des attributs doivent être entre guillemets
  * XML fait la différence entre les majuscules et les minuscules

=> Un docupment syntaxiquement correct et dit bien formé !

===== Les caractères autorisées =====

On différencie : \\
  * les caractères contenus dans les balises (nom d'élément et d'attributs)
  * les caractères de données (contenues entre deux balises)

Certains caractères blancs seront significatifs et d'autres pas.\\
Ex : <code xml><balise>C'est un caractère de _ _ _ _ _ données</balise></code>

On n'utilisera pas d'espaces dans les noms d'éléments et d'attributs.

Références d'entité et entités prédéfinies : \\
&xxx;\\
&amp; (&)\\
&lt;(<)\\
&gt; (>)\\
&apos; (')\\
&quot;(")

===== Les balises =====

==== Définition ====

Un élément défninit une structure, il peut avoir ou ne pas avoir de contenu (élément fils et des caractères de données). Aucun, un à plusieurs attributs peuvent lui être associés.

==== Définition 2 ====

Un attribut décrit un élément. Il sera placé à l'intérieur de la balise de départ d'un élément. La valeur d'un attribut est entourée d'apostrophes.
<code xml><voiture porte='4' /></code>. Ceci est un élément sans caractères de données.

La section CDATA n'est pas traitée par l'analyse XML. Elle peut contenir du texte, des caractères reservées et des espaces. elle est souvent utilisée pour contenir du code script : 
<code xml><![CDATA[ _ _ _ ]]></code>

===== Les espaces de nom =====

La notion d'espace de nom permet d'éviter les collisions de nom.

Ex: <code xml><sujet>Math</sujet>
<sujet>electro encephalographie</sujet>
</code>

Ces deux éléments sujet peuvent être différenciés par des espaces de nom.

<code xml><ecole:sujet>Math</ecole:sujet>
<medecine:sujet>electro encephalographie</medecine:sujet></code>

Chaque préfixe d'espace de nom est associé à un identificateur de ressource uniforme (URI) qui identifie de façon unique un espace de nom.\\
Pour être sûr que l'espace de nom est unique, une méthode consiste à utiliser les URL (Universal Resources Locators). Car les noms de domaines sont toujours uniques.

===== Avantages de XML =====

Intérêt de XML : pas toujours besoin de faire des requêtes sur le serveur, le client peut s'en occuper.


====== Les DTD (Document Type Definition) ======

===== Définition =====

Définit la structure d'un document XML => valide sa conformité.\\
Une DTD est définie en utilisant la grammaire EBNF (Extended Backus-Naur Form)\\
Un document XML conforme à une DTD est dit __valide__.\\
Un analyseur validant (Ex: Validant XML Microsoft) permet de dire si un document XML est valide ou non.

===== Déclaration de document type =====

<code xml><!DOCTYPE nomRacine ></code>

La DTD peut être soit interne soit externe.

Déclaration interne : 
<code xml><!DOCTYPE monMessage[ 
<!ELEMENT monMessage(#PCDATA)>
]></code>

<code xml><!DOCTYPE monMessage SYSTEM "maDTD.dtd"
[<!ELEMENT monElement (#PCDATA)>
]></code>

Exemple : 
<code xml><!DOCTYPE html PUBLIC "http://www.w3.org/TR/html4/strict.dtd"></code>

===== Déclaration d'élements Type =====

Un élément est un bloc de base d'un document XML.

<code XML>
	<!ELEMENT monelement (#PCDATA)>
</code>

PCDATA est la spécification du contenu, et //monelement// est le nom de l'élément.\\
PCDATA veut, ici, signifier que l'élément contient des caractères de données.

La DTD permet de définir l'ordre et la fréquence des éléments fils
  * Les séquences sont indiquées avec '**,**'
<code xml>
	<!ELEMENT classe (professeur, étudiant)>
</code>
  * Exactement 1 professeur et 1 étudiant dans cet ordre.
  * Les choix indiqués par '**|**'
Exemple : <code xml>
	<!ELEMENT dessert (glace | pâtisserie )>
</code>
  * Contient soit une glace soit une pâtisserie, mais pas les deux indicateurs d'occurences
<code xml>
	<!ELEMENT album (chanson+)> : Une occurence ou plus
	<!ELEMENT album (titre, (titre-chanson,durée)+)> : On devra spécifier une fois au MINIMUM titre-chanson.
	<!ELEMENT bibliothèque (livre*)> : On peut répéter autant de fois livre qu'on veut dans bibliothèque.
	<!ELEMENT choix (personne?)> : L'élément choix pourra avoir un élément personne ou pas.
</code>

Voici un exemple plus complet : 
<code xml>
	<!ELEMENT ferme (fermier+, (chien*|chat?), cochon*, (chèvre|vache)?, (poulet+|canard*))>
</code>

Ceci donnera : 

<code xml>
	<ferme>
		<fermier>Jeanne Dupond</fermier>
		<fermier>Jean Dupond</fermier>
		<chat>ponpon</chat>
		<cochon>tire-bouchon</cochon>
		<poulet>cocotte</poulet>
	</ferme>
</code>

===== Déclaration d'attributs =====

S'effectue avec le mot clé //ATTLIST//
<code xml>
	<!ELEMENT x EMPTY>
	<!ATTLIST x y CDATA #REQUIRED>
</code>

EMPTY est l'élément vide.\\
x : nom de l'élément
y : nom de l'attribut
CDATA : contenu de l'attribut
#REQUIRED : utilisation de l'attribut

Attributs par défaut : #REQUIRED, #IMPLIED, #FIXED.
  * #REQUIRED : doit être défini
  * #IMPLIED : Si l'attribut n'apparaît pas dans l'élément XML peut utiliser n'importe quelle valeur.
  * #FIXED : la valeur de l'attribut est une constante et ne peut pas être autre chose dans le document
<code xml>
	<!ATTLIST adresse code_postal #FIXED "67730">
</code>

===== Types d'attributs =====

Il y a 3 types différents d'attributs : 
  * les chaînes (CDATA)
  * les attributs à jeton
  * les attributs énumérés

==== Attributs à jeton ====

  * ID : Identifie de manière unique un élément. XML demande apparemment (expérience de la prof) un caractère alphanumérique d'abord ! Exemple : s1
  * IDREF : pointe sur un élément ayant un attribut ID. Vérifie si il existe dans le document un élément avec un attribut ID dont la valeur correspond à la valeur de l'attribut IDREF.
  * NMTOKEN (peu usité) : la valeur ne doit être constituée que de lettres, de chiffres, de tirets (-), de soulignés (_), de deux points (:) et de points (.)

==== Le type énuméré ====

Déclare une liste de valeurs possibles pour l'attribut. Ces valeurs sont séparées dans la définition par un '**|**'.
<code xml>
	<!ATTLIST personne genre (M|F) "F">
</code>

==== Les sections conditionnelles ====

Une DTD permet d'inclure ou d'exlure des déclarations en utilisant des sections conditionnelles.
<code xml>
	<![INCLUDE[ _ _ _ _ _]]> : donne la directive d'inclure l'élément
	<![INGNORE[ _ _ _ _ _]]> : donne la directive d'ignorer l'élément
</code>

===== Traitement des espaces dans les DTD =====

  * les attributs de type CDATA respectent les espaces
  * les attributs à jeton (ID, IDREF, NMTOKEN) suppriment les espaces
  * les attributs de type énuméré suppriment les espaces (normalisation)

====== Les schémas ======

Les schémas étudiés ici respectent le standard W3C (World Wide Web Consortium).\\
  * Le but d'un schéma est de spécifier une structure de document XML.
  * Utilise la même syntaxe que celle utilisée dans un document XML
  * Possède plus de possibilités de spécifications que les DTD

Dans les schémas XML le contenu d'un élément est défini par son nom et son type.\\
On distingue les types simples et les types complexes.\\
Des types simples sont prédéfinis.\\
Ex: String, Integer, decimal\\
Un type simple ne peut pas contenir d'éléments fils ou d'attributs.

Un type complexe peut spécifier des éléments fils et des attributs associés.\\
Les éléments peuvent être constitués d'éléments préalablement définis en utilisant les concepts d'agrégation et d'héritage.

  * Agrégation : permet de regrouper un ensemble d'élements à l'intérieur d'un nouvel élément
  * Héritage : permet d'étendre la définition d'un élément préalablement défini

----
Vendredi 28 mars 2008

===== Éléments simples =====

Un élément peut être de type simple ou de type complexe. Le type simple ne peut pas définir de sous - éléments et d'attributs.

Un type simple peut être référencé depuis l'attribut type des éléments xsd:element et xsd.attribute.

Un élément xsd:element ou un élément xsd.attribute peut avoir un sous - élément xsd:simpleType sans attribut name définissant ainsi un type anonyme pour cet élément ou cet attribut.

Des nouveaux types peuvent être dérivés à partir de types existants d'une des 3 façons suivantes :
  * en restreignant l'intervalle du type de base en utilisant l'élément xsd:restriction
  * en combinant plusieurs types de base avec l'élement xsd:union.
  * en autorisant différentes valeurs d'un type de base séparé par un espace avec l'élément xsd:list

==== Facettes ====

Les éléments minExclusives, minInclusive... pattern sont appelés des facettes. Elles désignent un aspect d'une valeur possible pour un type simple.

La facette //pattern// peut désigner des restrictions très sophistiquées sur le format des chaînes de caractères. La facette pattern compare la valeur concernée par rapport à une expression régulière.

<code xml>
	<xsd:simpleType name="nss">
		<xsd:restriction base="xsd:string">
			<xsd:pattern value="\d\d\d_\d\d_\d\d\d\" />
		</xsd:restriction>
	</xsd:simpleType>
</code>

===== Éléments complexe =====

Les types complexes permettent de définir des sous - éléments et des attributs. Ils peuvent avoir un contennu simple (simpleContent) ou un contenu complexe (complexContent).

Seuls les éléments peuvent avoir des types complexes. Les attributs sont toujours de type simple.

Les mauvais types sont définis en utilisant les éléments xsd:complexType.

L'attribut mixed, s'il possède la valeur vraie, signifie que de l'élément peut avoir à la fois des caractères de données et des éléments fils.

==== Notion de contenu simple ====

L'élément xsd:simpleContent est utilisé dans les éléments xsd:complexType dont le contenu est un type simple. Cet élément sert particulièrement lorsque la seule raison pour laquelle un élément ait un type complexe est la définition d'attributs.

==== Contenu complexe ====

L'élément xsd:complexContent est utilisé dans les éléments xsd:complexType pour dériver de nouveaux types complexes à partir d'un type complexe existant par extension ou par restriction.

Lors de la dérivation par extension, l'attribut //mixed// doit avoir la même valeur que l'attribut mixed du type de base. Lors de la dérivation par restriction l'attribut mixed peut avoir la valeur false pour interdire un contenu mixte qui pourrait être utilisé dans le type de base.

=== Notion de contenu complexe ===

  * L'élément xsd:sequence : indique que les éléments représentés par leur sous - éléments doivent apparaître dans le document dans l'ordre où ils ont été listés.
  * L'élément xsd:choice : précise que tous les éléments ou groupes représentés par un de ses sous - éléments __peut__ apparaître.
  * L'élément xsd:all indique que chaque élément représenté par un de ses sous - éléments xsd:element doit être présent. Cependant l'ordre n'a pas d'importance.
  
Dans la pratique, les plus utilisés sont //sequence// et //choice//.

===== Concept de base : déclaration d'attributs =====

xsd:attribute

L'attribut **use** peut avoir l'une des 3 valeurs suivantes :
  * optional : l'attribut est optionnel
  * prohibited : l'attribut ne doit pas apparaître
  * required : l'attribut doit apparaître

====== XML Path Language (XPath) ======

Préalable à la création de feuilles de style.

Permet de se balader dans un document XML, et pour aller à tel ou tel endroit du document, ou alors se fixer sur un noeud du document => on met en forme graphiquement le document.

En XPath, un document XML est vu comme une arborescence dans laquelle chaque partie du document est représentée par un noeud.

Il y a 7 types de noeuds : 
  * root : élément maître
  * element : un élément
  * attribute : un attribut
  * text : contenu
  * comment : commentaire
  * processing instruction : instruction de tâche??
  * namespace : espace de nom

----
Vendredi 4 avril 2008

<code xml>
	<?IUTprocessus exemple="fig1.xml?>"
</code>
cible = chaîne associée

A chaque noeud de l'arborescence XPATH est associée __une chaîne de caractères__ ( String - Value ) et un __nom étendu__.

Un nom étendu est constitué d'une partie locale et d'une URI (Uniform Resource Identifer) d'espaces de nom.

===== Recherche dans un document XML =====

La recherche commence à partir d'un noeud de contexte.\\
tout les résultats d'une recherche sont relatifs à ce noeud.

Un axe indique quel ensemble de noeud, relativement ou noeud de contexte, peut être inclus dans le résultat d'une recherche. Cet axe impose également un ordre sur les noeuds.

Il y a deux types d'axes : 
  * Les axes en descendant (forward axes) séléctionnent les noeuds qui suivent le noeud de contexte.
  * Les axes en montant (revers axes) séléctionnent les noeuds qui précèdent le noeud de contexte.

===== Chemin de localisation =====

==== Notation ====

Axe :: test_de_noeud[prédicat]

==== Exemples ====

  * child :: * : séléctionne tous les éléments fils de type élément du noeud de contexte
  * child :: text() : séléctionne tous les élement fils de type 'text' du noeud de contexte

==== Combinaison de deux chemins de localisation ====

Avec le symbole : '/'

=== Exemple ===
<code xml>
	child :: * / child :: text()
</code>

Séléctionne tous les petits - fils de type **text** du noeud de contexte.\\
La 2ième séléction s'applique sur l'ensemble des noeuds obtenu par la 1ère séléction.

=== Abréviation ===

/descendant_of_self :: node() / child :: body

%%//%% body : séléctionne tout les éléments body d'un document

<code xml>
	/livres/livre/traduction[. = "japonais"]/../titre
</code>
Ce chemin séléctionne les titres de chaque libre ayant une traduction en japonais.

=== Remarque ===

[.="japonais"] compare la chaîne associé du noeud courant à la chaîne "japonais".

==== Fonctions et opérateurs d'ensemble de noeuds ====

head | body : séléctionne tous les noeuds head et body fils du noeud de contexte

last() : renvoie le dernier élément de l'ensemble de noeuds.

=== Exemples ===

<code xml>
	head / title[last()]
</code>
Séléctionne le dernier élément title

<code xml>
	livre[position()=3]
</code>
Séléctionne le 3ième livre, s'écrit aussi livre[3]

Count(*) renvoie le nombre d'éléments fils du noeud de contexte

==== Les fonctions de chaînes ====

Elles permettent de manipuler les chaînes associées aux noeuds de l'arborescence.
<code xml>
	concat(chaîne1,chaîne2,chaîne3)
	start_with(chaîne1,chaîne2) vrai si chaîne1 commence par la chaîne2.
</code>

====== XSL : Extensible Stylesheet Language Transformations (XSLT) ======

Un document XSLT est un document XML avec un élément racine "stylesheet".

XSLT utilise les expressions Xpath pour localiser les noms dans le document XML.

Dans une transformation XSL il y a deux arbres de noeuds : 
  * L'arbre source (décrit dans le document XML)
  * L'arbre résultat (document produit par la transformation)

Pour générer et sauvegarder le fichier résultat de la transformation XSL il faut utiliser la bibliothèque Xerces/Xalan.

<code java>
	java org.apache.xalan.xslt.Process -in fichier.xml -xsl fichier.xsl -out nouveaufichier
</code>

===== Les templates =====

Le template permet de traiter un ensemble d'éléments XML localisés grâce à une expression XPATH :
<code xml>
	<xsl:template match = "expression_xpath">
	</xsl:template>
</code>

Un template possède toujours un contenu. Ce contenu est placé dans l'arbre résultat chaque fois qu'un élément correspondant à l'expression Xpath spécifiée sera rencontrée dans l'arbre source.

Appliquer les modèles avec xsl:apply_templates.

Par défaut, un processus XSLT lit le document XML de haut en bas en commençant à l'élement racine et en descendant dans l'arborescence en suivant l'ordre d'apparition des éléments.

Cependant il est possible de modifier cet ordre grâce à xsl:apply_templates. C'est l'attribut //select// qui indique les éléments à traiter.

<code xml>
	<xsl:template match="nom">
		<xsl:value_of select="nom_famille" />
		<xsl:value_of select="prenom" />
	</xsl:template>
</code>

<code xml>
	<xsl:template match="personne">
		<xsl:apply_templates select="nom" />
	<xsl:template>
</code>

==== Itération et tri ====

=== Itérations ===

<code xml>
	<xsl:for_each select="expression_xpath">
	</xsl:for_each>
</code>
Effectue une même opération sur tous les éléments d'un ensemble de noeuds renvoyés par l'expression XPATH.

=== Tri ===

<xsl:sort select="expression_path" order="ascending | descending" />


