3 1 Cours

Bases de données avancées
Master 1 Informatique
2017-2018
Jérôme Darmont
http://eric.univ-lyon2.fr/~jdarmont/
Actualité du cours
http://eric.univ-lyon2.fr/~jdarmont/?page_id=3142
http://eric.univ-lyon2.fr/~jdarmont/?feed=rss2
https://twitter.com/darmont_lyon2 #bda
Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 2

Objectifs du cours
SQL : langage de requêtes (bases de données relationnelles)

– Standard
– Optimisateurs de requêtes
– Bas niveau
Programmation nécessaire pour :

Langage
– Tâches complexes
– Interfaces utilisateurs
PL/SQL
80 % des données sont peu ou pas structurées Langage

– Description via le langage XML
XQuery
Partie 1
PL/SQL
Bases de données avancées 4

PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
Procédures stockées
SQL dynamique

PL/SQL : Requêtes SQL dans un programme
SQL encapsulé : Requêtes SQL incorporées dans le code source

(PL/SQL, T-SQL, PL/pgSQL, Pro*C…) C
API : Requêtes SQL via des fonctions du langage U
(Java Persistence API, PHP Data Objects…) R
S
Interfaces de niveau appel : intergiciel entre le langage et le SGBD
E
(ODBC, JDBC, ADO…)
U
Procédures stockées : Fonctions SQL stockées dans la base de R
données et exécutées par le SGBD S
(écrites en PL/SQL, T-SQL, PL/pgSQL)
PL/SQL : Caractéristiques du langage
Langage de 4e génération (L4G = L3G + syntaxe type SQL)
Conçu comme une extension de SQL
Déclaration de variables et de constantes
Types abstraits (collections, enregistrements, objets)
Modularité (sous-programmes, paquetages)
Gestion des erreurs (Gestion des erreurs)
Interaction étroite avec Oracle/SQL (types identiques)

PL/SQL : Caractéristiques du langage
SQL dynamique (construction de requêtes à la volée)
Programmation orientée objet
Performance (traitement par lots)
Productivité (uniformité des outils Oracle)
Portabilité (sur tous systèmes Oracle)
Sécurité (procédures stockées, déclencheurs)

PL/SQL : Architecture d’Oracle
Génie logiciel Réseau

SQL
SQL Developer
Serveur
Oracle
PL/SQL
Logiciels tiers Administration

PL/SQL : Moteur Oracle
Oracle Database PL/SQL

User’s Guide and Reference

PL/SQL : Types de blocs
Bloc anonyme
– Stocké dans un fichier
– Compilé et exécuté à la volée
BA
Procédure stockée
– Compilée a priori
– Stockée dans la base de données Déc
BD
Déclencheur PS
– Procédure stockée associée à une table
– Exécution automatique à la suite d’un événement

PL/SQL : Structure d’un bloc
[DECLARE
-- Types, constantes et variables]
BEGIN
-- Instructions PL/SQL
[EXCEPTION
-- Gestion des erreurs]
END;

PL/SQL : Sondage express
A. Jusqu’ici, tout va bien.
B. Je suis déjà perdu.
Répondre sur http://toreply.univ-lille1.fr
Question n° 9323

PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
SQL dynamique

PL/SQL : Variables et constantes
Déclaration dans la section DECLARE d’un bloc PL/SQL
Variables
ex. date_naissance DATE;
compteur INTEGER := 0; -- Initialisation
compteur2 INTEGER DEFAULT 0; -- Valeur par défaut
id CHAR(5) NOT NULL := ‘AP001’;
Constantes
ex. taux_tva CONSTANT REAL := 0.2;

PL/SQL : Types de données


PL/SQL : Référencer un type existant
Type d’une autre variable

ex. credit REAL;
debit credit%TYPE;
Type de l’attribut d’une table

ex. num_emp EMP.EMPNO%TYPE;
À utiliser
au maximum !
Type des n-uplets d’une table
ex. un_etudiant STUDENT%ROWTYPE;

PL/SQL : Affectation de variable
Affectation simple
ex. n := 0;
n := n + 1;
Valeur de la base de données

ex. SELECT custname INTO nom_client
FROM customer WHERE custnum = 10;
SELECT ename, sal INTO nom, salaire
FROM emp WHERE empno = 5000;

PL/SQL : Opérateurs arithmétiques et logiques
Opérateurs arithmétiques + - / * **
Opérateur de concaténation ||
Opérateurs de comparaison = < > <= >= <>

IS NULL LIKE BETWEEN IN
Opérateurs logiques AND OR NOT

PL/SQL : Tests
IF-THEN, IF-THEN-ELSE ou IF-THEN-ELSIF
IF condition1 THEN
-- Statements
[ELSIF condition2 THEN
-- Instructions PL/SQL]
[ELSE
-- Instructions PL/SQL]
END IF;

PL/SQL : Tests
CASE
CASE variable
WHEN val1 THEN -- Instruction PL/SQL
[ELSE -- Instruction par défaut]
END CASE;

PL/SQL : Boucles
Pour
FOR iterateur IN [REVERSE] min..max LOOP
END LOOP;
Tant que
WHILE condition LOOP
END LOOP;
Répéter
LOOP
EXIT WHEN condition;
END LOOP;
PL/SQL : Affichage écran
DBMS_OUTPUT.PUT('chaîne'); /* Pas de retour à la ligne */
DBMS_OUTPUT.PUT_LINE('chaîne'); /* Retour à la ligne */
DBMS_OUTPUT.PUT('Hello world !');
DBMS_OUTPUT.PUT_LINE('nom = ' || nom);
DBMS_OUTPUT.PUT_LINE('n = ' || TO_CHAR(n));
DBMS_OUTPUT.PUT_LINE('n = ' || n);
NB : Pour que l’affichage fonctionne, il faut mettre la variable d’environnement
SERVEROUTPUT à ON.
SET SERVEROUTPUT ON dans SQL Developer
En cas de dépassement, la taille du tampon d’affichage doit être augmentée.

