support_cours.pdf

SGBD et L4G
II2
KHCHERIF Raoudha
Raoudha.khcherif@topnet.tn
Bureau : 109
École Nationale des Sciences Informatiques

KHCHERIFRaoudha SGBD et L4G 2
Plan du cours
I. Architecture d‟un SGBD
II. Le Langage de définition de Données
III. Le Langage de manipulation de données
IV. Le Langage PL/SQL

I. Architecture d’un SGBD
Définitions:
BD: Collections de données cohérentes
et structurées
Système de Gestion de Bases de
Données
(SGBD) : Logiciel(s) assurant
structuration,
stockage, maintenance, mise à jour et
consultation des données d’une BD

I.1 Objectifs des SGBD
• Indépendance physique : un remaniement
de l’organisation physique des données
n’entraîne pas de modification dans les
programmes d’application (traitements)
• Indépendance logique : un remaniement de
l’organisation logique des fichiers (ex.
nouvelle rubrique) n’entraîne pas de
modification dans les programmes
d’application non concernés

• Manipulation facile des données : un
utilisateur non-informaticien doit pouvoir
manipuler simplement les données
(interrogation et mise à jour)
• Administration facile des données : un
SGBD doit fournir des outils pour décrire les
données, permettre le suivi de ces
structures et autoriser leur évolution (tâche
de l’administrateur BD)

• Efficacité des accès aux données : garantie d‟un
bon débit (nombre de transactions exécutées par
seconde) et d‟un bon temps de réponse (temps
d‟attente moyen pour une transaction)
• Redondance contrôlée des données : diminution
du volume de stockage, pas de mise à jour
multiple ni d‟incohérence

• Cohérence des données : ex. L‟âge d‟une
personne doit être un nombre entier positif. Le
SGBD doit veiller à ce que les applications
respectent cette règle (contrainte d’intégrité).
• Partage des données : utilisation simultanée les
données par différentes applications
• Sécurité des données : les données doivent être
protégées contre les accès non-autorisés ou en cas
de panne

I.2 Fonctions des SGBD
• Description des données : (LDD)
• Recherche des données
• Mise à jour des données
• Transformation des données
• Contrôle de l‟intégrité des données (respect des
contraintes d‟intégrité)
• Gestion de transactions (atomicité des transactions)
et sécurité (mots de passe, etc.)
}LMD

I.3 Architecture fonctionnelle type d’un SGBD
• Architecture Ansi/Sparc:
– Niveau externe: C‟est le niveau d‟expression des
besoins des utilisateurs. Il formalise les préoccupations
de chaque utilisateur et sera en final confronté au
schéma conceptuel global.
– Niveau conceptuel: Décrit la structure de la base de
données globalement à tous les utilisateurs (limite la
redondance) . Ce schéma décrit la structure de la base
indépendamment de son implantation

I.3 Architecture fonctionnelle type d’un SGBD
– Niveau interne : c‟est le niveau d‟implantation
informatique de la solution conceptuelle:
• Niveau interne logique: intègre une technologie
particulière, comme par exemple la technologie des
bases de données relationnelles.
• Niveau interne physique: c‟est le niveau
d‟implantation physique où l‟on tient compte d‟un
environnement logiciel et matériel donné.

Architecture Ansi/Sparc

Exemple: institut de formation
permanente
• Schéma logique
– Etudiant: nétudiant, nom, prénom, date_naissance
– Enseignant: nom, prénom, statut, compte_bancaire
– Cours: nomC, cycle, nom_enseignant
– Inscription: nétudiant, nom_cours, note1, note2

Exemple (suite)
• Schémas externes.
• Schéma externe du professeur de base de données:
– Etudiant_BD: nom, prénom, note1, note2, note_finale tel
que Etudiant_BD résulte de la combinaison de Etudiant et
Inscription du SL, tels qu'il existe une Inscription de cet
étudiant pour le cours BD (nétudiant dans Etudiant =
nétudiant dans Inscription et nom_cours dans Inscription
= BD), et tel que note_finale = (note1 + note2)/2

Exemple (suite)
• Schéma externe du service de gestion du personnel
enseignant :
– Professeur: nom, prénom, ncompte_bancaire,
nombre_de_cours, liste(nom_cours) tel que Professeur
résulte de la combinaison de Enseignant et Cours du SL,
tels que liste(nom_cours) est la liste de nomC qui se
trouvent dans Cours tel que nom_enseignant dans Cours =
nom dans Enseignant, et tel que nombre_de_cours =
Cardinalité (liste(nom_cours))

Exemple (suite)
• Schéma interne (SI)
– Etudiant: fichier FEtud, contenu: nom, prénom, date de
naissance, nétudiant indexé sur nétudiant, index
secondaire sur nom+prénom
– Enseignant + cours: fichier FEnsCours, contenu: nom,
prénom, statut, ncompte_bancaire, liste(nomC, cycle)
tel que nom_enseignant dans Cours = nom dans
Enseignant indexé sur nom, deux index secondaires,
l'un sur nomC, l'autre sur cycle
– Inscription: fichier FInscrits, contenu: nétudiant,
nom_cours, note1, note2 indexé sur nétudiant, index
secondaire sur nom_cours

