SQL3

Creation d’un Type d’Objet: .

CREATE TYPE NomType AS OBJECT (
a t t r i b u t 1 TYPE1,
a t t r i b u t 2 TYPE2, . . .
);

Heritage: .
CREATE TYPE SousType UNDER NomType (
−− a t t r i b u t s s p c i f i q u e s au sous−type . . .
);

Creation d’une Table: .

CREATE TABLE NomTable o f NomType
(NESTED TABLE NomAttribut STORE AS N o m T a b l e I m b r i q u , . . . )

Creation d’une Procedure: .

CREATE PROCEDURE NomProcedure ( param1 TYPE1, param2 TYPE2) AS
BEGIN
−− Corps de l a p r o c d u r e
END;

Creation d’une Fonction: .

CREATE FUNCTION NomFonction ( param1 TYPE1, param2 TYPE2)
RETURN TYPE_RESULTAT AS
BEGIN
−− Corps de l a f o n c t i o n
END;

Creation d’une Methode: .

CREATE TYPE BODY NomType AS
MEMBER FUNCTION NomMethode RETURN TypeResultat IS
BEGIN
−− Corps de l a m t h o d e
END NomMethode ;
END;

Requete SELECT: .
SELECT c o l o n n e 1 , c o l o n n e 2 FROM NomTable WHERE c o n d i t i o n ;

Requete INSERT: .
INSERT INTO NomTable ( colonne1 , c o l o n n e 2 ) VALUES ( v a l e u r 1 , v a l e u r 2 ) ;

Requete DELETE: .
DELETE FROM NomTable WHERE c o n d i t i o n ;

Requete UPDATE: .
UPDATE NomTable SET c o l o n n e 1 = n o u v e l l e _ v a l e u r WHERE c o n d i t i o n ;

1
 Exemple :
c r e a t e type T_Piece as o b j e c t (
nom v a r c h a r 2 ( 5 0 ) ,
not i n s t a n t i a b l e member f u n c t i o n masse r e t u r n Number ,
not i n s t a n t i a b l e member f u n c t i o n p r i x r e t u r n Number ,
not i n s t a n t i a b l e member f u n c t i o n nb_piece_base r e t u r n Number
) not f i n a l not i n s t a n t i a b l e ;
...
c r e a t e type T_Sphere under T_PieceBase (
rayon number ( 1 0 ) ,
OVERRIDING member f u n c t i o n volume r e t u r n Number
);
...
c r e a t e type T_PieceComposite under T_Piece (
c o ut number ( 2 0 ) ,
composant T_Ens_Composant ,
OVERRIDING member f u n c t i o n masse r e t u r n Number ,
OVERRIDING member f u n c t i o n p r i x r e t u r n Number ,
OVERRIDING member f u n c t i o n nb_piece_base r e t u r n Number ,
member f u n c t i o n composee_de r e t u r n Ens_C1
);
...
c r e a t e t a b l e LesPC o f T_PC
n e s t e d t a b l e composant s t o r e as T1
...
I n s e r t Into LesMatiere values (
T_Matiere ( ’ b o i s ’ , 1 0 , 2 0 ) ,
T_Matiere ( ’ f e r ’ , 5 , 3 ) ,
T_Matiere ( ’ f e r r i t e ’ , 6 , 1 0 )
);
...
c r e a t e o r r e p l a c e p r o c e d u r e i n s e r t P i e c e C o m p o s i t e as
p l a t e a u REF T_PieceBase ;
p i e d REF T_PieceBase ;
c l o u REF T_PieceBase ;
b o u l e REF T_PieceBase ;
begin
s e l e c t r e f ( p ) i n t o p l a t e a u from LESPIECESBASE p where p . nom=’ p l a t e a u ’ ;
s e l e c t r e f ( p ) i n t o p i e d from LESPIECESBASE p where p . nom=’ pied ’ ;
s e l e c t r e f ( p ) i n t o c l o u from LESPIECESBASE p where p . nom=’ c l o u ’ ;
s e l e c t r e f ( p ) i n t o b o u l e from LESPIECESBASE p where p . nom=’ boule ’ ;

−− A f a i r e : IDEM
i n s e r t i n t o LESPIECESCOMPOSITES VALUES (
T_PIECECOMPOSITE( ’ t a b l e ’ , 1 0 0 ,
T_ENS_COMPOSANT(
T_COMPOSANT ( p l a t e a u , 1 ) ,
T_COMPOSANT ( pied , 4 ) ,
T_COMPOSANT ( c l o u , 1 2 )
)
)
);

2
end ;

c r e a t e o r r e p l a c e type body T_PieceBase as

OVERRIDING member f u n c t i o n p r i x r e t u r n Number i s
n Number ;
begin
s e l e c t d e r e f ( s e l f . m a t i e r e ) . p r i x i n t o n FROM DUAL;
return n ;
end ; . . .
END ;

c r e a t e o r r e p l a c e type body T_Sphere as

