XML :

Semi-structuré : Le structuré représenté par des balises et inside il y a le non structuré. ie les balises vont
structurer un fichier qui n'était pas structuré pour qu'il sera tranféré.
XML EST SENSIBLE A LA CASSE.

Introduction:
• 1ère voie: Les bases de données semi-struturées. --> SGBD natifs --> SGBD des bases de données XML.
• 2ème voie: Intégrer L'XML dans les SGBD relationnels.
Définition : Langage pour l'échange de données dans le web. est un langage avec balises permettant de
structurer des données. décrit des objets de données appelés documents XML = Fichiers XML
Extansible: means the user can define his own balises (Markup)

Concepts de bases :
• Les tags indiquent la signification des sections
marquées
 Les balises servent à structurer le document
 Balise (ou tag ou label):
• Marque de début et fin permettant de repérer un élément textuel
• Forme: <balise> de début, </balise> de fin
• Nécessite le respect de la casse
 Elément de données
<producteur>
<adresse>
<rue>A. Briand</rue>
<ville>Alger</ville>
</adresse>
</producteur>
il y a l'élément producteur et adresse, rue, ville --> ils sont imbriqués
 Elément vide:
Les éléments vides ne contiennent rien entre leurs balises de début et de fin. Dans
ce cas, on peut utiliser une forme raccourcie, à savoir le nom de la balise de début
suivi d'une barre oblique. Par exemple: <name/>.
 Attribut
Dans la balise d’ouverture d’un élément, on peut définir des attributs qui définissent des propriétés de
l’élément.
L’attribut est un doublet nom="valeur" qualifiant une balise
Exemples:
<rapport langue=“FR“ date-modif=“2015-01-07“>
<producteur no="160017" region="Bourgogne">
<AUTEUR né= " 1802" mort= "1885" > Victor Hugo </AUTEUR>
le nom de l’attribut(unique) et la valeur sont sensibles à la casse
l’attribut fournit des informations supplémentaires sur le document ou les éléments XML.
la valeur d’un attribut est une chaîne date-modif=“2015-01-07“ ou date-modif=‘2015-01-07’
Elément vide peut avoir des attributs.

Un document XML est constitué de:

 Prologue
Il contient des déclarations facultatives: déclaration XML (facultative en XML 1.0, obligatoire en XML 1.1),
définition de type de document (DTD), qui sert à valider la structure du document, instructions de
traitement et commentaires(facultatifs).
Corps du document
C'est le contenu même du document.
 Commentaires et instructions de traitement
Ceux-ci peuvent apparaître partout dans le document, dans le prologue et le corps.
Ex:
<?xml version="1.0" encoding="iso-8859-1"?> 1
<!-- Time-stamp: "bibliography.xml 3 Mar 2008 16:24:04" --> 2
<!DOCTYPE bibliography SYSTEM "bibliography.dtd" > 3
<bibliography> 4
<book key="Michard01" lang="fr"> 5
</bibliography> 6

1 : Entête XML avec la version 1.0 et l'encodage iso-8859-1 des

caractères.
2: Commentaire délimité par les chaînes de caractères <!-- et -->.
3: Déclaration de DTD externe dans le fichier bibliography.dtd.
4: Balise ouvrante de l'élément racine bibliography
5: Balise ouvrante de l'élément book avec deux attributs de noms key et
lang et de valeurs Michard01 et fr
6: Balise fermante de l'élément racine bibliography