Stockage
• Stockage des données dans les supports
physiques
• gestion des structures de mémorisation
(fichiers)
• gestion des structures d ‟accès (gestion des
index, des clés,…)

Contrôle
• Optimisation globale des requêtes
• Gestion des conflits d ‟accès simultanés par
plusieurs utilisateurs
• Contrôle général de la cohérence de l ‟ensemble
• Coordination et suivi des processus en cours
• Garantie du bon déroulement des actions
entreprises

Dialogue
• Analyse des demandes de l ‟utilisateur
• Contrôle des droits d ‟accès de l ‟utilisateur
• Présentation des résultats.

II. Le langage de Définition des Données
(LDD SQL)
• SQL = Structured Query Language, issu de
SEQUEL (Structured English as a Query
Language)
• SQL permet la définition, la manipulation et le
contrôle d’une base de données relationnelle.
Il se base sur l’algèbre relationnelle.
• SQL est un standard ANSI depuis 1986.
• Nous adoptons dans ce chapitre la syntaxe
de SQL*Plus (Oracle).

II.2 Créations de Table:
CREATE TABLE
• Forme simple
• Transmise à l ‟interprète du LDD
– vérification
– création de la table
• schémastockédans dictionnairededonnées
• allocation des structuresphysiques
CREATE TABLE Client
(noClient INTEGER,
nomClient VARCHAR(15),
noTéléphone VARCHAR(15)
)

La commande DESCRIBE
• la commande DESCRIBE permet de retrouver le
format d‟une table
SQL> describe s_dept;
Name Null? Type
------------------------------- -------- ----
ID NOT NULL NUMBER(7)
NAME NOT NULL VARCHAR2(25)
REGION_ID NUMBER(7)

Types de données SQL
• CHAR(n):
• chaîne de caractères de longueur fixe n
• longueur par défaut 1
• longueur minimum 1,longueur maximum 255
• constantes:
• „DUPONT‟
• „Dupont,Marc‟
• „Titre“Coucou”‟
• „1234‟
• „NULL‟

Type de données: VARCHAR2(n)
• chaîne de caractères de longueur variable et
de taille maximum n
– Longueur maximale : 32767 octets
• uniquement sur Oracle sinon CHAR
VARYING(n)
• constantes identiques a CHAR(n)

Type de données: NUMBER(p)
• nombre entier positif, négatif ou nul de p
chiffres
• constantes:
– 0
– +0
– +1234
– -123123
– 1234

Type de données:
NUMBER(p,s)
• nombre réel en virgule fixe de p chiffres au total
dont s après la virgule
• constantes de type NUMBER(4,1):
– 0,0
– 123,5
– -123,7
– -3,0
• d'après la configuration, il faut utiliser „.‟ ou „,‟
• certains SQL utilisent NUMERIC(p,s)

Type de données: LONG
• chaîne de caractères de taille variable
jusqu'à 2 Gbytes
• limité à un seul attribut par table

Type de données: DATE
• date (siècle, année, mois, jour, heure, minute, seconde)
• constantes
– „07-OCT-97‟
– „30-FEB-97‟ pas correct !
– „01-FEB-98‟ ou „01-FEV-98‟
– SYSDATE == date et heure actuelle
• l'arithmétiquefonctionne sur les dates:
– „10-OCT-99‟ - „09-OCT-99‟ == 1
– „07-OCT-96‟ + 10 == „17-OCT-96‟
– Par défaut DD-MON-YY (18-DEC-02)
– Fonction TO_DATE
Exemple :
start_date := to_date(‟29-SEP-2003‟,‟DD-MON-YYYY‟);
start_date := to_date(‟29-SEP-2003:13:01‟,‟DD-MON-YYYY:HH24:MI‟);

La valeur NULL
• la valeur NULL est spéciale
– NULL appartient à tous les domaines: CHAR, LONG,
NUMBER, …
– signifie que la ligne n‟a pas de valeur pour cet attribut
• ne pas confondre avec
– „„
– 0
– 0.0

Contrainte NOT NULL
• lors de la création d‟une table on peut spécifier
que certains attributs ne peuvent prendre la valeur
NULL
CREATE TABLE s_dept
(id NUMBER(7) NOT NULL,
name VARCHAR2(25) ,
region_id NUMBER(7) ) ;

Définition des clés primaires et
étrangères
• Clé primaire :
CONSTRAINT nom_contrainte PRIMARY KEY
(attribut_clé [, attribut_clé2, …])
• Clé étrangère :
CONSTRAINT nom_contrainte FOREIGN KEY
(attribut_clé_ét) REFERENCES table(attribut)

Définition des clés (exemple)
CREATE TABLE Client ( NumCli NUMBER(3),
Nom CHAR(30),
DateNaiss DATE,
Salaire NUMBER(8,2),
NumEmp NUMBER(3),
CONSTRAINT cle_pri PRIMARY KEY (NumCli),
CONSTRAINT cle_etr FOREIGN KEY (NumEmp)
REFERENCES EMPLOYEUR(NumEmp));