Ex. DBMS_OUTPUT.ENABLE(10000);
PL/SQL : Exemple de bloc anonyme
-- Calcul de prix TTC
DECLARE
taux_tva CONSTANT REAL := 0.2;
prix product.prod_price%TYPE;
BEGIN
-- Affectation du prix
SELECT prod_price INTO prix FROM product
WHERE prod_code = 'Pr345blue';
-- Ajout de la TVA
prix := prix * (1 + taux_tva);
-- Affichage écran
DBMS_OUTPUT.PUT_LINE(prix || ' euros');
END;
PL/SQL : Quizz
Combien y a-t-il de sections
dans un bloc PL/SQL ?
A. 1
B. 2
C. 3
D. 4
E. 5
Question n° 9809
PL/SQL : Collections
Définition : Ensemble ordonné d’éléments de même type. Chaque

élément est indexé par sa position dans la collection.
Deux types de collections

– Tableau (VARRAY) : taille bornée, dense
– Liste (TABLE) : taille extensible, non-dense


PL/SQL : Déclaration de collection
1. Déclarer un type collection

ex. TYPE Liste_Chaines IS TABLE OF VARCHAR(20);
TYPE Tableau_Entiers IS VARRAY(10) OF INTEGER;
2. Déclarer une collection et l’initialiser

ex. ma_liste Liste_Chaines := Liste_Chaines('Aa', 'Bb', 'Cc');
t Tableau_Entiers := Tableau_Entiers();
NB : Une collection peut être déclarée vide (c’est le cas de t).

Il n’est pas obligatoire d’initialiser tous les éléments d’un tableau.

PL/SQL : Affectation de collection
Collection entière
ex. DECLARE TYPE T1 IS TABLE OF INT;
TYPE T2 IS TABLE OF INT;
et11 T1 := T1(1, 2, 3, 4);
et12 T1 := T1(5, 6);
et2 T2 := T2();
BEGIN et12 := et11; -- Légal
et2 := et11; -- Illégal
…
Elément d’une collection

ex. et11(1) := 10;

PL/SQL : Manipulation de collection (1/2)
Ensemble de méthodes ( procédures)

Usage: nom_collection.nom_methode[(paramètres)]
EXISTS(i) renvoie TRUE si le ie élément existe dans la collection.
COUNT renvoie le nombre d’éléments dans la collection.
LIMIT renvoie la taille maximum de la collection (NULL pour les listes).
EXTEND(n) augmente la taille de la collection de n.

EXTEND(1)  EXTEND

PL/SQL : Manipulation de collection (2/2)
TRIM(n) supprime n éléments en fin de collection (la taille de la collection

diminue automatiquement).
TRIM  TRIM(1)
DELETE(i) et DELETE suppriment respectivement le ie élément et tous les

éléments de la collection (listes seulement).
FIRST et LAST renvoient respectivement l’index du premier et du dernier

élément de la collection.
NB : FIRST = 1 et LAST = COUNT dans un tableau.
PRIOR(i) et NEXT(i) renvoient respectivement l’index de l’élément précédent

et de l’élément suivant du ie élément.

PL/SQL : Exemple de manipulation de collection
DECLARE
TYPE ListeEntiers IS TABLE OF INTEGER;
pile ListeEntiers := ListeEntiers();
element INTEGER;
BEGIN
-- On empile les valeurs 1 et 11
pile.EXTEND;
pile(pile.COUNT) := 1;
pile.EXTEND;
pile(pile.COUNT) := 11;
-- On dépile
element := pile(pile.COUNT); -- element = 11
pile.TRIM; -- Suppression en haut de pile
PL/SQL : Quizz
Les valeurs ci-dessous sont-elles justes
pour la liste suivante ?
FIRST = 2 LAST = 6 COUNT = 4 LIMIT = 6
33 58 22 17
1 2 3 4 5 6
Question n° 7007
PL/SQL : Enregistrements
Définition : Ensemble de données liées stockées dans des champs.
1. Déclarer un type enregistrement

ex. TYPE Etudiant IS RECORD(
numetu INTEGER,
nom VARCHAR(50),
age INTEGER );
2. Déclarer un enregistrement
ex. un_etudiant Edutiant;

PL/SQL : Affectation d’enregistrement
Référence directe
ex. un_etudiant.numetu := 12212478;
un_etudiant.nom := 'Toto';
un_etudiant.age := 6;
un_etudiant := mon_etudiant; -- équivalent à Etudiant%ROWTYPE
Résultat de requête
ex. SELECT student_number, student_name, student_age
INTO un_etudiant
FROM student
WHERE student_number = 12212478;
PL/SQL : Procédures
PROCEDURE nom_proc (param1, param2…) IS

-- Déclarations locales (pas de clause DECLARE)
BEGIN
[EXCEPTION
-- Gestion des exceptions]
END;

PL/SQL : Fonctions
FUNCTION nom_fonction (param1, param2…)

RETURN type_valeur_retour IS
-- Déclarations locales
BEGIN
RETURN valeur_retour;
[EXCEPTION
-- Gestion des exceptions]
END;

PL/SQL : Déclaration et paramétrage de sous-programmes
Déclaration : Tout sous-programme doit être défini avant d’être

appelé.
 définition dans la section DECLARE d’un bloc PL/SQL
Définition et mode de passage des paramètres

nom_param [IN | OUT | IN OUT] TYPE
ex. resultat OUT REAL
– IN: Paramètre d’entrée (lecture seule / par valeur)
– OUT: Paramètre de sortie (écriture seule / par référence)
– IN OUT: Paramètre d’entrée-sortie (lecture-écriture / par référence)

PL/SQL : Exemple de procédure
PROCEDURE Conversion_USD_EUR (prix_USD IN REAL,

prix_EUR OUT REAL) IS
taux CONSTANT REAL := 0.89;
BEGIN
prix_EUR := prix_USD * taux;
END;

PL/SQL : Exemple de fonction (récursive)
-- Calcul de n!
FUNCTION facto (n INTEGER) RETURN INTEGER IS
BEGIN
IF n = 1 THEN -- Condition d’arrêt
RETURN 1;
ELSE
RETURN n * facto(n - 1); -- Appel récursif
END IF;
END;