OVERRIDING member f u n c t i o n volume r e t u r n Number i s
n Number ;
begin
r e t u r n s e l f . rayon ∗ s e l f . rayon ∗ s e l f . rayon ∗ 4/3 ∗ 3 . 1 4 ;
end ;
END ;
...
c r e a t e o r r e p l a c e type body T_PieceComposite as
OVERRIDING member f u n c t i o n p r i x r e t u r n Number i s
n Number ;
begin
s e l e c t SUM( d e r e f ( c . p i e c e ) . p r i x ( ) ∗ c . q t e ) i n t o n FROM t a b l e ( s e l f . composant ) c
r e t u r n n + s e l f . cout ;
end ;
OVERRIDING member f u n c t i o n nb_piece_base r e t u r n Number i s
n Number ;
begin
s e l e c t SUM( c . q t e ∗ d e r e f ( c . p i e c e ) . nb_piece_base ( ) ) i n t o n from t a b l e ( s e l f . comp
return n ;
end ;

member f u n c t i o n composee_de r e t u r n Ens_C1 i s

r e s u l t Ens_C1 ;
BEGIN
s e l e c t d e r e f ( c . p i e c e ) . nom bulk c o l l e c t i n t o r e s u l t from t a b l e ( s e l f . composant )
where v a l u e ( c ) IS OF ( T_PieceBase )
UNION
( s e l e c t c c as nom from t a b l e ( s e l f . composant ) c , t a b l e (CAST( d e r e f ( c . p i e c e ) AS
where v a l u e ( c ) IS OF ( T_PieceComposite )
);
return r e s u l t ;
end ;
END ;

1. Quel est le nom et le prix au kilo des matières ?

SELECT nom , masse FROM l e s m a t i e r e s ;

2. Quel est le nom des matières dont le prix au kilo est inférieur à 5 euros ?
SELECT ∗ FROM l e s m a t i e r e s
WHERE p r i x < 5 ;

3
 3. Quelles sont les pièces de base en bois ?
SELECT nom , pb . m a t i e r e . nom FROM LESPIECESBASE pb
WHERE pb .MATIERE. nom = ’ b o i s ’ ;

4. Quel est le nom des matières dont le libellé contient ‘fer’. Utiliser la syntaxe : like ‘%fer%’
SELECT m. nom FROM l e s m a t i e r e s m
WHERE m. nom LIKE ’% f e r % ’;

5. Donner le nom des pièces formant la pièce nommée ’billard’. Le résultat est la liste boule, canne,
table
SELECT c . p i e c e . nom , c . q t e FROM LESPIECESCOMPOSITES pc , TABLE( pc . composant ) c
WHERE pc . nom = ’ b i l l a r d ’ ;

6. Donner le nom de chaque matière avec son nombre de pièces de bases.

SELECT pb . m a t i e r e . nom , COUNT( ∗ ) FROM LESPIECESBASE pb
GROUP BY pb . m a t i e r e . nom ;

7. Quelles sont les matières pour lesquelles il existe au moins 3 pièces de base ?
SELECT pb . m a t i e r e . nom , COUNT( ∗ ) FROM LESPIECESBASE pb
GROUP BY pb . m a t i e r e . nom
HAVING COUNT( ∗ ) >= 3 ;

8. Quels sont le nom, le volume, la masse et le prix des pièces de base ?

SELECT nom , volume ( ) , masse ( ) , p r i x ( ) FROM l e s P i e c e s B a s e ;

9. Quels sont le nom et la masse des pièces composites dont la masse est supérieure à 100 ?
SELECT nom , masse ( ) FROM l e s P i e c e s C o m p o s i t e s WHERE masse ( ) > 1 0 0 ;

10. Quelles sont les pièces composites contenant plus de 10 pièces ?

SELECT nom FROM l e s P i e c e s C o m p o s i t e s WHERE nb_piece_base ( ) > 1 0 ;

11. Quel est le nom des composants de chaque pièce composite ?

SELECT nom , composant . p i e c e . nom
FROM l e s P i e c e s C o m p o s i t e s , TABLE( composant ) composant ;

12. Quel est l’ensemble des pièces répertoriées dans la base ?

SELECT nom FROM TABLE( l e s P i e c e s B a s e )
UNION SELECT nom FROM TABLE( l e s P i e c e s C o m p o s i t e s ) ;

13. Quel est le nom des pièces composites qui ont une canne ?
SELECT nom FROM l e s P i e c e s C o m p o s i t e s
WHERE ’ canne ’ MEMBER OF composee_de ( ) ;

14. Quel est le nom des pièces composites qui n’ont aucun clou ?
SELECT nom FROM l e s P i e c e s C o m p o s i t e s
WHERE ’ c l o u ’ NOT MEMBER OF composee_de ( ) ;

4
 XML et DTD
Les Types de DTD:
— Interne La DTD peut être incluse directement dans le document XML.
< ?xml version="1.0" encoding="UTF-8" ?>
< !DOCTYPE element_racine [
< !ELEMENT element_racine (cd*)>
...
]>
<element_racine> . . . </element_racine>

— Externe La DTD peut être définie dans un fichier séparé.

< ?xml version="1.0" encoding="UTF-8" ?>
< !DOCTYPE element_racine SYSTEM "ma_dtd.dtd">
<element_racine> . . . </element_racine>

Element Simple: < !ELEMENT nom_element (#PCDATA) >

Un élément peut contenir n’importe quelle suite de caractères < !ELEMENT nom_element ANY >
Un élément peut être vide< !ELEMENT nom_element (EMPTY) >

Element Complexe: < !ELEMENT element (composant1, composant2, composant3,... ) >

On peut avoir un choix d’éléments : < !ELEMENT element (composant1 | composant2 | ... ) >
On peut associer le nombre de fois que l’on va trouver chacun de ces éléments grâce à un code :
composant ? : on trouvera composant : 0 ou 1 fois
composant* : on trouvera composant : 0 à n fois
composant+ : on trouvera composant : 1 à n fois (au moins une fois)

Les Attributs: < !ATTLIST element

attribut1 contenu1 contrainte1
...
attributN contenuN contrainteN
>
où :
• element : représente le nom de l’élément concerné.
• attribut1, ‘attributN’ : les noms des attributs.
• contenu1, ‘contenuN’ : le type de contenu :
CDATA : chaîne de caractère quelconque.
ID : attribut dont la valeur sera un identifiant unique.
IDREF : attribut dont la valeur sera l’identifiant d’un autre élément.
• contrainte1,’contrainteN’ : optionnel, détermine le type de contrainte associée à cet attribut, soit :
#DEFAULT valeur : définit la valeur par défaut.
#REQUIRED : valeur d’attribut obligatoire.
#IMPLIED : valeur d’attribut facultative.
#FIXED "valeur" : valeur fixe.
(valeur1 | valeur2 | ...) « valeur1 » : valeur parmi une liste de valeur autorisées.
"valeur par défaut" : une valeur par défaut si l’attribut n’est pas présent.

Les Entités: < !ENTITY nom_entité "contenu va remplacer nom_entité dans le document XML" >
Remplacer une entité par son contenu dans un document XML : &nom_entité ;

5
 Exemple :

1 <? xml version = " 1.0 " encoding = " UTF -8 " ? >
2 <! DOCTYPE catalogue [
3 <! ELEMENT catalogue ( cd *) >
4 <! ELEMENT cd ( titre , ( artiste | groupe ) , annee , chansons ) >
5 <! ELEMENT titre (# PCDATA ) >
6 <! ELEMENT artiste (# PCDATA ) >
7 <! ELEMENT groupe (# PCDATA ) >
8 <! ELEMENT annee (# PCDATA ) >
9 <! ELEMENT chansons ( chanson +) >
10 <! ELEMENT chanson (# PCDATA ) >
11 <! ATTLIST cd
12 id CDATA # REQUIRED
13 >
14 <! ATTLIST annee
15 format CDATA # IMPLIED
16 >
17 ]>
18 < catalogue >
19 < cd id = " 1 " >
20 < titre > The Dark Side of the Moon </ titre >
21 < artiste > Pink Floyd </ artiste >
22 < annee format = " CD " > 1973 </ annee >
23 < chansons >
24 < chanson > Speak to Me </ chanson >
25 < chanson > Breathe </ chanson >
26 < chanson > On the Run </ chanson >
27 <! -- ... autres chansons ... -- >
28 </ chansons >
29 </ cd >
30 < cd id = " 2 " >
31 < titre > Abbey Road </ titre >
32 < groupe > The Beatles </ groupe >
33 < annee > 1969 </ annee >
34 < chansons >
35 < chanson > Come Together </ chanson >
36 < chanson > Something </ chanson >
37 < chanson > Here Comes the Sun </ chanson >
38 <! -- ... autres chansons ... -- >
39 </ chansons >
40 </ cd >
41 <! -- ... autres CDs ... -- >
42 </ catalogue >

6
 XSchema
Attribut: <xs :attribute name="nomAttribut" type="xs :integer" use="required" default="0" />
— name : Spécifie le nom de l’attribut.
— type : Indique le type de données de l’attribut. Il existe d’autre type :
xs :string : Chaîne de caractères.
xs :boolean : Valeur booléenne (true ou false).
xs :date : Date au format YYYY-MM-DD.
xs :time : Heure au format hh :mm :ss.
xs :integer, xs :decimal, xs :float et xs :double : Nombre.
— use : Définit si l’attribut est obligatoire(required) ou facultatif (optional).
— default : Spécifie la valeur par défaut de l’attribut.

Element Simple: <xs :element name="nomElm" type="xs :int" minOccurs="1" maxOccurs="1" />
— name : Spécifie le nom de l’élément.
— type : Spécifie le type de données de l’élément.
— minOccurs : Spécifie le nombre minimal d’occurrences de cet élément.
— maxOccurs : Spécifie le nombre maximal d’occurrences de cet élément. Il peut avoir la valeur
unbounded si il peut apparaître un nombre indéfini de fois.

Les Restrictions: Une restriction restreint les valeurs valides d’un type de données simple existant. La
structure d’une restriction : <xs :simpleType> ... (Restriction) </xs :simpleType>

Les types de Ristrictions :

— Chaîne de Caractères :
Length : Restreint la longueur de la chaîne de caractères à une valeur spécifique.
1 < xs:restriction base = " xs:string " >
2 < xs:length value = " 5 " / >
3 </ xs:restriction >

Pattern : Restreint la chaîne de caractères à suivre un motif spécifique défini par une expression
régulière.
1 < xs:restriction base = " xs:string " >
2 < xs:pattern value = " [A - Za - z0 -9]+ " / >
3 </ xs:restriction >

— Entier :
minInclusive et maxInclusive : [min, max]
1 < xs:restriction base = " xs:integer " >
2 < xs:minInclusive value = " 1 " / >
3 < xs:maxInclusive value = " 100 " / >
4 </ xs:restriction >

minExclusive et maxExclusive : ]min, max[

Clé et Reference (key et keyref ): Référencer un attribut unique depuis un autre élément.
— key : utilisé pour définir une clé. name spécifie le nom de la clé.
— keyref : utilisé pour référencer une clé définie par key en utilisant refer.
— selector : spécifie le chemin XPath vers les éléments.
— field : spécifie l’attribut unique.

7
 Type Complexe: La structure d’un type complexe : <xs :complexType> ... </xs :complexType>
Un type complexe peut être composé de :
— Attributs.
— Eléments : On peut définir la composition d’un élément via :
<xs :sequence> : les sous-éléments doivent apparaître dans l’ordre.
<xs :choice> : seulement un des sous-éléments aux choix.
<xs :all> : tous les éléments doivent apparaître dans un ordre quelconque.
— Texte.
— Un mixte de tout cela.

Exemple :
1 < xs:schema xmlns:xs = " http: // www . w3 . org /2001/ XMLSchema " >
2 <! -- Type Simple avec Restriction pour email -- >
3 < xs:simpleType name = " EmailType " >
4 < xs:restriction base = " xs:string " >
5 < xs:pattern value = " [a - zA - Z0 -9. _ %+ -]+ @ [a - zA - Z0 -9. -]+\.[ a - zA - Z ]{2 ,} " /
>
6 </ xs:restriction >
7 </ xs:simpleType >
8 <! -- Type Complexe -- >
9 < xs:complexType name = " Contact " >
10 <! -- Element avec un Choix -- >
11 < xs:choice >
12 < xs:element name = " email " type = " EmailType " / >
13 < xs:element name = " telephone " type = " xs:string " / >
14 </ xs:choice >
15 </ xs:complexType >
16 < xs:complexType name = " Personne " >
17 <! -- Element avec une S q u e n c e -- >
18 < xs:sequence >
19 < xs:element name = " nom " type = " xs:string " / >
20 < xs:element name = " coordonnees " type = " Contact " / >
21 </ xs:sequence >
22 < xs:attribute name = " id " type = " xs:int " use = " required " / >
23 </ xs:complexType >
24 <! -- Utilisation de xs:key pour d f i n i r une c l primaire -- >
25 < xs:key name = " clePersonne " >
26 < xs:selector xpath = " individu " / >
27 < xs:field xpath = " @id " / >
28 </ xs:key >
29 < xs:complexType name = " Groupe " >
30 <! -- Element avec une S q u e n c e de r f r e n c e s des personnes -- >
31 < xs:sequence >
32 < xs:element name = " membre " type = " xs:int " maxOccurs = " unbounded " / >
33 </ xs:sequence >
34 <! -- Utilisation de xs:keyref pour r f r e n c e r id dans le groupe -- >
35 < xs:keyref name = " cleReferencePersonne " refer = " clePersonne " >
36 < xs:selector xpath = " membre " / >
37 < xs:field xpath = " . " / >
38 </ xs:keyref >
39 </ xs:complexType >
40 <! -- Elements utilisant les Types Complexes -- >
41 < xs:element name = " individu " type = " Personne " / >
42 < xs:element name = " groupe " type = " Groupe " / >
43 </ xs:schema >

8
 XPath
Les Chemins:
— Noeud Racine : /
— Elément enfant direct du noeud racine : /nom_element
— Enfant d’un enfant : nom_element/nom_element
— Descendant arbitraire du noeud racine : //nom_element
— Descendant arbitraire d’un noeud : nom_element//nom_element
— Un parent d’un noeud : ../

Les Axes de Recherche:

— Le nœud courant : nom_element/self : :nom_element
— Les enfants du nœud courant : nom_element/child : :nom_element
nom_element/nom_element
— Les descendants du nœud courant : nom_element/descendant : :nom_element
— Le nœud parent du nœud courant : nom_element/parent : :nom_element
nom_element../nom_element
— Les ascendants du nœud courant : nom_element/ancestor : :nom_element
— Les nœuds frères placés après le nœud courant : nom_element/following-sibling : :nom_element
— Les nœuds placés après dans le document : nom_element/following : :nom_element
— Les nœuds frères placés avant le nœud courant : nom_element/preceding-sibling : :nom_element
— Les nœuds placés avant dans le document : nom_element/preceding : :nom_element
— Les nœuds de type attribut du noeud courant : nom_element/attribute : :nom_attribut
nom_element/@nom_attribut

9
 Filtrage des Noeuds:
— * : Nœuds de type Element ou Attribut.
— text() : Nœuds de type Text.
— comment() : Nœuds de type Comment.
— processing-instruction() : Nœuds de type Processing Instruction.
— node() : Tous les nœuds.

Les Conditions: Les sélecteurs de noeuds sont de la forme axe : :filtre[ condition1 ][ condition2 ]...
— Condition d’existence : nom_element [@nom_attribut]
— Condition de position : nom_element [valeur]
— Les conditions logiques (=, !=, <, >, <=, >=) : nom_element [@nom_attribut = ’valeur’]
— Les conditions logiques (and et or) : nom_element[condition1 and condition2]

Les Fonctions:
— sum() : Calcule la somme des éléments. Ex : sum(//nom_element)
— count() : Compte le nombre d’éléments dans une séquence. Ex : count(//nom_element)
— not() : Inverse la valeur de la condition logique. Ex : //nom_element[not(condition)]
— position() : Renvoie la position de l’élément. Ex : //nom_element[position() = ’valeur’]
— last : Renvoie le dernier éléments. Ex : //nom_element[position() = last()]
— name() : Renvoie le nom de l’élément ou de l’attribut. Ex : //nom_element[name()=’nom’]
— id() : Renvoie l’élément dont l’id correspond à la valeur spécifiée. Ex : //nom_element[id()=’id’]
— starts-with() : Vérifie si une chaîne commence par une sous-chaîne. Ex : //nom_element[starts-
with(., ’ex’)]
— contains() : Vérifie si une chaîne contient une sous-chaîne. Ex : //nom_element[contains(., ’ex’)]

Exemple :

Document DTD :
1 <! ELEMENT base ( restaurant | ville ) * >
2 <! ELEMENT restaurant (( fermeture ) ? ,( menu ) *) >
3 <! ATTLIST restaurant nom CDATA # REQUIRED >
4 <! ATTLIST restaurant ville IDREF # REQUIRED >
5 <! ATTLIST restaurant etoile CDATA # REQUIRED >
6

7 <! ELEMENT fermeture (# PCDATA ) >

8

9 <! ELEMENT menu EMPTY >

10 <! ATTLIST menu nom CDATA # REQUIRED >
11 <! ATTLIST menu prix CDATA # REQUIRED >
12

13 <! ELEMENT ville ( plusBeauMonument ) ? >

14 <! ATTLIST ville nom ID # REQUIRED >
15 <! ATTLIST ville departement CDATA # REQUIRED >
16

17 <! ELEMENT plusBeauMonument EMPTY >

18 <! ATTLIST plusBeauMonument nom CDATA # REQUIRED >
19 <! ATTLIST plusBeauMonument tarif CDATA # REQUIRED >

10
Expression XPath :
1. Tous les menus à moins de 50 EUR : //menu[@prix<50]
2. Les menus des restaurants 2 ou 3 étoiles : //restaurant[@etoile=2 or @etoile=3]/menu
3. Le nom des villes dans le département 69 : //ville[@departement="69"]/@nom
4. Le nom des restaurants à Lyon : //restaurant[@ville=’Lyon’]/@nom
5. Le nom des restaurants dans le département 75 :
//restaurant[ancestor::ville[@departement="75"]]/@nom
6. Le plus beau monument des villes ayant au moins 1 restaurant 3 étoiles :
base/ville[@nom = //restaurant[@etoile=3]/@ville]/plusBeauMonument
7. Les villes avec au moins un restaurant qui a au moins 4 menus :
//ville[@nom=//restaurant[count(menu)=4]/@ville]
8. Les restaurants 3 étoiles fermés le dimanche :
//restaurant[@etoile=3 and contains(fermeture, "dimanche"]
9. Les restaurants ayant au moins un menu contenant le nom de la ville :
//restaurant[contains(menu/@nom, ./@ville)]
10. (a) Le 2ème menu de chaque restaurant : //restaurant/menu[2]
(b) Le 5ème menu du guide touristique. : (//menu)[5]
11. Le nombre d’étoiles des restaurants qui se trouvent dans la troisième ville du document :
//ville[3]/../restaurant/@etoile
12. (a) Le 2ème menu à moins de 150 EUR de chaque restaurant :
//restaurant/menu[2][@prix<150]
(b) Le 2ème menu de chaque restaurant s’il vaut moins de 150 EUR :
//restaurant/menu[2][@prix<150]/..
13. Les villes sans restaurant 3 étoiles : //ville[@nom!=../restaurant[@etoile = 3]/@ville]/@nom
14. (a) Les villes sans plus beau monument : //ville[not(plusBeauMonument)]/@nom
(b) Les restaurants dans une ville sans plus beau monument :
//restaurant[@ville= //ville[not(plusBeauMonument)]/@nom]/@nom
15. Les noms des restaurants dont tous les menus coûtent moins cher que les menus du restaurant "Les
quatre saisons" :
//restaurant[(menu/@prix < //restaurant[@nom=’Les 4 saisons’]/menu/@prix) and
(@nom!=’Les 4 saisons’)]/@nom
16. Les villes avec au moins deux restaurants différents classés 3 étoiles :
//ville[@nom = //restaurant[@etoile=3 and count(following-sibling::*)>=1]/@ville
]/@nom
17. Les noms des restaurants proposant au moins deux menus (contenant le mot) "salade" avec des
prix différents :
//restaurant[count(menu[contains(@nom, ’salade’)] and @prix !=
following-sibling::menu[contains(@nom, ’salade’)]/@prix]) >= 2]/@nom
18. La liste de tous les prix de menu possibles, chaque prix doit être listé une seule fois :
//menu[not(@prix = following::menu/@prix) and not(@prix = preceding::menu/@prix)
]/@prix
19. Le nom des restaurants qui ont au moins un menu dont le prix est égal au tarif du plus beau
monument de la ville (du restaurant en question) :
//restaurant[menu/@prix = ../ville/plusBeauMonument/@tarif]/@nom

11
 XQuery
Les Expressions FLWOR:
— for : iteration sur une liste de fragments xml. Ex : for $variable in expression_recherche
— let : association du résultat d’une expression à une variable. Ex : let $variable := expression
— where : condition de sélection. Ex : where condition
— order : tri des résultats. Ex : order by expression (ascending / descending)
— return : expression à retourner. Ex : return expression

Exemple :

Document DTD :
Book
1 <! ELEMENT chapter ( title , section *) >
2 <! ELEMENT section ( title , section *) >
3 <! ELEMENT title (# PCDATA ) >
Price
1 <! ELEMENT prices ( book *) >
2 <! ELEMENT book ( title , source , price ) >
3 <! ELEMENT title (# PCDATA ) >
4 <! ELEMENT source (# PCDATA ) >
5 <! ELEMENT price (# PCDATA ) >
Bib
1 <! ELEMENT bib ( book * ) >
2 <! ELEMENT book ( title , ( author + | editor + ) , publisher , price ) >
3 <! ATTLIST book year CDATA # REQUIRED >
4 <! ELEMENT author ( last , first ) >
5 <! ELEMENT editor ( last , first , affiliation ) >
6 <! ELEMENT title (# PCDATA ) >
7 <! ELEMENT last (# PCDATA ) >
8 <! ELEMENT first (# PCDATA ) >
9 <! ELEMENT affiliation (# PCDATA ) >
10 <! ELEMENT publisher (# PCDATA ) >
11 <! ELEMENT price (# PCDATA ) >

Expression XQuery :
1. Donner (ordre alphabétique) le titre et l’année des livres publiés par Addison-Wesley après 1991.
<bib>
{
for $b in //book
let $year:=$b/@year
let $publisher := $b/publisher
where $year>"1991" and $publisher="Addison-Wesley"
order by $b/title
return <book year="{$year}"> {$b/title} </book>
}
</bib>

2. Dans [Link], quels sont tous les titres de chapitre ou de section qui contiennent le mot «XML» ?
for $t in //chapter//title
where $t[contains(.,"XML")]
return $t

12
3. Combien y a-t-il de livres ?
count(//book)

4. Pour chaque livre, donner le titre et les auteurs regroupés dans un élément <result> :
<bib>
{
for $b in //book
return <result>{$b/title} {$b/author}</result>
}
</bib>

5. Pour chaque auteur, donner la liste des titres de ses livres. Un élément du résultat contient un
auteur avec tous les titres qu’il a écrit :
<results>
{
for $author in distinct-values(//author)
return
<result>
<author>
{ $author }
</author>
{
for $book in //book[author = $author]
return <title>{ $book/title/text() }</title>
}
</result>
}
</results>

6. Pour chaque livre ayant au moins un auteur, donner le titre et le nom d’au plus deux auteurs. Le
nom des auteurs suivants est remplacé par l’élément <et-al> :
<bib>
{
for $b in //book[author]
return
<book>
<title>{$b/title/text()}</title>
{
for $a at $index in $b/author[position() <= 2]
return <author>{$a}</author>
}
{
if (count($b/author) > 2)
then <et-al/>
else ()
}
</book>
}
</bib>

13
 7. Quels sont les livres qui ont un élément dont le nom se termine par «or» et dont un sous élément
contient la chaîne «Suciu» :
for $b in //book
for $a in $b//author
where $b/*[ends-with(name(), ’or’)] and $a/last[contains(.,’Suciu’)]
return
<book> {$b/title} {$a} </book>
8. Dans le document [Link], donner le prix le moins cher de chaque livre. Le résultat est une
liste d’éléments <minprice>. Le titre est un attribut de <minprice>, le prix est un élément de
<minprice> :
<results>
{
for $b in distinct-values(//title)
let $min := min(//book[title=$b]/price)
return
<minprice title="{$b}"> {$min} </minprice>
}
</results>
9. Pour chaque livre avec au moins un auteur, donner le titre et les auteurs, pour chaque livre avec
un éditeur, donner une référence contenant le titre du livre et l’affiliation de l’éditeur :
<bib>
{
for $book in //book
where ($book/author or $book/editor)
return
if ($book/author) then
<book>
<title>{$book/title/text()}</title>
{$book/author}
</book>
else if ($book/editor) then
<reference>
<title>{$book/title/text()}</title>
<affiliation>{$book/editor/affiliation}</affiliation>
</reference>
else ()
}
</bib>
10. Trouver les paires de livres qui ont les mêmes auteurs et des titres différents. Ne pas tenir compte
de l’ordre des auteurs :
<bib>
{
for $b1 in //book
for $b2 in //$b1/following::book
where $b1/author = $b2/author and $b1/title != $b2/title
return
<book-pair> {$b1/title} {$b2/title} </book-pair>
}
</bib>

14
 SPARQL
• RDF
Structure de base: Les données RDF sont structurées en Triplets (sujet-prédicat-objet).
— Sujet : L’entité sur laquelle porte la déclaration.
— Prédicat : L’aspect ou la propriété de l’entité.
— Objet : La valeur ou la cible de la déclaration.
Type de base: (rdf :type) Permet de distinguer les URLS qui sont :
— Ressource : (rdf :Resource) une entité identifiée de manière unique par une URI.
— Propriété : (rdf :Property ) décrit la relation entre différentes ressources.
— Déclaration : (rdf :Statement) Triplets
@prefix : Sert à définir des abréviations pour simplifier l’écriture des URIs.
foaf : Décrit des informations sociales sur des personnes. Ex : foaf :Person : Représente une personne.
Collection RDF: Permet de regrouper plusieurs valeurs sous une seule propriété.
— rdf :Bag : multi-ensemble de ressources.
— rdf :Seq : séquence ordonnée de ressources.
— rdf :Alt : énumération de ressources (non ordonnées).
Liste RDF: (rdf :List) Similaires aux collections mais offrent un ordre spécifique.
— rdf :first : représente le premier élément d’une liste RDF.
— rdf :rest : représenter le reste d’une liste RDF après le premier élément.
— rdf :nil : représenter la fin d’une liste RDF.
Ressources anonymes (nœud blanc): N’est pas identifiée par une URI. Sa syntaxe : _ :id
Schémas: Permet de définir la structure et les relations sémantiques dans un ensemble de données RDF.
— Class : (rdf :Class) Représente une catégorie partageant des caractéristiques communes.
Sous-Classe : (rdfs :subClassOf ) Indique qu’une classe est une sous-classe d’une autre classe.
— Property : (rdfs :Property )
Domain : (rdfs :domain) Spécifie la classe à laquelle appartient le sujet d’une propriété.
Range : (rdfs :range) Spécifie la classe à laquelle appartient l’objet d’une propriété.
Sous-Propriété : (rdfs :subPropertyOf ) Indique qu’une propriété est une sous-propriété
d’une autre propriété.

• SPARQL
Prologue: Introduit des informations supplémentaires avant la requête principale.
— BASE : Définit une base pour les URI relatives.
— PREFIX : Définit un préfixe pour abréger les URI dans la requête.
Head: Spécifie le type de résultat attendu.
— SELECT : Sélectionne les variables à inclure dans le résultat.
— ASK : Vérifie si une condition est vraie (retourne vrai ou faux).
— DESCRIBE : Retourne une description du sujet spécifié.
— CONSTRUCT : Crée un nouveau graphe RDF en fonction des motifs spécifiés.
Body: Décrit les motifs que les données RDF doivent suivre.
— FROM,WHERE, DISTINCT, LIMIT, ORDER BY, GROUP BY, UNION
— OFFSET : Indique le décalage à partir duquel commencer à récupérer les résultats.
— OPTIONAL : Spécifie des motifs de triplets optionnels.
— FILTER : Applique des conditions pour filtrer les résultats.
— NOT EXIST : Vérifie l’absence de motifs correspondants.
— MINUS : Retire les résultats qui correspondent à une autre requête.
— BOUND : Teste si une variable est a une valeur (liée) dans le résultat courant de la requête.

15
 Exemple :

Les Données RDF : Le format utilisé dans cet exemple est Turtle, un langage de sérialisation RDF.
1 @prefix rdf: < http: // www . w3 . org /1999/02/22 - rdf - syntax - ns # > .
2 @prefix rdfs: < http: // www . w3 . org /2000/01/ rdf - schema # > .
3 @prefix foaf: < http: // xmlns . com / foaf /0.1/ > .
4 @prefix f: < http: // www . cems . uwe . ac . uk / empdept / concept / > .
5 @prefix : < http: // www . abc . org / > .
6

7 # rdf types
8 :john a f:emp .
9 :liz a f:emp .
10 :dan a f:emp .
11 :larry a f:emp .
12 :jim a f:emp .
13 :clark a f:emp .
14 :robert a f:emp .
15

16 # job
17 :john f:Job " architect " .
18 :liz f:Job " doctor " .
19 :dan f:Job " engineer " .
20 :larry f:Job " singer " .
21

22 # surnames
23 :john foaf:surname " john " .
24 :liz foaf:surname " liz " .
25 :dan foaf:surname " dan " .
26 :larry foaf:surname " larry " .
27

28 # salary
29 :john f:Sal " 33 " .
30 :liz f:Sal " 42 " .
31 :robert f:Sal " 48 " .
32 :dan f:Sal " 33 " .
33

34 # departement
35 :john f:Dept " urbanism " .
36 :liz f:Dept " surgery " .
37 :dan f:Dept " chemistry " .
38 :larry f:Dept " culture " .
39 :john f:Dept " culture " .
40

41 :urbanism f:Location " NE1 " .

42 :surgery f:Location " SW1 " .
43 :chemistry f:Location " Westminster " .
44 :culture f:Location " Slough " .
Forme Etendue des Trois Premier
:john rdf :type :Person.
:john job "architect".
:john surnames "john".
:john salary "33".
:john departement "urbanien".

16
Les Requetes SPARQL :
1. Noms des employés avec leur job suivant l’ordre alphabétique de leur nom.
PREFIX f o a f :< ht tp : / / xmlns . com/ f o a f /0.1/ >
PREFIX f :< ht tp : / /www. cems . uwe . ac . uk/empdept / c o n c e p t/>
SELECT ?n ? j WHERE {
? e a f : emp .
?e f : job ? j .
? e f o a f : surname ?n .
}
ORDER BY ?n

2. Parmi les employés qui ont un surname, retourner les 3 premiers suivant un tri décroissant de leur
salaire.
PREFIX f o a f :< ht tp : / / xmlns . com/ f o a f /0.1/ >
PREFIX f :< ht tp : / /www. cems . uwe . ac . uk/empdept / c o n c e p t/>
SELECT ?n ? s WHERE {
? e a f : emp .
? e f o a f : surname ?n .
?e f : Sal ? s .
FILTER EXISTS { ? e f o a f : surname [ ] }
}
ORDER BY DESC( ? s )
LIMIT 3

3. Les employés qui ne sont ni médecin ni chanteur à partir du troixieme.

PREFIX f : <http : / /www. cems . uwe . ac . uk/ empdept/ c o n c e p t/>
SELECT ? e
WHERE {
? e a f : emp .
? e f : Job ? j .
MINUS { { ? e f : Job " d o c t o r " } UNION { ? e f : Job " s i n g e r " } }
}
OFFSET 2

4. Les employés dont le nom commence par ‘l’ et termine par ‘ry’.
PREFIX f o a f :< h ttp : / / xmlns . com/ f o a f /0.1/ >
PREFIX f :< h ttp : / /www. cems . uwe . ac . uk/empdept / c o n c e p t/>
SELECT ?n WHERE {
? e a f : emp .
? e f o a f : surname ?n .
FILTER ( s t r S t a r t s ( ? n , " l " ) && s t r E n d s ( ? n , " ry " ) ) .
}

5. Le plus grand salaire.

(a) Sans utiliser ORDER BY et LIMIT.
PREFIX f :< ht tp : / /www. cems . uwe . ac . uk/empdept / c o n c e p t/>
SELECT ? e ? s WHERE {
? e f : SAL ? s .
? e a f : emp .
FILTER NOT EXISTS { ? oe f : SAL ? os . FILTER ( ? os >?s ) }
}

17
 (b) En utilisant ORDER BY et LIMIT.
PREFIX f :< ht tp : / /www. cems . uwe . ac . uk/empdept / c o n c e p t/>
SELECT ? e ? s WHERE {
? e f : SAL ? s .
? e a f : emp .
}
ORDER BY DESC( ? s )
LIMIT 1
6. Les couples d’employés tels que la différence entre leurs salaires est supérieure à 5.
PREFIX f :< ht tp : / /www. cems . uwe . ac . uk/empdept / c o n c e p t/>
SELECT ? e1 ? e2 WHERE {
? e1 a f : emp .
? e2 a f : emp .
? e1 f : SAL ? s1 .
? e2 f : SAL ? s2 .
FILTER ( abs ( ? s1 −?s2 ) >5).
}
7. Le nombre d’employés par département.
SELECT ? dept (COUNT( ? employee ) AS ? countEmployees )
WHERE {
? employee a f : emp .
? employee f : Dept ? dept .
}
GROUP BY ? dept
8. Vérifier si un employé a un salaire supérieur à 40.
ASK
WHERE {
: john f : S a l ? s a l a r y .
FILTER ( ? s a l a r y > 4 0)
}
9. Créer une nouvelle triple pour un nouvel employé.
CONSTRUCT {
: a l i c e a f : emp ;
f o a f : surname " a l i c e " ;
f : Job " d e v e l o p e r " ;
f : S a l "50" ;
f : Dept "IT" .
}
WHERE {
FILTER NOT EXISTS { : a l i c e ?p ? o }
}
10. Obtenir les employés avec leur département s’il est défini.
SELECT ? employee ? department
WHERE {
? employee a f : emp .
OPTIONAL {? employee f : Dept ? department . }
}

18
 N1QL
• NoSQL
Modèles NoSQL: Quatre catégories de modèles de bases de données : clés-valeurs, documents, tables
orientées-colonnes et graphes.
Clés-Valeurs: Chaque objet est représenté par un couple clef-valeur (Ki,Vi) tel que hash(Ki)=Vi.
— Create(clef, valeur) : Crée et écrit un nouveau objet (clef, valeur).
— Read(clef ) : Lit un objet à partir de sa clef.
— Update(clef, valeur) : Met à jour la valeur d’un objet à partir de sa clef.
— Delete(clef ) : Supprime un objet à partir de sa clef.

• N1QL
— SELECT :Permet de sélectionner des données dans une base de données.
SELECT expressions FROM bucket WHERE condition;
— SIMPLE ARITHMETIC : Effectue des opérations arithmétiques simples sur les données.
SELECT a + b AS sum FROM bucket;
— ROUND : Arrondit un nombre à la décimale la plus proche.
SELECT ROUND(number) FROM bucket;
— TRUNC : Tronque un nombre à une décimale spécifique.
SELECT TRUNC(number, decimals) FROM bucket;
— DISTINCT : Retourne des valeurs distinctes des résultats de la requête.
SELECT DISTINCT field FROM bucket;
— NULL : Gère les valeurs nulles ou manquantes dans les requêtes.
SELECT field FROM bucket WHERE field IS NULL;
— INDEXES : Améliore les performances en utilisant des index pour accélérer les requêtes.
CREATE INDEX index\_name ON bucket(field);
— EXPLAIN : Fournit des informations sur la façon dont une requête sera exécutée.
EXPLAIN SELECT * FROM bucket WHERE condition;
— JOIN : Effectue des opérations de jointure entre les données.
SELECT * FROM bucket1 JOIN bucket2 ON condition;
— NEST : Utilisé dans le contexte de la clause JOIN pour imbriquer des résultats.
SELECT * FROM bucket1 NEST bucket2 ON condition;
— UNNEST : Utilisé pour dénormaliser les résultats de la clause NEST.
SELECT * FROM bucket1 UNNEST bucket2;
— ANY : Vérifie si au moins un élément d’un tableau satisfait une condition.
SELECT * FROM bucket WHERE ANY element IN array\_field SATISFIES condition END;
— ARRAY : Construit un tableau à partir des résultats de la requête.
SELECT ARRAY field FOR field IN expression END FROM bucket;
— FIRST : Retourne le premier élément d’un tableau.
SELECT FIRST(array\_field) FROM bucket;
— JSON Objects : Utilisation de l’opérateur "." pour accéder aux champs d’objets JSON imbriqués.
SELECT [Link]\_to\_field FROM bucket WHERE condition;

19
Exemple :

1. Pour les pays ayant une population plus de 50 millions d’habitants, leur nom, population et le
nombre d’organisations auxquelles ils appartiennent triés par ordre décroissant de population. Uti-
liser la fonction ARRAY_LENGTH() qui retourne la longueur d’un tableau.
SELECT name , p o p u l a t i o n , ARRAY_LENGTH( o r g a n i z a t i o n s ) AS org_count
FROM C o u n t r i e s
WHERE p o p u l a t i o n > 50000000
ORDER BY p o p u l a t i o n DESC;
2. Les noms des pays qui se trouvent sur exactement deux continents et où la couverture sur l’un
des continents dépasse 50%. Utiliser l’expression ANY-SATISFIES-END pour vérifier qu’au moins un
élément d’un tableau vérifie une condition donnée.
SELECT name
FROM C o u n t r i e s
WHERE ARRAY_LENGTH( c o n t i n e n t s ) = 2 AND ANY c o n t i n e n t IN c o n t i n e n t s SATISFIES
3. Les noms des pays dont toutes les frontières sont supérieures à 100 km. Utiliser l’expression
EVERYY-SATISFIES-END pour vérifier que tous les éléments d’un tableau vérifient une condition
donnée.
SELECT name
FROM C o u n t r i e s
WHERE EVERY n e i g h b o r IN n e i g h b o r s SATISFIES n e i g h b o r . l e n g t h > 100 END;
4. Les pays qui ont à la fois un désert et une montagne. De telles pays ont leur nom qui figure dans
les collections Deserts et Mountains.
SELECT DISTINCT c . name
FROM C o u n t r i e s c
WHERE ARRAY_LENGTH( c . d e s e r t s ) > 0 AND ARRAY_LENGTH( c . mountains ) > 0 ;

20
 5. Les pays qui ont une montagne mais pas de déserts.
SELECT DISTINCT c . name
FROM C o u n t r i e s c
WHERE ARRAY_LENGTH( c . d e s e r t s ) = 0 AND ARRAY_LENGTH( c . mountains ) > 0 ;
6. Les noms des continents sans doublons.
SELECT DISTINCT c o n t i n e n t
FROM C o u n t r i e s c
UNNEST c . c o n t i n e n t s AS c o n t i n e n t ;
7. Les noms des organisations sans doublons.
SELECT DISTINCT o rg
FROM C o u n t r i e s
UNNEST o r g a n i z a t i o n s AS or g ;
8. Les montagnes (nom et hauteur) de la France.
SELECT m. name , m. e l e v a t i o n
FROM C o u n t r i e s c
JOIN Mountains m ON KEYS c . name
WHERE c . name = ’ France ’ ;
9. Les noms des pays se trouvant sur plus d’un continent, avec la liste des noms de leurs continents,
et le nombre de leurs voisins. Utiliser le constructeur de tableau ARRAY-FOR-IN-END.
SELECT c . name , ARRAY_CONTAINS( c . c o n t i n e n t s [ ∗ ] . c o n t i n e n t , ARRAY FOR v IN c . c o
FROM C o u n t r i e s c
WHERE ARRAY_LENGTH( c . c o n t i n e n t s ) > 1 ;
10. Pour les organisations ayant plus de 4 pays, leurs noms, la liste des noms des pays membres ainsi
que la somme des populations de ces pays. Utiliser la fonction qui construit un tableau de valeur
de l’attribut passé en argument. Cette fonction est utilisée dans une requête avec GROUP BY.
SELECT org , ARRAY_AGG( c . name ) AS member_countries , SUM( c . p o p u l a t i o n ) AS t o t a
FROM C o u n t r i e s c
UNNEST c . o r g a n i z a t i o n s AS or g
GROUP BY o rg
HAVING COUNT(DISTINCT c . name ) > 4 ;
11. Les noms des pays et leurs capitales avec la liste de leurs déserts.
SELECT c . name , c . c a p i t a l , d . d e s e r t s
FROM C o u n t r i e s c
LEFT JOIN D e s e r t s d ON KEYS c . name ;
12. Les noms des pays avec la liste des noms de leurs déserts et la liste des noms de leurs montagnes.
Ne retourner que les pays qui ont à la fois des montagnes et des déserts.
SELECT DISTINCT c . name , d . d e s e r t s , m. mountains
FROM C o u n t r i e s c
JOIN D e s e r t s d ON KEYS c . name
JOIN Mountains m ON KEYS c . name ;
13. Même question en retournant les pays qui ont des montagnes mais pas de déserts.
SELECT DISTINCT c . name
FROM C o u n t r i e s c
JOIN Mountains m ON KEYS c . name
LEFT JOIN D e s e r t s d ON KEYS c . name
WHERE d IS MISSING ;

21
14. Les noms et les capitales des pays frontaliers de la France.
SELECT n e i g h b o r . name , n e i g h b o r . c a p i t a l
FROM C o u n t r i e s c
JOIN UNNEST c . n e i g h b o r s AS n e i g h b o r
WHERE c . name = ’ France ’ ;

15. Les noms et la liste des montagnes des pays frontaliers de la France.
SELECT n e i g h b o r . name , n e i g h b o r . mountains
FROM C o u n t r i e s c
JOIN UNNEST c . n e i g h b o r s AS n e i g h b o r
LEFT JOIN Mountains m ON KEYS n e i g h b o r . name ;

16. L’organisation ayant le plus grand nombre total de population des pays membres. Astuce, construire
pour chaque organisation le total des populations de ses pays membres, trier par ce nombre de façon
décroissante et prendre la première organisation du résultat ainsi obtenu.
SELECT org , SUM( c . p o p u l a t i o n ) AS t o t a l _ p o p u l a t i o n
FROM C o u n t r i e s c
UNNEST c . o r g a n i z a t i o n s AS or g
GROUP BY o rg
ORDER BY t o t a l _ p o p u l a t i o n DESC
LIMIT 1 ;

17. Les noms des pays ayant des déserts, avec la superficie totale de leurs déserts.
SELECT c . name , ARRAY_SUM( d . a r e a s ) AS t o t a l _ d e s e r t _ a r e a
FROM C o u n t r i e s c
JOIN D e s e r t s d ON KEYS c . name
WHERE ARRAY_LENGTH( c . d e s e r t s ) > 0
GROUP BY c . name ;

18. Les noms des pays avec le nom de leur plus haute montagne et sa hauteur.
SELECT c . name , MAX(m. e l e v a t i o n ) AS highest_mountain
FROM C o u n t r i e s c
JOIN Mountains m ON KEYS c . name
GROUP BY c . name ;

19. Les noms des pays ayant au moins une montagne avec une élévation dépassant 4000 mètres.
SELECT DISTINCT c . name
FROM C o u n t r i e s c
WHERE ANY mountain IN c . mountains SATISFIES mountain . e l e v a t i o n > 4000 END;

20. Les noms des pays dont le nom commence et se termine par la lettre "A".
SELECT name
FROM C o u n t r i e s
WHERE LEFT( name , 1 ) = ’A’ AND RIGHT( name , 1 ) = ’A ’ ;

21. Les noms des pays dont le nom contient la lettre ’u’.
SELECT name
FROM C o u n t r i e s
WHERE POSITION ( ’ u ’ IN LOWER( name ) ) > 0 ;

22