Définition des contraintes
d’intégrités
• Contrainte de domaine :
CONSTRAINT nom_cont CHECK (condition)
• Exemple:
CREATE TABLE Client ( NumCli NUMBER(3),
Nom CHAR(30),
DateNaiss DATE,
Salaire NUMBER(8,2),
NumEmp NUMBER(3),
CONSTRAINT cle_pri PRIMARY KEY (NumCli),
CONSTRAINT cle_etr FOREIGN KEY (NumEmp) REFERENCES
EMPLOYEUR(NumEmp),
CONSTRAINT date_ok CHECK (DateNaiss
<SYSDATE));

Définitions des index
• Création d’index (accélération des accès)
CREATE [UNIQUE] INDEX nom_index ON
nom_table (attribut [ASC|DESC], …);
• UNIQUE pas de double
• ASC/DESC ordre croissant ou décroissant
CREATE UNIQUE INDEX Icli ON Client (NumCli);
• Destructions : DROP TABLE nom_table;
DROP INDEX nom_index;

Modification du schéma d’une
table
• Ajout d’attributs
ALTER TABLE nom_table ADD (attribut TYPE, …);
ex. ALTER TABLE Client ADD (tel NUMBER(8));
• Modifications d’attributs
ALTER TABLE nom_table MODIFY (attribut TYPE,
…);
ex. ALTER TABLE Client MODIFY (tel
NUMBER(10));
• Suppression de contraintes
ALTER TABLE nom_table DROP CONSTRAINT
nom_contrainte;

III. Le Langage de Manipulation
de données (LMD SQL)
III.1 Syntaxe générale d’une requête:
SELECT [ALL|DISTINCT] attribut(s) FROM table(s)
[WHERE condition] [GROUP BY attribut(s)
[HAVING condition]]
[ORDER BY attribut(s) [ASC|DESC]];
• Tous les tuples d’une table
ex. SELECT * FROM Client;
• Tri du résultat
ex. Par ordre alphabétique inverse de nom
SELECT * FROM Client ORDER BY Nom DESC;

BD exemple
• client ( numcli , nom, prenom, adresse, codepost,
ville, tel);
• produit ( numprod, designation, prixunit, qtestock );
• commande ( numcom, numcli, idvendeur, datec,
quantite, numprod);
• vendeur ( idvendeur, nomvendeur, qualité, salaire,
commission));

Interrogation des données
• Calculs ex. Calcul de prix TTC
SELECT PrixUni+PrixUni*0.206 FROM Produit;
• Projection
ex. Noms et Prénoms des clients, uniquement
SELECT Nom, Prenom FROM Client;
• Restriction
ex. Clients qui habitent à Tunis
SELECT * FROM Client WHERE Ville = ‘Tunis’;

• ex. Commandes en quantité au moins égale à 3
SELECT * FROM Commande WHERE Quantite >=
3;
• ex. Produits dont le prix est compris entre 50 et
100 DT
SELECT * FROM Produit
WHERE PrixUni BETWEEN 50 AND 100;
• ex. Commandes en quantité indéterminée
SELECT * FROM Commande WHERE Quantite IS
NULL;

• ex. Clients habitant une ville dont le
nom se
termine par Menzel
SELECT * FROM Client
WHERE Ville LIKE ‘%Menzel’;
• ‘Menzel%’  commence par Menzel
• ‘%Men%’  contient le mot Men
– le joker„_‟ peut être remplacépar n‟importequel caractère
– le joker„%‟ peut être remplacépar 0, 1, 2, … caractères

• ex. Prénoms des clients dont le nom est
Mohamed,
Ahmed ou Mahmoud
SELECT Prenom FROM Client
WHERE Nom IN (‘Ahmed’, ‘Mahmoud’, ‘Mohamed’);
• spécifie une liste de constantes dont une doit égaler le premier terme pour
que la condition soit vraie
• pour des NUMBER, CHAR, VARCHAR, DATE
• NB : Possibilité d’utiliser la négation pour tous ces
prédicats : NOT BETWEEN, NOT NULL, NOT LIKE,
NOT IN.

Fonctions d’agrégat
• Elles opèrent sur un ensemble de valeurs,
fournissent une valeur unique
– AVG() : moyenne des valeurs
– SUM() : somme des valeurs
– MIN(), MAX() : valeur minimum, valeur maximum
– COUNT() : nombre de valeurs
• ex. Moyenne des prix des produits
SELECT AVG(PrixUni) FROM Produit;

Opérateur DISTINCT
• ex. Nombre total de commandes
SELECT COUNT(*) FROM Commande;
SELECT COUNT(NumCli) FROM Commande;
• ex. Nombre de clients ayant passé commande
SELECT COUNT( DISTINCT NumCli)
FROM Commande;

Exemple
• Table COMMANDE (simplifiée)
NumCli Date Quantite
1 22/09/99 1
3 22/09/99 5
3 22/09/99 2
 COUNT(NumCli) Résultat = 3
 COUNT(DISTINCT NumCli)  Résultat = 2

Jointure
• Consiste en un produit cartésien ou certaines lignes seulement
sont sélectionnées via la clause WHERE
• ex. Liste des commandes avec le nom des clients
SELECT Nom, Date, Quantite FROM Client, Commande
WHERE Client.NumCli = Commande.NumCli;
• ex. Idem avec le numéro de client en plus
SELECT C1.NumCli, Nom, Date, Quantite
FROM Client C1, Commande C2 WHERE C1.NumCli =
C2.NumCli ORDER BY Nom;
• NB : Utilisation d’alias (C1 et C2) pour alléger
l’écriture + tri par nom.