• Les documents XML ont une structure hiérarchique, avec des éléments qui s'imbriquent les uns dans
les autres pour former une arborescence, commencant par l'élément racine qui est obligatoire.
• Les noms de balises d'éléments doivent commencer par une lettre ou un
caractère de soulignement(_) (mais pas par l'expression xml) . Ils ne doivent pas commencer par un
caractère numérique ou un caractère de ponctuation. Ils ne contiennent pas d’espace. Après la première
lettre, les caractères numériques, les tirets(-) et les points (.) sont permis.

Comment choisir entre élément ou attribut ?

pas de règle absolue mais...
• élément = contenu complexe
• les éléments sont ordonnés, les attributs non
• attribut = valeur simple
• attribut = assez indépendant du contenu
<document lang=“FR“ encoding=“UTF8“>...
<poids unite=“mg“>...

• Bien formé = suit les règles syntaxiques de XML

• Valide = bien formé + conforme à un schéma (DTD , XML-Schema,...)
La validité n’est pas requise
Définir un schéma permet de manipuler plus facilement des documents, de les traiter par des
programmes

Définir une DTD:

DTD: Definition type document
 grammaire pour la structure des documents
 un ensemble de règles, chacune d’entre-elles décrivant le contenu autorisé d’un élément ou
l’ensemble des attributs existant pour un élément.
Comment lier une DTD à un document XML?
Une DTD peut être associée de 3 façons à un document XML :
1.DTD interne : toutes les règles sont dans le fichier XML
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE bonjour
[ <!ELEMENT bonjour (#PCDATA)>]>
<bonjour>bonjour tout le monde</bonjour>
2.DTD mixte : certaines règles sont décrites dans un fichier spécifique et certaines règles sont dans le
fichier XML.
<?xml version="1.0"?>
<!DOCTYPE bonjour SYSTEM "bonjour.dtd"
[<!ELEMENT bonjour (#PCDATA)>]>
<bonjour>bonjour tout le monde</bonjour>
3.DTD externe : toutes les règles à respecter sont décrites dans un fichier spécifique.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE bonjour SYSTEM
"http://www.chez-moi.fr/dtd/bonjour.dtd">
<bonjour>Hello world!</bonjour>

A partir du moment où une DTD est associée au document à valider, on peut valider à l’aide : d'un
logiciel / des programmes dans des bibliothèques.

Une DTD contient:

· Déclaration d’élément
<!ELEMENT nom_élément modèle>
Modèle: modèle de contenu de l’élément.
vide l’élément n’a pas de contenu (mais peut avoir des attributs) "EMPTY"
libre le contenu de l’élément est un contenu quelconque bien formé "ANY"
 données l’élément contient du texte "#PCDATA"
éléments l’élément est composé d’autre éléments (ses fils)
Ce sont des sous-éléments placés entre parenthéses et qui peuvent être:
 Un nom d'élément unique. <!ELEMENT livres (livre)>
 Une séquence de noms d'élément séparés par une virgule, dont l'ordre est
important. <!ELEMENT chapitre (titre,intro,section)>
Un choix de noms d'élément, c'est-à-dire une liste de noms séparés par une barre
verticale (|), représentant des choix mutuellement exclusifs. <!ELEMENT job_id
(manager | worker)>
L'association d'un élément unique et d'une liste. Par exemple:
<!ELEMENT person (full_name| (first_name, last_name))>
mixte l’élément contient un mélange de texte et de sous-éléments.
Une seule façon de mélanger texte #PCDATA et des sous éléments
est acceptée : #PCDATA doit être le premier membre d’un choix placé sous une étoile.
<!ELEMENT book (#PCDATA | em | cite) *>
Indicateurs d’occurrence (Par défaut c'est le +) * (0-n) + (1-n) ? (0-1)
<!ELEMENT chapitre (titre,intro?,section+)>
<!ELEMENT section (titre-section,texte-section)+>
<!ELEMENT texte-section (p|f)*>

· Déclaration d’attribut:
<!ATTLIST element nom-attribut1 type1 defaut1 nom-attribut2 type2 defaut2 ...>
Le type d’un attribut définit les valeurs qu’il peut prendre et pas les types INT,Float ... ,. Un attribut est
toujours String.
• CDATA : valeur chaîne de caractères,
• Une liste de choix possibles parmi un ensemble de noms symboliques.
la valeur par défaut de l’attribut,
• #REQUIRED indique que l’attribut est obligatoire,
• #IMPLIED indique que l’attribut est optionnel,
• #FIXED valeur indique que l’attribut prend toujours la même valeur, dans toute instance de
l’élément si l’attribut y apparaît.
Exemples de déclaration d’attribut:
<!ATTLIST document version CDATA "1.0">
<!ATTLIST document version CDATA #FIXED "1.0">
<!ATTLIST nom titre (Mlle|Mme|M.) #REQUIRED
nom-epouse CDATA #IMPLIED>

Le Langage XPATH:
XPath est un langage de requêtes pour extraire des données d'un document XML
• Une expression XPath peut s'exprimer :
relativement, vis à vis d'un nœud (ou élément) contextuel d'une manière absolue
Le résultat d'une expression XPath peut être :
un ensemble de nœuds (ou un nœud seul) une chaîne de caractères /un nombre /un booléen.
• Sa syntaxe élémentaire ressemble à l'expression d'un chemin pour parcourir l'arbre de noeuds du
fichier XML 'dans l'ordre du doc et sans doublon).
XPATH1 : Classique
XPATH2: XQuery
Dans l'arbre XML il faut montrer tous les noeuds(instances des éléments) avec leurs valeurs.
Une expression de chemin XPath consiste en une séquence
d'étapes séparées par / ou //
Elle peut être
• absolue comme /A/B/C . Le nœud contexte (point de départ)
est alors la racine du document (le nœud document) ou
• relative comme A/B/C . Le nœud contexte dépend alors...du
contexte dans lequel on utilise le chemin XPath

Une étape est composée de 3 composants :

Axe: sens de navigation dans l'arbre par rapport au nœud contexte
Filtre : type des nœuds à retenir
Prédicat(s): propriétés que doivent satisfaire les nœuds parmi les nœuds retenus.
axe :: filtre [prédicat1] [prédicat2]...

Les Axes:
• child sélectionne les nœuds éléments fils du nœud courant
• descendant les nœuds éléments descendants du nœud courant
• parent le nœud père du nœud courant
• ancestor les éléments ancêtres ‫عناصر السلف‬
• following-sibling (preceding-sibling) les éléments frères droits (les éléments frères gauches)
• following (preceding) les éléments dont la balise ouvrante (fermante) apparaît après (avant) dans le
document
• self le nœud courant lui-même
• ancestor-or-self, descendant-or-self : ancestor and itself
• attribute les attributs de l'élément courant : un noeud aussi

Les filtres:
Un filtre permet de sélectionner par un nom ou par un type : un filtre peut être
• un nom d'élément ou d'attribut
• le caractère * qui sélectionne tous les objets de même nature (mais uniquement élément ou attribut).
• child::* sélectionne tous les éléments fils du nœud courant,
• attribute::* sélectionne tous les attributs du nœud courant.
• comment() qui sélectionne les nœuds de type commentaire
• text() qui sélectionne les nœuds de type texte
• node() qui sélectionne les nœuds de n'importe quel type.
• processing-instruction() pour les nœuds d'instructions de traitement
Les prédicats:
Un prédicat est une expression booléenne qui peut être évaluée
à vrai ou faux. On dispose des connecteurs logiques « and » et
« or » et on peut faire intervenir dans les expressions des
valeurs de type:
• numérique
• chaîne de caractères
• booléens (true et false)
• ensemble de nœuds
Des règles de conversion s'appliquent pour pouvoir convertir toute expression XPath en valeur
booléenne en fonction de ce qu'elle retourne.
Valeurs numériques:
• on dispose des comparaisons habituelles < , > , <= , >= , != , =
• on dispose des opérations +, -, *, /, div, mod
• la fonction number(arg) permet de tenter une conversion si la conversion échoue, on obtient la valeur
NaN
/descendant::node() [number(child:code-barre) mod 2 = 1]
Régles de conversion en booléen:
• un ensemble vide vaut false sinon true
• une chaîne vide vaut false sinon true
• 0 ou NaN valent false, les autres valeurs numériques valent
Exemple:
/descendant::*[child::taux] l'ensemble des éléments qui ont un
fils taux.

Fonctions:
• position() retourne la position du nœud contexte dans l'ensemble résultat courant. La première
position vaut 1, la dernière vaut last().
• count(expression) retourne le nombre d'éléments dans le résultat de l'évaluation de l'expression.
• not(expression) négation logique
On dispose aussi de fonctions de manipulation de chaînes (contains, concat ...) et de fonctions
numériques : somme, valeur arrondie, .
/descendant :: taux [position()=2] le deuxième élément tauxdans l'ordre du document.

Syntaxe abrégée: Syntaxe inspirée des systèmes de fichiers.

• child:: peut être omis
• attribute:: peut être remplacé par @
• descendant-or-self::node()/child:: peut être remplacé par //
• self::node() peut être remplacé par un .
• parent::node() peut être remplacé par ..
• [position()=x] peut s'écrire [x]
Opérateur Union:
On peut faire l'union des ensembles résultats de plusieurs expressions XPath à l'aide de l'opérateur |.
//eau/@id | //eau/../../bouteilles/bouteille/@ref_eau

Le langage XQUERY:
• permet de définir des fonctions, et utiliser toutes les fonctions prédéfinies pour XPath.
• XQuery est un langage sensible à la casse. Les mots clés sont en minuscules.
commentaires sont possibles (: un commentaire :)
Qu’est ce qu’une requête?
Une requête est une expression qui
• Lit une séquence de fragments XML ou de valeurs atomiques.
•Retourne une séquence de fragments XML ou de valeurs atomiques.

Une expression de chemin XPath est une requête XQuery

Une expression FLWOR (For, Let, Where, Order, Return) lie des variables, applique des prédicats, et
construit un nouveau résultat.
1) for $s in (<one/>, <two/>, <three/>) return <out>{$s}</out>
a pour résultat
<out><one/></out><out><two/></out><out><three/></out>
2) let $s := (<one/>, <two/>, <three/>) return <out>{$s}</out>
a pour résultat
<out><one/><two/><three/></out>
Let retourne une séquence des éléments alors que for retourne successivement chaque élément de
laséquence.

Formattage des résultats

for $b in //book
order by $b/@year
return <livre>{$b/@title,
$b/@year}<editeur>{$b/publisher/text()}</editeur></livre>
Résultat:
<livre title="Comprendre XSLT">
<editeur>O’Reilly</editeur>
</livre>
<livre title="Data on the Web" year="2000">
<editeur>Morgan Kaufmann Publishers</editeur>
</livre>
Les requètes de changement d'ordre ainsi le formattage sont faites uniquement par XQuery sinon toute
autre requète peut être faite par les 2.

XMLType
•XMLType est un type de données SQL comme int,Varchar ...
• XMLType stocke du contenu XML de l’une des façons suivante:
1/ Stockage non structuré: CLOB ie grande chaine de caractères
2/ Stockage binaire: CLOB binaire
3/ Stockage structuré: Objet-relationnel (le stockage par défaut)

· Définition d’une colonne d’une table (jouant le rôle d’un type de données) :
CREATE TABLE emp_resumes
(employee_id integer,
resume XMLType);
· Définition d’une table (jouant le rôle d’un type d’objet) :
CREATE TABLE emp_resumes OF XMLType;
dans ce cas les lignes sont de type XML ie pas de colonnes
On peut créer un type objet avec
Cretae Type emp_type
num integer
nom VarChar
prenom VarChar
Create Table employees OF emp_type
chaque ligne de cette table respecte les formats de cette type.
L'accès à ces champs se fait avec le (.) L'objet dans ce cas c'est le doc XML et les balises sont les champs.

Charger des données dans XMLType

INSERT into emp_resumes
VALUES (100, XMLType(
'<?xml version="1.0"?>
<RESUME>
<FULL_NAME>Steven King</FULL_NAME>
<JOB_HISTORY>
<JOB_ID>AD_PRES</JOB_ID>
</JOB_HISTORY>
</RESUME>'));
Le chargement de données dans une colonne XMLType avec l'instruction
INSERT, crée une ligne contenant le document XML Resume pour l'employé Steven King

Interroger un XMLType en utilisant Xpath

Utiliser des expressions XPath dans les fonctions XMLType suivantes:
la fonction existsNode() utilisée dans les conditions d'interrogation pour
filtrer les résultats sur la base du contenu XML dans les instances XMLType: elle détermine si un
document contient un nœud correspondant à l'expression XPath. Si la colonne XMLType contient le
nœud, la fonction renvoie 1; sinon, elle renvoie 0.
Fonction SQL: existsNode(xmltype, xpath-expr)
Fonction XMLType: xmltype.existsNode(xpath-expr)

la fonction existsNode() : exemples

Fonction SQL:
SELECT Count(*) FROM Emp_resumes
WHERE existsNode(resume, ‘/RESUME[FULL_NAME="Steven King "]’)=1;
SELECT employee_id, existsNode(resume, ‘//JOB_ID[text()= “AD_VP"]’)
FROM emp_resumes ;

la fonction extract() elle renvoie un nœud ou un ensemble de nœuds identifiés par l'expression XPath.
Le résultat est une instance XMLType, qui peut être un document complet ou un fragment.
Fonction SQL: extract(xmltype, xpath-expr)
Fonction XMLType: xmltype.extract(xpath-expr)
SELECT employee_id, extract(RESUME, '//FULL_NAME') result
FROM emp_resumes;

SELECT employee_id, e.resume.extract('//FULL_NAME') result

FROM emp_resumes e;
EMPLOYEE_ID RESULT
------------------------- ----------------------------------------
100 <FULL_NAME>Steven King</FULL_NAME>
101 <FULL_NAME>Neena Kochhar</FULL_NAME>

Combiner les fonctions existsNode et extract():

SELECT employee_id, extract(resume, '//JOB_ID/text()') result
FROM emp_resumes
WHERE existsNode(resume, ‘/RESUME[FULL_NAME="Steven King "]’)=1;
EMPLOYEE_ID RESULT
------------------------- ----------------------------------------
100 ADR_PRES
la fonction extractValue() Retourne les valeurs des éléments sans les balises début et fin. fonctionne
uniquement avec un noed textuel (élément textuel ou bien un attribut)
Fonction SQL: extractValue(xmltype, xpath-expr)
Fonction XMLType: xmltype.extractValue(xpath-expr)
SELECT employee_id, e.resume.extractvalue( '//FULL_NAME') result
FROM emp_resumes e;
EMPLOYEE_ID RESULT
------------------------- ----------------------------------
100 Steven King
101 Neena Kochhar

Filtrer avec extractvalue()

SELECT employee_id, extract(resume, '//JOB_HISTORY') result
FROM emp_resumes
WHERE extractValue(resume, ‘//JOB_ID’)=‘AD_PRES’;
EMPLOYEE_ID RESULT
---------------------- -------------------
100 <JOB_HISTORY>
<JOB_ID>AD_PRES</JOB_ID>
</JOB_HISTORY>