PL/SQL : Appel de sous-programmes
-- Exemple
DECLARE
hundredBucks CONSTANT REAL := 100;
resEuro REAL;
fact10 INTEGER;
BEGIN
Conversion_USD_EUR(hundredBucks, resEuro);
fact10 := facto(10);
END;

PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
SQL dynamique

PL/SQL : Création de curseur
Définition : Structure de données qui stocke le résultat d’une requête

retournant plusieurs n-uplets.
Déclaration : CURSOR nom_curseur IS requete_SQL;

ex. CURSOR calc_TVA IS
SELECT prod_num, price * 1.2 AS prix_TTC
FROM product;
NB : Les n-uplets du curseur sont de type calc_TVA%ROWTYPE.

PL/SQL : Curseur implicite
-- Parcours complet du curseur
DECLARE
CURSOR calc_TVA IS
SELECT prod_num, price * 1.2 AS prix_TTC
FROM product;
nuplet calc_TVA%ROWTYPE;
BEGIN
FOR nuplet IN calc_TVA LOOP
DBMS_OUTPUT.PUT_LINE(
nuplet.prod_num
|| ' : ' ||
nuplet.prix_TTC);
END LOOP;
PL/SQL : Curseur explicite
-- Parcours ad hoc du curseur
DECLARE
-- Comme précédemment
BEGIN
OPEN calc_TVA;
FETCH calc_TVA INTO nuplet; -- 1re ligne
WHILE calc_TVA%FOUND LOOP
FETCH calc_TVA INTO nuplet; -- Ligne suivante
END LOOP;
CLOSE calc_TVA;
END;

PL/SQL : Attributs des curseurs
%NOTFOUND est égal à FALSE si FETCH renvoie un résultat.
%FOUND est égal à TRUE si FETCH renvoie un résultat.
%ROWCOUNT renvoie le nombre de n-uplets lus.
%ISOPEN est égal à TRUE si le curseur est ouvert.

PL/SQL : Curseur paramétré
DECLARE
CURSOR c(s number) IS SELECT ename, sal FROM emp WHERE sal >= s;
nuplet c%ROWTYPE;
BEGIN
OPEN c(2500);
FETCH c INTO nuplet;
WHILE c%FOUND LOOP
DBMS_OUTPUT.PUT_LINE(nuplet.ename || ' : ' || nuplet.sal);
FETCH c INTO nuplet;
END LOOP;
CLOSE c;
END;

PL/SQL : Quizz
On veut appliquer un échantillonnage sur les
n-uplets d’une table. Quel type de curseur
doit-on utiliser pour les sélectionner ?
A. Curseur implicite
B. Curseur explicite
C. Curseur paramétré
Question n° 6655
PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
SQL dynamique

PL/SQL : Exceptions
Quand une erreur survient, une exception est levée (exécutée).

Gestion des erreurs dans des routines séparées du programme principal
Avantages
– Gestion systématique des erreurs
– Gestion groupée des erreurs similaires
– Lisibilité du code
Fonctions PL/SQL de gestion des erreurs

– SQLCODE : Code de la dernière exception levée
– SQLERRM : Message d’erreur associé

PL/SQL : Exceptions systèmes
Libellé erreur Code erreur SQLCODE
---------------------------------------------------------------------------------------
CURSOR_ALREADY_OPEN ORA-06511 -6511
DUP_VAL_ON_INDEX ORA-00001 -1
INVALID_CURSOR ORA-01001 -1001
INVALID_NUMBER ORA-01722 -1722
LOGIN_DENIED ORA-01017 -1017
NO_DATA_FOUND ORA-01403 -1403
NOT_LOGGED_ON ORA-01012 -1012
PROGRAM_ERROR ORA-06501 -6501
STORAGE_ERROR ORA-06500 -6500
TIMEOUT_ON_RESOURCE ORA-00051 -51
TOO_MANY_ROWS ORA-01422 -1422
VALUE_ERROR ORA-06502 -6502
ZERO_DIVIDE ORA-01476 -1476
PL/SQL : Exceptions personnalisées
Déclaration (section DECLARE)

nom_exception EXCEPTION;
Lever l’exception (section BEGIN)

IF condition THEN
RAISE nom_exception;
END IF;
Gérer l’exception (section EXCEPTION)

WHEN nom_exception THEN -- Instruction(s) PL/SQL ;

PL/SQL : Exemple d’exception
DECLARE
c INTEGER;
personne EXCEPTION;
BEGIN
SELECT COUNT(*) INTO c FROM emp;
IF c = 0 THEN
RAISE personne;
END IF;
EXCEPTION
WHEN personne THEN
RAISE_APPLICATION_ERROR(-20501, 'Table vide !');
END; -- Code d’erreur compris entre –20999 et -20001

PL/SQL : Gestion d’exceptions imprévues
DECLARE
i INTEGER := &saisie;
e1 EXCEPTION;
e2 EXCEPTION;
BEGIN
IF i = 1 THEN
RAISE e1;
ELSIF i = 2 THEN
RAISE e2;
ELSE
i := i / 0;
END IF;
EXCEPTION
WHEN e1 THEN RAISE_APPLICATION_ERROR(-20001, 'Exception 1');
WHEN e2 THEN RAISE_APPLICATION_ERROR(-20002, 'Exception 2');
WHEN OTHERS THEN RAISE_APPLICATION_ERROR(-20999, SQLERRM);
END;
PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
SQL dynamique

PL/SQL : Procédures stockées
Définition : Procédures précompilées stockées de manière

permanente dans la base de données
Création
CREATE PROCEDURE nom_proc (paramètres) AS ...
ex. CREATE PROCEDURE HelloWorld AS
BEGIN
DBMS_OUTPUT.PUT_LINE('Hello World!');
END;
Exécution sous SQL Developer en PL/SQL
ex. EXECUTE HelloWorld HelloWorld;
Suppression
ex. DROP PROCEDURE HelloWorld;
PL/SQL : Paquetages
Définition : Ensemble de types, curseurs, variables et sous-