Jointure exprimée avec le
prédicat IN
• ex. Nom des clients qui ont commandé le 23/09
SELECT Nom FROM Client WHERE NumCli
IN (SELECT NumCli FROM Commande
WHERE Date = „23-09-2000‟ );
NB : Il est possible d‟imbriquer des requêtes.

Prédicats EXISTS / NOT
EXISTS
• ex. Clients qui ont passé au moins une
commande [n ’ont passé aucune
commande]
SELECT * FROM Client C1
WHERE [NOT] EXISTS ( SELECT * FROM
Commande C2 WHERE C1.NumCli =
C2.NumCli );

Prédicats ALL / ANY
• ex. Numéros des clients qui ont commandé
au moins un produit en quantité supérieure à
chacune [à au moins une] des quantités
commandées par le client n° 1.
SELECT DISTINCT NumCli FROM Commande
WHERE Quantite > ALL [ANY] (
SELECT Quantite FROM Commande
WHERE NumCli = 1 );

Groupement
• permet de créer des groupes de lignes pour appliquer
des fonctions d‟agrégat sur les groupes
– il est possible de créer des groupes sur plusieurs attributs
• ex. Quantité totale commandée par chaque
client
SELECT NumCli, SUM(Quantite) FROM Commande
GROUP BY NumCli;
• ex. Nombre de produits différents
commandés...
SELECT NumCli, COUNT(DISTINCT NumProd)
FROM Commande GROUP BY NumCli;

Groupement
• ex. Quantité moyenne commandée pour les
produits faisant l’objet de plus de 3
commandes
SELECT NumProd, AVG(Quantite)
FROM Commande GROUP BY NumProd
HAVING COUNT(*)>3;
Attention : La clause HAVING ne s’utilise
qu’avec
GROUP BY.

Opérations ensemblistes
• INTERSECT, MINUS, UNION
– les deux tableaux opérandesdoiventavoirunedescriptionidentique:
• nombre de colonnes
• domaines des valeurs de colonnes
– structuregénérale
• co-requête OPERATEUR co-requête
• ou chaque co-requête est une instruction SELECT
ex. Numéro des produits qui soit ont un prix inférieur à 100
DT, soit ont été commandés par le client n° 2
SELECT NumProd FROM Produit WHERE PrixUni<100
UNION SELECT NumProd FROM Commande WHERE
NumCLi=2;

• mécanisme très puissant mais d‟un emploi
subtil !
• = une requête SELECT insérée dans la
clause WHERE d‟une autre requête
SELECT
• bien sur, une sous-requête peut contenir une
sous-sous-requête !
Les sous-requêtes

• peuvent retourner
– une seule valeur
– une liste de valeurs
• une sous-requête constitue le second
membre d‟une comparaison dans la clause
WHERE
Les sous-requêtes

SELECT last_name, salary FROM s_emp
WHERE salary >= (SELECT AVG(salary) FROM
s_emp);
LAST_NAME SALARY
------------------------- ------------------
Velasquez 2500
Ngao 1450
Nagayama 1400
Quick-To-See 1450
...
sous-requête
Les sous-requêtes retournant
une valeur

SELECT last_name, salary FROM s_emp
WHERE salary >= ALL (SELECT salary FROM
s_emp WHERE dept_id = 10) ;
LAST_NAME SALARY
------------------------- -------------------
Velasquez 2500
Ngao 1450
Quick-To-See 1450
Ropeburn 1550
Giljum 1490
Les sous-requêtes retournant
une liste de valeurs

• clause ORDER BY y est interdite
• chaque sous-requête doit être entourée de
parenthèses
• clause SELECT d‟une sous-requête ne peut
contenir qu‟un seul attribut
• les attributs définis dans la requête principale
peuvent être utilises dans la sous-requête
• les attributs définis dans la sous-requête ne
peuvent pas être utilises dans la requête principale
Contraintes des sous-requêtes

• dans le cas de sous-requêtes retournant une seule
valeur, les opérateurs classiques (<, >, …) peuvent
être appliques
• dans le cas de sous-requêtes retournant une liste de
valeurs, il faut utiliser les quantificateurs
– ANY: l‟expression est vraie si une des valeurs de la
sous-requête vérifie la comparaison
– ALL: l‟expression est vraie si toutes les valeurs de la
sous-requête vérifient la comparaison
• Note: IN équivaut à = ANY
Opérateurs de comparaison et les
sous-requêtes

• la clause WHERE d‟une requête principale
peut contenir plusieurs sous-requêtes reliées
par les connecteurs AND et OR
Les sous-requêtes multiples

Mise à jour des données
• Ajout d’un tuple
INSERT INTO nom_table VALUES (val_att1,
val_att2, …);
ex. INSERT INTO Produit VALUES (400, ‘Nouveau
produit’, 78.90);
• Mise à jour d’un attribut
UPDATE nom_table SET attribut=valeur
[WHERE condition];
ex. UPDATE Client SET Nom=‘Dudule’ WHERE
NumCli = 3;

Mise à jour des données
• Suppression de tuples
DELETE FROM nom_table [WHERE condition];
ex. DELETE FROM Produit;
ex. DELETE FROM Client WHERE Ville =
‘Tunis’;

Les vues
• Vue : table virtuelle calculée à partir d‟autres
tables grâce à une requête
• Définition d’une vue
CREATE VIEW nom_vue AS requête;
ex. CREATE VIEW Noms AS SELECT Nom,
Prenom FROM Client;

Les vues
• Intérêt des vues
– Simplification de l’accès aux données en
masquant les opérations de jointure
ex. CREATE VIEW Prod_com AS SELECT
P.NumProd, Dési, PrixUni, Date, Quantite
FROM Produit P, Commande C WHERE
P.NumProd=C.NumProd;
SELECT NumProd, Dési FROM Prod_com
WHERE Quantite>10;

Les vues
– Sauvegarde indirecte de requêtes complexes
– Présentation de mêmes données sous différentes
formes adaptées aux différents usagers
particuliers
– Support de l’indépendance logique
ex. Si la table Produit est remaniée, la vue
Prod_com doit être refaite, mais les requêtes
qui
utilisent cette vue n’ont pas à être remaniées.

Les vues
– Renforcement de la sécurité des données
par masquage des lignes et des colonnes
sensibles aux usagers non habilités
• Problèmes de mise à jour,
restrictions
– La mise à jour de données via une vue
pose des problèmes et la plupart des
systèmes impose d’importantes
restrictions.

Les vues
• Problèmes de mise à jour,
restrictions
– Le mot clé DISTINCT doit être absent.
– La clause FROM doit faire référence à une
seule table.
– La clause SELECT doit faire référence
directement aux attributs de la table
concernée (pas d’attribut dérivé).
– Les clauses GROUP BY et HAVING sont
interdites.

IV.Le Langage PL/SQL
IV.1.Généralités
PL/SQL :
 Langage procédural
Extension de SQL
Déclaration de variables et de constantes
Définition de sous-programmes
Gestion des erreurs à l‟exécution (exceptions)
Manipulation de données avec SQL

STRUCTURE D‟UN PROGRAMME PL/SQL
Déclaration de variables, types, curseurs, exceptions,.. (Optionnel)
Corps du programme : Code SQL (Obligatoire)
Gestion des erreurs (Optionnel)
BLOC PL/SQL :
DECLARE (Déclaration de variables et curseurs)
…..
BEGIN
…..
….
EXCEPTION (Traitement des cas d‟erreur signalés par le SGBD)
…..
END ;
II – LE LANGAGE PL/SQL

PORTEE DES OBJETS
Un bloc qui déclare un objet peut y accéder ainsi que tous les sous blocs
(sous bloc : bloc imbriqué dans un autre).
Par contre tout objet déclaré dans un sous bloc n‟est pas accessible au
niveau du bloc supérieur.
UTILISATION EN CLIENT SERVEUR
Requêtes SQL exécutées séquentiellement :
Envoi d‟un message du client vers le serveur pour chaque
requête et retour du serveur vers le client
Bloc PL/SQL :
Envoi d‟un message pour tout le bloc et un seul retour vers le
client

IV.2 Bloc PL/SQL
DECLARE
--Déclaration constantes/variables
BEGIN
--Commandes/instructions
EXCEPTION
--Traitement des erreurs à
l’exécution.
END;

DECLARATION DES VARIABLES
Identificateur [CONSTANT] typededonnées [NOT NULL] [ :=| DEFAULT
expression] ;
Types de données :
Caractères (CHAR, VARCHAR, VARCHAR2, LONG, CLOB,..)
Numériques (NUMBER)
Date/heure (DATE, INTERVAL,….)
Données binaires (BLOB, RAW, …)
Adresse d‟enregistrements (ROWID)
Variable du type d‟une colonne (%TYPE)
Nom_variable Nom_table.Nom_colonne%TYPE
Variable du type enregistrement d‟un table (%ROWTYPE)
Nom_variable Nom_table %ROWTYPE
Variable de type RECORD :
TYPE Nom_variable IS RECORD (……..) ;

IV.3 Déclaration
• Partie déclarative d‟un bloc PL/SQL ou d‟un sous-
programme
• Types usuels : INTEGER, REAL, STRING, DATE,
BOOLEAN + types SQL
• Variables
– ex.
Date_naissance DATE;
compteur INTEGER:=0; -- Valeur par défaut
compteur INTEGER DEFAULT 0; -- idem
 id CHAR(5) NOT NULL:=„AP001‟;

IV.3. Déclarations
• Constantes
– ex. euro CONSTANT REAL:=6.55957;
• Type d’une autre variable
– ex. credit REAL;
– debit credit%TYPE;
• Type d’un tuple d’une table
– ex. un_client client%ROWTYPE;
• Tableaux : 1) Déclaration d‟un type tableau
2) Déclaration d‟une variable de ce type

IV.3. Déclarations
• Tableaux
– ex. TYPE Tab_entiers TABLE OF INTEGER
INDEX BY BINARY_INTEGER;
– TYPE Tab_cli TABLE OF client.nom%TYPE
INDEX BY BINARY_INTEGER;
• un_entier Tab_entiers;
• un_client Tab_cli;