programmes interreliés et stockés ensemble
Un paquetage est subdivisé en deux parties :
– Spécification : interface (déclarations publiques),
– Corps : déclarations privées et code.
Oracle 8 documentation
(Fig. 8-1)

PL/SQL : Définition d’un paquetage
-- Définition de la spécification
CREATE [OR REPLACE] PACKAGE nom_paquetage AS
[-- Définition de types publics]
[-- Déclaration de curseurs publics]
[-- Déclaration de variables globales publiques (à éviter !)]
[-- Déclaration de sous-programmes publics]
END;
-- Définition du corps (optionnelle)
CREATE [OR REPLACE] PACKAGE BODY nom_paquetage AS
[-- Définition de types privés]
[-- Spécification de curseurs publics et privés]
[-- Déclaration de variables globales privées (à éviter !)]
[-- Spécification de sous-programmes publics et privés]
END;
PL/SQL : Exemple de spécification de paquetage
CREATE OR REPLACE PACKAGE Employes AS
TYPE nuplet IS RECORD (ename emp.ename%TYPE,
salary emp.sal%TYPE);
CURSOR salaire_dec RETURN nuplet;
PROCEDURE embaucher (
numemp NUMBER,
nom VARCHAR,
job VARCHAR,
mgr NUMBER,
sal NUMBER,
comm NUMBER,
numdep NUMBER);
PROCEDURE licencier (emp_id NUMBER);
END;
PL/SQL : Exemple de corps de paquetage
CREATE OR REPLACE PACKAGE BODY Employes AS
CURSOR salaire_dec RETURN nuplet IS
SELECT empno, sal FROM emp ORDER BY sal DESC;
PROCEDURE embaucher (numemp NUMBER,
nom VARCHAR, job VARCHAR,
mgr NUMBER, sal NUMBER,
comm NUMBER, numdep NUMBER) IS
BEGIN
INSERT INTO emp VALUES (numemp, nom, job,
mgr, SYSDATE, sal, comm, numdep);
END;
PROCEDURE licencier (emp_id NUMBER) IS
BEGIN
DELETE FROM emp WHERE empno = emp_id;
END;
END;
PL/SQL : Déclencheurs
Définition : Procédure stockée associée à une table et exécutée

automatiquement lorsque des événements liés à des actions sur la
table surviennent (mises à jour, principalement).
Les déclencheurs complètent des contraintes d’intégrité en

permettant de créer des règles d’intégrité complexes. Ce sont des
éléments des bases de données actives.

PL/SQL : Principaux types de déclencheurs
Insertion Deletion Update
Before 1 2 3
After 4 5 6

PL/SQL : Définition de déclencheur
CREATE [OR REPLACE] TRIGGER nom_declencheur

BEFORE | AFTER
INSERT | DELETE | UPDATE
| [INSERT] [[OR] DELETE] [[OR] UPDATE]
ON nom_table
[FOR EACH ROW]
-- Bloc PL/SQL codant les actions à effectuer

PL/SQL : Variables spécifiques aux déclencheurs
:NEW.nom_attribut : Valeur d’un attribut après mise à jour
Ex. INSERT INTO client (1, 'NouveauClient');

:NEW.NumCli prend la valeur 1 dans le déclencheur.
:NEW.Nom prend la valeur 'NouveauClient' dans le déclencheur.
:OLD.nom_attribut : Valeur d’un attribut avant mise à jour
Ex. DELETE FROM client WHERE NumCli = 33;

:OLD.NumCli prend la valeur 33 dans le déclencheur.

PL/SQL : Exemple de déclencheur (1/2)
-- Emulation de clé primaire sur la table client
CREATE OR REPLACE TRIGGER client_pk
BEFORE INSERT OR UPDATE ON client
FOR EACH ROW
DECLARE
n INTEGER;
cle_existante EXCEPTION;
cle_nulle EXCEPTION;
BEGIN
-- La clé est-elle vide ?
IF :NEW.NumCli IS NULL THEN
RAISE cle_nulle;
END IF;
PL/SQL : Exemple de déclencheur (2/2)
-- La clé existe-t-elle déjà ?
SELECT COUNT(NumCli) INTO n FROM client
WHERE NumCli = :NEW.NumCli;
IF n > 0 THEN
RAISE cle_existe;
END IF;
EXCEPTION
WHEN cle_existe THEN
RAISE_APPLICATION_ERROR(-20501,
'Clé primaire déjà utilisée !');
WHEN cle_nulle THEN
RAISE_APPLICATION_ERROR(-20502,
'Une clé primaire doit avoir une valeur !');
END;
PL/SQL : Quizz
Deux tables T et T’ ont la même structure.
Chaque ajout de n-uplet dans T doit être
répercuté dans T’.
Quel type de déclencheur faut-il utiliser ?
A. BEFORE INSERT
B. BEFORE INSERT FOR EACH ROW
C. AFTER INSERT
D. AFTER INSERT FOR EACH ROW
Question n° 2247
PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
SQL dynamique

PL/SQL : SQL statique vs. SQL dynamique
Exemples
– Procédure stockée qui met la table EMP à jour
 SQL statique (la requête est connue à la compilation)
– Procédure stockée qui met à jour une table dont le nom est un paramètre
 SQL dynamique (la requête complète n’est pas connue à la compilation)
Définition du SQL dynamique :

Construction d’une requête SQL à la volée dans un bloc PL/SQL

PL/SQL : Requête dynamiques
Exécution : EXECUTE IMMEDIATE requete -- requete est une chaîne

[INTO res1, res2…];
Paramétrage
– EXECUTE IMMEDIATE requete [INTO res1, res2...]
[USING [IN | OUT | IN OUT] param1 -- Ne fonctionne que sur des
[, [IN | OUT | IN OUT] param2]... -- valeurs d’attributs
];
– Construction par concaténation de la chaîne requete (fonctionne dans tous les cas)
NB : Les requêtes qui altèrent la structure de la base de données