IV.3. Déclarations
• Enregistrements personnalisés
1) Définition d’un type enregistrement
– ex. TYPE Enr_four IS RECORD (numero
fournisseur.numfour%TYPE, raison_sociale
CHAR(20));
2) Définition d’une variable de ce type
– ex. un_fournisseur Enr_four;

V.4. Instructions de base
• Affectation
– ex. numero:=0;
– numero:=numero+1;
– SELECT numcli INTO numero FROM client
WHERE numcli=numero+1;
• Utilisation des tableaux
– ex. i:=1;
– un_entier(i):=i*2;
– NB : i doit être de type BINARY_INTEGER.

V.4. Instructions de base
• Utilisation des enregistrements
personnalisés
– ex. un_fournisseur.numero:=4589;
– un_fournisseur.raison_sociale:=„COGIP‟;
– SELECT numfour, raisonsoc INTO
un_fournisseur FROM fournisseur WHERE
numfour=4589;

V.5. Structures de contrôle
• Instruction sélective
– IF-THEN, IF-THEN-ELSE ou IF-THEN-
ELSIF
IF condition1 THEN
-- Instructions
ELSEIF condition2 THEN
-- Instructions
ELSE
-- Instructions
END IF;

CASE variable
WHEN expr1 THEN instructions1;
WHEN expr2 THEN instructions2;
……
WHEN exprn THEN instructionsn;
[ELSE instructionsm;]
END CASE;
CASE variable
WHEN condition1 THEN instructions1;
WHEN condition2 THEN instructions2;
……
WHEN condition_n THEN instructionsn;
[ELSE instructionsm;]
END CASE;
Test conditionnel

Test conditionnel
• CASE
– CASE sélecteur
WHEN expression1 THEN résultat1
WHEN expression2 THEN résultat2
ELSE résultat3
END;

Test conditionnel
Exemple :
val := CASE city
WHEN „TORONTO‟ THEN „RAPTORS‟
WHEN „LOS ANGELES‟ THEN „LAKERS‟
ELSE „NO TEAM‟
END;

• Instructions itératives
FOR compteur IN [REVERSE] min..max LOOP
-- Instructions
END LOOP;
WHILE condition LOOP
-- Instructions
END LOOP;
LOOP
-- Instructions
END LOOP;

• Branchements
-- Saut inconditionnel
GOTO étiquette;
-- Sortie de boucle
EXIT WHEN condition;
NB : À utiliser avec énormément de modération !

V.6. Curseurs
• Curseur : structure de données permettant
de stocker le résultat d‟une requêtes qui
retourne plusieurs tuples
• Déclaration : CURSOR nom_curs IS
requête;
– ex. CURSOR calcul IS SELECT numprod,
prixuni*1.206 prixttc FROM produit;
NB : Un tuple du curseur sera de type
calcul%ROWTYPE.

V.6. Curseurs
• Ouverture d’un curseur : OPEN
nom_curs;
• Gestion automatique d’un curseur
ex. FOR tuple IN calcul LOOP
var1:=tuple.numprod;
var2:=tuple.prixttc;
END LOOP;
• Gestion « manuelle »
ex.LOOP
FETCH calcul INTO tuple;
EXIT WHEN calcul%NOTFOUND;
…
END LOOP

V.6. Curseurs
• Attributs des curseurs
– "%NOTFOUND : FALSE si FETCH retourne un
résultat
– "%FOUND : opposé logique de %NOTFOUND
– "%ROWCOUNT : Nombre de lignes lues
– "%ISOPEN : TRUE si le curseur est ouvert
• Fermeture d’un curseur : CLOSE nom_curs;

Exemple

Ligne courante d’un curseur
• La ligne courante d‟un curseur est déplacée à
chaque appel de l‟instruction fetch
• On est parfois amené à modifier la ligne courante
pendant le parcours du curseur
• Pour cela on peut utiliser la clause « where current
of » pour désigner cette ligne courante dans un
ordre LMD (insert, update, delete)
• Il est nécessaire d‟avoir déclaré le curseur avec la
clause FOR UPDATE OF pour que le bloc
compile

Exemple
• DECLARE
CURSORc IS
select matr, nome, sal from emp
wheredept = 10
FOR UPDATE OF emp.sal;
………………………………………..
if salaireis not null then
total := total + salaire;
else -- on met 0 à la place de null pour le salaire
updateemp set sal = 0 where current of c;
• end if;

Select … for update
• Select classique : non verrouillé
• Problème avec les curseurs
• Solution : Select … for update
– Résultat : verrouiller toutes les lignes jusqu‟au
prochain commit

V.7. Exceptions
• À chaque erreur à l‟exécution, une
exception est levée. Ces exceptions sont
gérées par des routines séparées.
• Fonctions PL/SQL pour la gestion
d’erreurs
– "SQLCODE : Code de la dernière exception
levée
– "SQLERRM : Message d‟erreur associé

V.7. Exceptions
• Exceptions personnalisées
– Déclaration : nom_exc EXCEPTION;
– Lever l’exception : IF condition THEN RAISE
nom_exc; END IF;
• Traitement des exceptions
– WHEN nom_exc THEN -- Instruction
– ex. WHEN probleme THEN
RAISE_APPLICATION_ERROR(-20501,‟Erreur !‟);

Les exceptions et erreurs
• NO_DATA_FOUND
– Quand Select into ne retourne aucune ligne
• TOO_MANY_ROWS
– Quand Select into retourne plusieurs lignes
• OTHERS
– Toutes erreurs non interceptées
• RAISE_APPLICATION_ERROR
– Pour retourner une message d‟erreur
– Numéro d‟erreur entre -20000 et -20999
• LOGIN_DENIED Connexion incorrecte
• NOT_LOGGED_ON Pas de connexion
• ROWTYPE_MISMATCH Erreur de type
• STORAGE_ERROR Dépassement de capacité mémoire
• ZERO_DIVIDE Division par zéro

V.8. Exemple de programme
PL/SQL
-- Calcul du prix TTC des produits
-- et recopie dans la table PRODTTC
DECLARE
nbp NUMBER(3);
aucun_produit EXCEPTION;
CURSOR calcul IS SELECT numprod, prixuni*1.206
prixttc FROM produit;
tuple calcul%ROWTYPE;
BEGIN
-- Comptage des produits
SELECT COUNT(*) INTO nbp FROM produit;
-- Test « il existe des produits » ou pas ?
IF nbp = 0 THEN RAISE aucun_produit;
END IF;

V.8. Exemple de programme
PL/SQL
-- Recopie des valeurs dans la table prodttc
FOR tuple IN calcul LOOP
INSERT INTO prodttc VALUES (tuple.numprod, tuple.prixttc);
END LOOP;
-- Validation de la transaction
COMMIT;
EXCEPTION
WHEN aucun_produit THEN
RAISE_APPLICATION_ERROR(-20501, „Erreur : table client
vide‟);
END;

Affichage
• Activer le retour écran
– set serveroutput on size 10000
• Affichage
– dbms_output.put_line(chaîne);
– Utilise || pour faire une concaténation

Exemple n°1
DECLARE
i number(2);
BEGIN
FOR i IN 1..5 LOOP
dbms_output.put_line(„Nombre : ‟ || i );
END LOOP;
END;

Exemple n°2
DECLARE
compteur number(3);
i number(3);
BEGIN
select count(*) into compteur from clients;
FOR i IN 1..compteur LOOP
dbms_output.put_line('Nombre : ' || i );
END LOOP;
END;

PL/SQL
Procédures et fonctions

FONCTIONSETPROCEDURESSTOCKEES(CATALOGUEES)
Programmes PL/SQL compilés et stockés dans le dictionnaire de données
Les procédures stockées peuvent être appelées dans :
Un bloc PL/SQL
Une fonction ou une procédure
Dans un programme en langage évolué (C, Fortran, ..)
Sécurité : droit d’accès sur les procédures
GRANT EXECUTE ON Nom_procédure TO Nom_utilisateur ;
Intégrité : Utilisation de COMMIT-ROLLBACK lors de
traitements dépendants exécutés dans le même bloc ;
Performance : réduction du nombre d’appels à la base
Productivité : simplicité de maintenance

CREATION DE PROCEDURES OU FONCTIONS :
CREATE [OR REPLACE] PROCEDURE Nom_procédure
[(paramètre1 IN | OUT | IN OUT type
[,paramètre2 IN | OUT | IN OUT type]
…..
[,paramètren IN | OUT | IN OUT type])]
IS
Déclaration de variables locales ;
BEGIN
Corps_de_la_procédure
END;
CREATE [OR REPLACE] FUNCTION Nom_fonction
[(paramètre1 IN | OUT | IN OUT type
[,paramètre2 IN | OUT | IN OUT type]
…..
[,paramètren IN | OUT | IN OUT type])]
RETURN typeSQL
IS
Déclaration de variables locales ;
BEGIN
Corps_de_la_procédure
END;

APPELD’UNE PROCEDURE OU D’UNE FONCTION :
EXECUTE Nom_Procédure(……) ;
EXECUTE Nom_Fonction(……) ;
SELECT …., Nom_Fonction(….),…..
Variable := Nom_Fonction(…….) ;

Les procédures
create or replace procedure list_nom_clients
IS
BEGIN
DECLARE
nom varchar2(30);
CURSOR get_nom_clients IS
select nom,adresse from clients;
BEGIN
FOR toto IN get_nom_clients LOOP
dbms_output.put_line('Employé : ' ||
UPPER(toto.nom) ||' Ville : '|| toto.adresse);
END LOOP;
END;

Les procédures
create or replace procedure list_nom_clients
(ville IN varchar2,
result OUT number)
IS
BEGIN
DECLARE
CURSOR get_nb_clients IS
select count(*) from clients where adresse=ville;
BEGIN
open get_nb_clients;
fetch get_nb_clients INTO result;
end;
end;

Récupération des résultats
• Déclarer une variable
SQL> variable nb number;
• Exécuter la fonction
SQL> execute list_nom_clients('paris',:nb)
• Visualisation du résultat
SQL> print
• Description des paramètres
SQL> desc nom_procedure

Les fonctions
createor replace function nombre_clients
return number
IS
BEGIN
DECLARE
i number;
CURSORget_nb_clients IS
select count(*)from clients;
BEGIN
open get_nb_clients;
fetch get_nb_clientsINTO i;
return i;
end;
end;
• Exécution:select nombre_clients()fromdual