(CREATE, DROP, ALTER…), même statiques, doivent être exécutées
en mode dynamique.
PL/SQL : Exemples de requêtes dynamiques (1/2)
DECLARE
requete VARCHAR(250);
numdep dept.deptno%TYPE := 50;
nomdep dept.dname%TYPE := 'Staff';
ville dept.loc%TYPE := 'Lyon';
nuplet emp%ROWTYPE;
nom_table CHAR(4) := 'dept';
BEGIN
-- Requête paramétrée sur attributs (statique !)
requete := 'INSERT INTO dept VALUES (:p1, :p2, :p3)';
EXECUTE IMMEDIATE requete
USING numdep, nomdep, ville;
PL/SQL : Exemples de requêtes dynamiques (2/2)
-- Récupération d’un résultat
requete := 'SELECT * FROM emp WHERE empno = :id';
EXECUTE IMMEDIATE requete INTO nuplet USING 5560;
-- Sans variable pour la requête

EXECUTE IMMEDIATE
'DELETE FROM dept WHERE deptno = :n'
USING numdep;
-- Construction de la requête par concaténation

EXECUTE IMMEDIATE
'DELETE FROM ' || nom_table || ' WHERE deptno = ' || numdep;
END;

PL/SQL : Curseurs dynamiques
DECLARE -- Exemple
TYPE CursDyn IS REF CURSOR; -- Pointeur vers un curseur
emp_cv CursDyn; -- Curseur dynamique
nom emp.ename%TYPE;
salaire emp.sal%TYPE := 10000;
BEGIN
OPEN emp_cv FOR -- Le curseur est forcément explicite
'SELECT ename, sal FROM emp
WHERE sal > ' || salaire;
FETCH emp_cv INTO nom, salaire;
WHILE emp_cv%FOUND LOOP
FETCH emp_cv INTO nom, salaire;
END LOOP;
CLOSE emp_cv;
END;
PL/SQL : Quizz
Lesquelles de ces requêtes sont dynamiques ?
A. SELECT * FROM emp;

B. SELECT * FROM emp WHERE empno = n;
C. SELECT COUNT(*) FROM nom_table;
D. DROP TABLE emp;
Question n° 6361

PL/SQL : Plan
Introduction
Bases du langage
Curseurs
Gestion des erreurs
SQL dynamique

Partie 2
XML/XQuery
Bases de données avancées 75

XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
– XPath
– Requêtes FLWOR
– Requêtes complexes

XML/XQuery : Données structurées
Les données sont organisées en entités.
Les entités similaires forment des groupes (classes).
Les entités du même groupe ont la même description (attributs).
Pour toutes les entités d’un groupe :
– Chaque attribut a le même type.
– Chaque valeur d’attribut a la même taille.
– Tous les attributs sont présents.
– Les attributs sont toujours dans le même ordre.
Les données structurés sont décrites par un schéma.

– Elles sont généralement stockées dans des bases de données.
XML/XQuery : Données non structurées
Les données sont de tous types.

Les données ne suivent aucun schéma ni séquence prédéterminé.
Les données ne suivent aucune règle.
Les données ne sont pas prévisibles.
Exemples de données non-structurées :

– Textes
– Images
– Vidéos
– Sons
XML/XQuery : Données semi-structurées
Bases de Documents
données
Moteurs de recherche
Langages de requête
Années 1990
Données Données Données

structurées semi-structurées non structurées

XML/XQuery : Données semi-structurées
Les données sont organisées en entités sémantiques.
Structurées
Les entités similaires forment des groupes.
Les entités du même groupe peuvent ne pas avoir les mêmes attributs.
Pour toutes les entités d’un groupe :
Non-structurées
– Un même attribut peut avoir des types différents.
– Une même valeur d’attribut peut avoir des tailles différentes.
– Des attributs peuvent être manquants ou dupliqués.
– L’ordre des attributs n’est pas nécessairement important.
Les données semi-structurées sont autodescriptives.

– Pages web, documents XML, courriels…
XML/XQuery : Exemple de données semi-structurées
Nom Jérôme Darmont

Courriel jerome.darmont@univ-lyon2.fr
jdarmont@eric.univ-lyon2.fr
Courriel sabine.loudcher@univ-lyon2.fr
Nom
– Prénom Loudcher
– Nom de famille Sabine
Nom Julien Velcin

Affiliation Université Lumière Lyon 2
XML/XQuery : Modèle de données semi-structuré
Avantages
– Peut représenter des informations issues de sources de données qui ne
peuvent pas êtres contraintes par un schéma
– Format flexible pour l’interopérabilité
– Permet de voir des données structurées comme semi-structurées (Web)
– Le schéma peut facilement évoluer.
Inconvénients
– Performance des requêtes sur données à grande échelle
Représentations standards
– Electronic Data Interchange (EDI) : domaine financier
– Object Exchange Model (OEM) : modèle basé sur les graphes
– SGML, HTML et XML
XML/XQuery : Exemple de graphe OEM

XML/XQuery : Gestion de données semi-structurées
Modélisation des données semi-structurées

– Graphes (OEM) – Modèle logique
– XML – Modèle physique
Requêtage des données semi-structurées

– XPath
– XQuery
Stockage des données semi-structurées

– Fichiers plats
– Bases de données relationnelles, relationnelles-objets ou natives XML

XML/XQuery : Références
Peter Wood, Birkbeck University of London

Semi-Structured Data
http://www.dcs.bbk.ac.uk/~ptw/
Mike Bergman, Structured Dynamics LLC

Semi-structured Data: Happy 10th Birthday!
http://www.mkbergman.com/153/semi-structured-data-happy-10th-
birthday/

XML/XQuery : Sondage express
Pensez-vous avoir compris la

Différence entre données structurées,
non structurées et semi-structurées ?
Question n° 8121

XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
– XPath
– Requêtes FLWOR

XML/XQuery : Le langage XML
XML : Extensible Markup Language