Procédures et fonctions
• Suppression de procédures ou fonctions
– DROP PROCEDURE nom_procedure
– DROP FUNCTION nom_fonction
• Table système contenant les procédures et
fonctions : user_source

Exercices
• Réalisez une procédure list_tables qui
donne le nom de toutes vos tables
• Réalisez une procédure UPDATENOM qui
remplit correctement la colonne
NOM_PIECE de clients par rapport à la
table fournisseurs
• Réalisez une procédure UPDATEPRIX qui
met à jour tous les prix de la table clients

Procédure LIST_TABLES
create or replace procedure list_tables
IS
BEGIN
DECLARE
CURSOR get_nom IS
select table_name from user_tables;
BEGIN
FOR nom IN get_nom
LOOP
dbms_output.put_line('Nom de la table : ' ||
toto.table_name);
END LOOP;
END;

Procédure UPDATENOM
CREATE OR REPLACE PROCEDURE updatenom
IS
BEGIN
DECLARE
nompiece varchar2(30);
cursor toto IS
SELECT distinct fournisseurs.reference, fournisseurs.nom_piece
FROM fournisseurs;
BEGIN
FOR nompiece IN toto LOOP
UPDATE clients
SET clients.nom_piece=nompiece.nom_piece
WHERE clients.reference=nompiece.reference;
END LOOP;
END;
END;

Procédure UPDATEPRIX
CREATE OR REPLACE PROCEDURE updateprix
IS
BEGIN
DECLARE
prixunit number(5);
CURSOR toto IS
SELECT clients.nom, clients.adresse, fournisseurs.prix_piece_unite
FROM fournisseurs,clients
WHERE fournisseurs.reference=clients.reference;
BEGIN
FOR prixunit IN toto LOOP
UPDATE clients
SET clients.prix=clients.quantite*prixunit.prix_piece_unite
WHERE prixunit.nom=clients.nom and prixunit.adresse=clients.adresse;
END LOOP;
END;
END;

V.9. Triggers
• Trigger (déclencheur) : routine déclenchée
automatiquement par des événements liés à des
actions sur la base
• Les triggers complètent les contraintes d‟intégrité
en permettant des contrôles et des traitements plus
complexes.

V.9.Triggers
Types de
triggers
Insertion Suppression Mise à jour
Avant 1 2 3
Après 4 5 6
D‟une table de la base

V.9.Triggers
• Création en SQL*Plus :
– CREATE [OR REPLACE] TRIGGER nom_trig
BEFORE|AFTER INSERT|DELETE|UPDATE ON
nom_table FOR EACH ROW
-- Bloc PL/SQL contenant le
-- traitement à effectuer
• Variables spécifiques
– :OLD.nom_attribut : valeur de l‟attribut avant mise à
jour
– :NEW.nom_attribut : valeur de l‟attribut après mise à
jour

Accès aux valeurs modifiées
• Utilisation de new et old
• Si nous ajoutons un client dont le nom est
toto, alors nous récupérons ce nom grâce à
la variable :new.nom
• Dans le cas de suppression ou modification,
les anciennes valeurs sont dans la variable
:old.nom

V.9. Triggers
-- Exemple : test de clé primaire sur la table client
CREATE ORREPLACE TRIGGER trig_clep BEFORE INSERT ON
client FOREACH ROW
DECLARE
n INTEGER;
cle_existeEXCEPTION;
cle_nulleEXCEPTION;
BEGIN
-- Existence de la clé primaire
SELECT COUNT(numcli)INTO n FROM client WHERE
numcli=:NEW.numcli;
IF n>0 THEN
RAISE cle_existe;
END IF

V.9. Triggers
-- Valeurnulle
IF :NEW.numcli IS NULL THEN
RAISE cle_nulle;
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,‘La clé primaire doit avoir une valeur!’);
END;

Les Packages?
• Regroupement des types, éléments et sous
programmes PL/SQL logiquement liés.
• Se composent de deux parties
– Une spécification
– Un corps
• Permettent à Oracle de lire immédiatement
plusieurs objets en mémoire

Package
Déclarationde la procédureA
Définition de la procédureA
Variable locale
Spécification
Corps de package

• Spécification :
• CREATE [OR REPLACE] PACKAGENom_programmeAS
Variables;
PROCEDURE ….;
FUNCTION ….RETURN …;
…..
Exceptions;
END [Nom_programme] ;
• Implémentation :
• CREATE [OR REPLACE] PACKAGEBODY Nom_programme
» AS
PROCEDURE….
BEGIN
…..
END;
FUNCTION….RETURN …;
BEGIN
….
END ;
• END [Nom_programme] ;

Exemple
• CREATEPACKAGEbankAS
PROCEDURE transac;
PROCEDURE detourne(valueNUMBER);
• END bank;
• CREATEPACKAGEBODY bankAS
--commentaires
PROCEDUREtransacIS
BEGIN
...
END transac;
-- commentaires
PROCEDUREdetourne(valueNUMBER)IS
BEGIN
...
END detourne;
END bank;
EXECUTE bank.detourne(1 000 000 000$);

support_cours.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à support_cours.pdf

Similaire à support_cours.pdf (20)

Plus de MbarkiIsraa

Plus de MbarkiIsraa (19)

Dernier

Dernier (20)

support_cours.pdf