– Format de structuration de données et de documents Internet issu de SGML
– Définition, gestion, création, transmission et partage de documents
XML est un standard du W3C

– 1996 : Brouillon SGML
– 1997 : XML 1.0
– 2004 : XML 1.1
HTML XML

XML/XQuery : Exemple de document XML
<?xml version="1.1" encoding=“utf-8" ?> 
<annuaire_professeurs> 
<!– Sous-éléments -->
<professeur>
<nom>Jérôme Darmont</nom>
<courriel>jerome.darmont@univ-lyon2.fr</courriel>
<cours>Bases de données avancées</cours>
<cours>Programmation Web</cours> Ensemble d’éléments imbriqués
</professeur> matérialisés par des balises
<professeur>
<nom>Julien Velcin</nom>
<courriel>julien.velcin@univ-lyon2.fr</courriel>
<cours>Programmation orientée objet</cours>
</professeur>

</annuaire_professeurs> 
XML/XQuery : Règles d’écriture d’un document XML (1/2)
Un document XML a un et un seul élément racine.

Les éléments doivent être correctement emboîtés (les balises ouvrantes
et fermantes ne doivent pas se chevaucher).
Tout élément doit avoir une balise ouvrante et une balise fermante.
Le nom d’un élément doit être identique dans la balise ouvrante et la
balise fermante.
Les noms d’éléments sont sensibles à la casse. Ils doivent commencer
par une lettre ou par _ suivi(e) de lettres, de chiffres, de . , de – ou de _.

XML/XQuery : Règles d’écriture d’un document XML (2/2)
Les noms d’éléments commençant par XML (dans toutes combinaisons

de minuscules et majuscules) sont réservés à des fins de
standardisation.
Un document XML respectant ces règles est dit bien formé.
Un document XML doit être bien formé !
Un document XML peut de plus être valide s’il se conforme à la

structure définie dans une DTD ou un Schéma XML.
Document Type Definition XML Schema

XML/XQuery : Schémas XML
DTD XML Schema
Syntaxe spécifique (non XML) Exprimé dans un document XML
Typage faible Typage fort
Modélisation partielle impossible Modélisation partielle possible
Interprétable par un·e utilisateur·trice Conçu pour des traitements

humain·e automatiques

XML/XQuery : Éléments XML (1/2)
Caractères non-autorisés : < & ]]>
Eléments emboîtés : profondeur non limitée

– Ex. <annuaire_professeurs>
<professeur>
<nom>
<nom_famille>Zighed</nom_famille>
<prenom>Abdelkader</prenom>
<prenom>Djamel</prenom>
</nom>
</professeur>
</annuaire_professeurs>
XML/XQuery : Éléments XML (2/2)
Section CDATA : Bloc de texte libre dans lequel seule la chaîne ]]> est
interdite
– Ex. <nom>
<![CDATA[<Darmont> & <Loudcher>]]>
</nom>
Élément vide : sans contenu

– Ex. <courriel></courriel>
– Formulation équivalente <courriel />

XML/XQuery : Attributs d’éléments XML
Attributs : données associées à un élément, complémentaires du contenu
Définition : couple nom/valeur dans la balise ouvrante de l’élément

– Ex. <bureau campus="PdA" batiment="K">063</bureau>
attribut valeur attribut valeur
Les attributs sont possibles dans les éléments vides.

– Ex. <image source="ma_bobine.png" />

XML/XQuery : Contenu d’élément XML vs. attributs (1/2)
Que choisir ?
– <professeur>
<nom>Darmont</nom>
</professeur>
– <professeur nom="Darmont" />
4 principes pour décider

– Uche Ogbuji, Fourthought, Inc.
– Source : http://www.ibm.com/developerworks/xml/library/x-eleatt/

XML/XQuery : Contenu d’élément XML vs. attributs (2/2)
Principe Élément Attribut

Contenu principal Information essentielle Information périphérique
Information structurée Information hiérarchisée Information atomique
Lisibilité Utilisateur.trice humain.e Traitement automatique
Relation élément/attribut Information précisée par une autre
Exemple de relation <stock>

élément/attribut <produit quantité="1500">
<nom>Ordinateur</nom>
</produit>
<produit quantité="500">
<nom>Imprimante</nom>
</produit>
</stock>
XML/XQuery : Quizz
Dans un document XML, les données

sont stockées dans :
A. Les éléments
B. Les attributs
Question n° 5450
XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
– XPath
– Requêtes FLWOR

XML/XQuery : Le langage XQuery
Langage de requêtes pour données XML
Similarités avec SQL
Conçu par le W3C
Basé sur des expressions XPath (mêmes modèle de données, fonctions, opérateurs)
Versions
– 2007 : XQuery 1.0  XPath 2.0
– 2014 : XQuery 3.0  XPath 3.0
Standardisation en cours
Soutenu par les éditeurs de SGBD (Oracle, Microsoft, IBM…)
XML/XQuery : Document XML exemple (1/2)
<?xml version="1.1" encoding="utf-8" ?>
<catalogue>
<dvd zone="1">
<titre>Blade runner</titre>
<realisateur>Ridley Scott</realisateur>
<annee>1982</annee>
<duree>117</duree>
<langue>Anglais</langue>
<prix>14.79</prix>
</dvd>
<dvd zone="2">
<titre>La grande vadrouille</titre>
<realisateur>Gérard Oury</realisateur>
<annee>1966</annee>
<duree>122</duree>
<langue>Français</langue>
<prix>19.82</prix>
</dvd> 
XML/XQuery : Document XML exemple (2/2)
<dvd zone="2">
<titre>Le fabuleux destin d'Amélie Poulain</titre>
<realisateur>Jean-Pierre Jeunet</realisateur>
<annee>2001</annee>
<duree>120</duree>
<prix>14.99</prix>
</dvd>
<dvd zone="2">
<titre>The big Lebowski</titre>
<realisateur>Ethan Coen</realisateur>
<realisateur>Joel Coen</realisateur>
<annee>1997</annee>
<duree>112</duree>
<langue>Anglais</langue>
<prix>19.82</prix>
</dvd>
Bases de données avancées
</catalogue> http://eric.univ-lyon2.fr/~jdarmont/ 102
XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
– XPath
– Requêtes FLWOR

XML/XQuery : Expressions de chemins (1/3)
Document XML entier

doc("dvd.xml")/catalogue
Résultat Par
Tout le document l’exemple
Un élément donné
doc("dvd.xml")/catalogue/dvd
doc("dvd.xml")/catalogue/dvd/titre
Résultat
Un attribut donné
doc("dvd.xml")/catalogue/dvd/data(@zone)
Résultat
1222
Un élément donné quel que soit son niveau hiérarchique

doc("dvd.xml")/catalogue//titre
//titre
Résultat
Tous les sous-éléments d’un élément
doc("dvd.xml")/catalogue/dvd/*
Résultat
<realisateur>Ridley Scott</realisateur>
<annee>1982</annee>
<duree>117</duree>
<langue>English</langue>
<prix>14.79</prix>
<realisateur>Gérard Oury</realisateur>
<annee>1966</annee>
<duree>122</duree>
<langue>French</langue>
<prix>19.82</prix> Etc.
XML/XQuery : Prédicats XPath (1/2)
ie, dernier, i premiers/derniers éléments
doc("dvd.xml")/catalogue/dvd[1]
doc("dvd.xml")/catalogue/dvd[last()]
doc("dvd.xml")/catalogue/dvd[position() < 3]/titre
Résultat
Éléments possédant un sous-élément ou attribut donné

doc("dvd.xml")/catalogue/dvd[duree]/titre
Résultat
doc("dvd.xml")/catalogue/dvd[@zone]
XML/XQuery : Prédicats XPath (2/2)
Condition sur un élément ou un attribut

doc("dvd.xml")/catalogue/dvd[price < 15]
doc("dvd.xml")/catalogue/dvd[@zone = "2" and prix < 15]/titre
Résultat
Combinaison de chemins
doc("dvd.xml")//titre | doc("dvd.xml")//prix
Résultat
<titre>Blade runner</titre><prix>14.79</prix>
<titre>La grande vadrouille</titre><prix>19.82</prix>
<titre>Le fabuleux destin d'Amélie Poulain</titre><prix>14.99</prix>
<titre>The big Lebowski</titre> <prix>19.82</prix>

XML/XQuery : Quizz
Lesquels de ces chemins sont-ils corrects ?
A. /catalogue/dvd/prix
B. doc("dvd.xml")/catalogue/dvd/prix
C. //prix
D. /catalogue//prix
Question n° 5462

XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
XPath
– Requêtes FLWOR

XML/XQuery : Requêtes FLWOR
For, Let, Where, Order by, Return
Clause For (1/3) : lie une variable à chaque élément retourné par
une expression (itération)
Exemple
for $x in (1 to 3) 
return <res>{$x}</res>
Résultat
<res>1</res>
<res>2</res>
<res>3</res>
XML/XQuery : Clause For (2/3)
Exemple
for $x in (1, 2),
$y in (10, 20) (: Ceci est également un commentaire :)
return <res>x = {$x} et y = {$y}</res>
Résultat
<res>x = 1 et y = 10</res>
<res>x = 1 et y = 20</res>
<res>x = 2 et y = 10</res>
<res>x = 2 et y = 20</res>

XML/XQuery : Clause For (3/3)
Exemple
for $x at $i in doc("dvd.xml")/catalogue/dvd/titre
return <dvd id="{$i}">{data($x)}</dvd>
Résultat
<dvd id="1">Blade runner</dvd>
<dvd id="2">La grande vadrouille</dvd>
<dvd id="3">Le fabuleux destin d'Amélie Poulain</dvd>
<dvd id="4">The big Lebowski</dvd>

XML/XQuery : Clause Let
Clause Let : Assigner une ou plusieurs valeurs à une variable

(pas d’itération)
Exemple
let $x := (1 to 5)
return <res>{$x}</res>
Résultat
<res>1 2 3 4 5</res>

XML/XQuery : Clause Where
Clause Where : Spécifie une ou plusieurs conditions sur le résultat
Exemple
for $x in doc("dvd.xml")/catalogue/dvd
where $x/prix > 15
return $x/titre
Exemple
where $x/@zone = "2" and $x/prix < 10
return $x/titre
XML/XQuery : Clauses Order by et Return (1/2)
Clause Order by : Trie le résultat

Exemple
order by $x/titre
return $x/titre
Exemple
order by $x/@zone, $x/titre descending
return $x/titre
Clause Return : Spécifie le résultat

XML/XQuery : Clause Return (2/2)
Expressions conditionnelles
Exemple
return if ($x/@zone="1")
then <zoneUS>{data($x/titre)}</zoneUS>
else <zoneEU>{data($x/titre)}</zoneEU>
Résultat
<zoneUS>Blade runner</zoneUS>
<zoneEU>La grande vadrouille</zoneEU>
<zoneEU>Le fabuleux destin d'Amélie Poulain</zoneEU>
<zoneEU>The big Lebowski</zoneEU>
XML/XQuery : Fonctions XPath/XQuery (1/2)
Fonctions d’accès : data()…

Fonctions numériques : abs(), floor(), ceiling(), round(), number()…
Fonctions de chaînes : string-length(), upper-case(), lower-case(),
normalize-space(), substring(), substring-after(), replace(), contains()…
Fonctions temporelles : day-from-date(), year-from-date()…
Fonctions de séquences : exists(), distinct-values(), reverse()…
Fonctions contextuelles : last(), position()…
Fonctions booléennes : not()…

XML/XQuery : Fonctions XPath/XQuery (2/2)
Exemple d’appel à une fonction

for $x in doc("dvd.xml")/catalog/dvd/titre
let $titreMAJ := upper-case($x)
return <film>{$titreMAJ}</film>
Résultat
<film>BLADE RUNNER</film>
<film>LA GRANDE VADROUILLE</film>
<film>LE FABULEUX DESTIN D'AMÉLIE POULAIN</film>
<film>THE BIG LEBOWSKI</film>

XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
XPath
Requêtes FLWOR

XML/XQuery : Clause Group by (XQuery 3)
Regroupement sur un critère

for $d in /catalogue/dvd
group by $z := $d/@zone
return <zone value="{$z}">
<prix_moyen>{avg($d/prix)}</prix_moyen>
</zone>
Regroupement multiple
for $d in /catalogue/dvd
group by $z := $d/@zone, $a := $d/annee
return <groupe zone="{$z}" annee="{$a}">
<prix_moyen>{avg($d/prix)}</prix_moyen>
</groupe>
XML/XQuery : Jointures – Documents exemples (1/3)
<?xml version="1.1" encoding="utf-8" ?> 
<clients>
<client id="1">
<nom>Loudcher</nom>
<prenom>Sabine</prenom>
<addresse>Bureau K073</addresse>
</client>
<client id="2">
<nom>Bentayeb</nom>
<prenom>Fadila</prenom>
</client>
<client id="3">
<nom>Darmont</nom>
<prenom>Jérôme</prenom>
</client>
</clients>
<?xml version="1.1" encoding="utf-8" ?> 

<produits>
<produit id="10">
<nom>Ordinateur</nom>
</produit>
<produit id="20">
<nom>Moniteur</nom>
</produit>
<produit id="30">
<nom>Imprimante</nom>
</produit>
</produits>

<?xml version="1.1" encoding="utf-8" ?> 
<commandes>
<commande cli-id="1" prod-id="10">
<quantite>3</quantite>
</commande>
</commande>
</commande>
</commande>
</commande>
</commandes>
XML/XQuery : Jointures de documents XML (1/3)
Exemple
for $c in doc("clients.xml")//client,
$o in doc("commandes.xml")//commande
where $c/@id = $o/@cli-id
return <res>{data($c/nom)}, {data($c/prenom)}:
{data($o/quantite)}</res>
Résultat
<res>Loudcher, Sabine : 3</res>
<res>Loudcher, Sabine : 15</res>
<res>Bentayeb, Fadila : 7</res>
<res>Bentayeb, Fadila : 10</res>
<res>Darmont, Jérôme : 5</res>
Exemple
$o in doc("commandes.xml")//commande,
$p in doc("produits.xml")//produit
where $c/@id = $o/@cli-id
and $o/@prod-id = $p/@id
{data($o/quantite)} x {data($p/nom)}</res>
Résultat
<res>Loudcher, Sabine : 3 x Ordinateur</res>
<res>Loudcher, Sabine : 15 x Moniteur</res>
<res>Bentayeb, Fadila : 7 x Ordinateur</res>
<res>Bentayeb, Fadila : 10 x Imprimante</res>
<res>Darmont, Jérôme : 5 x Imprimante</res>
Variantes avec les conditions de jointures exprimées

en prédicats de chemins
$o in doc("commandes.xml")//commande[@cli-id=$c/@id]
{data($o/quantite)}</res>
for $c in //client,
$p in //produit,
$o in //commande[@cli-id=$c/@id and @prod-id=$p/@id]
return <res>{data($c/nom)}, {data($c/prenom)} :
{data($o/quantite)} x {data($p/nom)}</res>

XML/XQuery : Quizz
Quelles clauses de requêtes FLWOR sont

également exprimables en XPath ?
A. For
B. Where
C. Order by
D. Group by
Question n° 7489
XML/XQuery : Plan
Introduction
Documents XML
Langage XQuery
XPath
Requêtes FLWOR
Requêtes complexes

Sondage express
Que pensez-vous de ce cours ?
Question n° 2361

3 1 Cours

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

3 1 Cours

Transféré par

Droits d'auteur :

Formats disponibles

Bases de données avancées

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 2

SQL : langage de requêtes (bases de données relationnelles)

Programmation nécessaire pour :

80 % des données sont peu ou pas structurées Langage

Bases de données avancées 4

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 5

SQL encapsulé : Requêtes SQL incorporées dans le code source

Langage de 4e génération (L4G = L3G + syntaxe type SQL)

Conçu comme une extension de SQL

Déclaration de variables et de constantes

Types abstraits (collections, enregistrements, objets)

Modularité (sous-programmes, paquetages)

Gestion des erreurs (Gestion des erreurs)

Interaction étroite avec Oracle/SQL (types identiques)

SQL dynamique (construction de requêtes à la volée)

Programmation orientée objet

Performance (traitement par lots)

Productivité (uniformité des outils Oracle)

Portabilité (sur tous systèmes Oracle)

Sécurité (procédures stockées, déclencheurs)

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 8

Génie logiciel Réseau

Logiciels tiers Administration

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 9

Oracle Database PL/SQL

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 10

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 11

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 12

A. Jusqu’ici, tout va bien.

B. Je suis déjà perdu.

Répondre sur http://toreply.univ-lille1.fr

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 13

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 14

Déclaration dans la section DECLARE d’un bloc PL/SQL

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 15

Oracle Database PL/SQL

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 16

Type d’une autre variable

Type de l’attribut d’une table

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 17

Valeur de la base de données

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 18

Opérateurs de comparaison = < > <= >= <>

Opérateurs logiques AND OR NOT

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 19

IF-THEN, IF-THEN-ELSE ou IF-THEN-ELSIF

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 20

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 21

En cas de dépassement, la taille du tampon d’affichage doit être augmentée.

Répondre sur http://toreply.univ-lille1.fr

Définition : Ensemble ordonné d’éléments de même type. Chaque

Deux types de collections

Oracle Database PL/SQL

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 26

1. Déclarer un type collection

2. Déclarer une collection et l’initialiser

NB : Une collection peut être déclarée vide (c’est le cas de t).

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 27

Elément d’une collection

Bases de données avancées http://eric.univ-lyon2.fr/~jdarmont/ 28

Ensemble de méthodes ( procédures)

EXISTS(i) renvoie TRUE si le ie élément existe dans la collection.