Collège de Rosemont Techniques de l'informatique

COURS 4. LANGAGE SQL. PARTIE LMD.

1. Introduction.

Le langage de manipulation de données ou LMD est un sous-ensemble SQL avec les instructions de
mise à jour des données (d'ajout, de modification, de suppressions des lignes) et d'extraction (de
consultation) des données dans les tables existantes.
Il est possible de contrôler la mise à jour de données dans des tables avec les commandes
COMMIT et ROLLBACK qui permettent respectivement d'enregistrer en permanence les
données modifiées ou de revenir en arrière et annuler les modifications effectuées.
Il est possible de formater l'information extraite des tables des BDs en utilisant les commandes
de formatage de SQL*PLUS.
Remarque : Généralement, les opérations de mise à jour de données dans des tables existantes sont
effectuées par les utilisateurs via des applications (formulaires) avec les interfaces graphiques.
Cependant, parfois les administrateurs peuvent utiliser les instructions du LMD avec l'outil
SQL*Plus pour préparer des données de tests des applications ou des performances du système.

Les commandes de base du LMD sont les suivantes :

1. INSERT - pour l'insertion (l'ajout) des lignes (rangées) dans une table existante;
2. UPDATE - pour la modification des lignes (rangées) dans une table existante;
3. DELETE - pour la suppression des lignes (rangées) dans une table existante;
4. SELECT - pour l'extraction lignes (rangées) d'une table existante;

INSERT
COMMIT
Mise à jour
UPDATE
de données
ROLLBACK
DELETE

Extraction Commandes
SELECT de formatage
de données
de SQL*Plus

Les commandes de base du LMD manipulent des expressions. Ces expressions font référence à
des noms d'objets de la base, à des contraintes, comportent des appels à des fonctions
standardisées et composent ses éléments avec des opérateurs.
Des expressions logiques (conditions) permettent également de définir la portée des expressions.

2. Insertion des lignes dans une table existante.

La première opération de mise à jour que l'on effectue sur une table créée vide est l'ajout des
données (insertion de lignes ou de rangées) dans cette table à l'aide de la commande INSERT.
Pour pouvoir insérer des lignes dans une table, il faut soit être propriétaire de cet objet, soit avoir le
privilège INSERT sur cette table. Le privilège INSERT ANY TABLE permet d'insérer des lignes
dans n'importe quelle table appartenant à n'importe quel utilisateur.

2.1. Insertion dans une table des lignes une à une avec des valeurs données.
La commande INSERT INTO VALUES permet d'insérer une seule rangée (ligne) à la fois.
Il y a deux manières d’insérer les données dans une rangée d'une table:

Bases de données. 1 Elena Smagina

Collège de Rosemont Techniques de l'informatique

• Insérer toute une rangée (valeurs pour la totalité des colonnes – insertion complète);
• Insérer des valeurs seulement pour certaines colonnes spécifiées, laissant les autres colonnes
d'une rangée indéterminées (NULL) (insertion partielle).

La syntaxe de la commande INSERT INTO VALUES est la suivante :

INSERT INTO nom_table [(nom_colonne1, nom_colonne2,…]
VALUES (expression1, expression2,…) ;

Remarque : À partir de la version 7, Oracle applique automatiquement toutes les contraintes

d'intégrité définies lors de la création des tables, il est donc impossible de les violer avec les valeurs
dans la commande INSERT.

Lors de l'insertion complète lorsqu'il n'y a pas de colonnes spécifiées, une valeur est requise pour
chacune des colonnes. Les valeurs doivent être saisies dans le même ordre que celui utilisé lors de
la définition des colonnes dans la commande CREATE TABLE.

Les valeurs spécifiées dans la commande INSERT doivent être du même format que les types des
colonnes :
• Une valeur/expression de type caractère doit être mise entre apostrophes. Les apostrophes à
l'intérieur d'une chaîne de caractères doivent être doublées.
• Une valeur/expression de type numérique est exprimée en notation standard (le point délimite
les décimales, le signe – indique les valeurs négatives). Toutefois, il n'y aura pas d'erreur si la
valeur numérique est mise entre apostrophes.
• Une valeur/expression de type date doit être mise entre apostrophes et spécifiée selon le
format par défaut du système (par exemple, pour une version Oracle en anglais, le format
américain de la date est : JJ-MON-AA et la valeur de la date doit être comme suit : '27-DEC-02'
– on utilise les 3 premières lettres du nom du mois en anglais). Par contre, il est possible de
changer le format de saisie à l'aide de la fonction scalaire de conversion TO_DATE dans la
commande INSERT ou en changeant le format de la date par défaut dans une session avec la
commande : ALTER SESSION SET NLS_DATE_FORMAT = 'DD/MM/YYYY';
• La valeur nulle sera saisie comme NULL ou ‘’ (deux apostrophes) (s’il y a une valeur par
défaut, elle n’apparaîtra pas, car le NULL a été inséré explicitement).

Il est important de respecter toutes les contraintes lors de l’insertion, au risque de se voir
refuser la transaction.

Lors de l'insertion partielle lorsque les noms de colonnes sont spécifiés, il doit y avoir autant de
valeurs qu'il y a de colonnes et elles doivent être saisies dans le même ordre en respectant les types
de données de colonnes. Les colonnes non spécifiées se verront attribuer les valeurs NULL.

Pour afficher le contenu d’une table, on utilise la commande suivante :

SELECT * FROM nom_table ;

Remarque : On peut spécifier le format d'affichage en utilisant des commandes de SQL*Plus :

COLUMN nom_colonne FORMAT type_format où type_format peut être A suivi du nombre
de caractères pour le type caractères ou 9 suivi du nombre de chiffres avec le point qui sépare
décimaux pour le type numérique.

Exemples :
• INSERT INTO S VALUES ('S1', 'Smith' , '20', 'London'); - insertion complète d'une ligne dans
la table S
Bases de données. 2 Elena Smagina
Collège de Rosemont Techniques de l'informatique

• INSERT INTO S(SName, S#) VALUES ('Jones' , 'S2'); - insertion partielle d'une ligne dans la
table S
COLUMN SNAME FORMAT A10
COLUMN STATUS FORMAT 99
COLUMN CITY FORMAT A10 – formatage de l'affichage (commandes SQL*Plus
ne se termine pas par ;)
SELECT * FROM S; - affichage du contenu de la table S

• INSERT INTO S VALUES ('S3', 'Smith' , '', ''); - accepte

• INSERT INTO S VALUES ('S4', '' , '', ''); - n'accepte pas à cause de contrainte NOT NULL sur la
colonne SNAME
• INSERT INTO S VALUES ('S2', 'Blake' , '', ''); - n'accepte pas à cause de contrainte UNIQUE de
la clé primaire S#
• ALTER TABLE S ADD(UserCreS VARCHAR2(16), DateCreS DATE); - modification de la
structure de la table S avec l'ajout de 2 colonnes Utilisateur-créateur d'une ligne de fournisseurs
supplémentaire et la date de création de ce fournisseur (pour les analyses et statistiques).
INSERT INTO S(SName, S#, Status, UserCreS, DateCreS) VALUES ('Adams' , 'S4', 10*3,
'Créateur : '||USER, SYSDATE); - insertion d'une ligne dans la table S modifiée.
INSERT INTO S(SName, S#, DateCreS) VALUES (INITCAP('dupont pierre') , 'S6',
SYSDATE-10); - insertion d'une ligne dans la table S modifiée

2.2. Insertion dans une table de plusieurs lignes provenant d'une autre table.
Il est possible d'insérer dans une table des lignes provenant d'une autre table en utilisant la
commande INSERT INTO SELECT basée sur une requête.

La syntaxe de commande INSERT INTO SELECT est la suivante :

INSERT INTO nom_table(nom_colonne1, nom_colonne2, ...)
SELECT expression_requête

La partie SELECT expression_requête qui sera étudiée plus tard peut contenir n'importe quelle
clause de SELECT, sauf la clause ORDER BY qui impliquerait un classement des lignes contraire
à l'esprit du relationnel.

Remarque : il faut que l'information sélectionnée par SELECT corresponde au nombre de

colonnes à remplir et à leur type et leur taille.

Exemple : Création d'une table Fournisseurs qui ne contiendra que les numéros, les noms et les
villes de fournisseurs et remplissage de cette table à partir de la table S.
CREATE TABLE Fournisseurs (
NumFournisseur VARCHAR2(5) PRIMARY KEY,
NomFournisseur VARCHAR2(20) NOT NULL,
VilleFournisseur VARCHAR2(20)
); - création de nouvelle table vide Fournisseurs

INSERT INTO Fournisseurs(NumFournisseur, NomFournisseur, VilleFournisseur)

SELECT S#, SName, City from S; - insertion de plusieurs lignes dans la table créée
Fournisseurs à partir de la table existante S
SELECT * FROM Fournisseurs; - affichage du contenu de la table créée et remplie Fournisseurs

2.3. Exercice.
Soit la base de données SPJ (FournisseursPiecesProjets) créée précédemment.

Bases de données. 3 Elena Smagina

Collège de Rosemont Techniques de l'informatique

Travail à faire :
1. Créer le script de remplissage de la base de données SPJ créée InsertSPJ.sql.

Solution (script InsertSPJ.sql) :

REM Nom du fichier : InsertSPJ.SQL
REM Auteur : Elena Smagina
REM Date de création: 16/01/2003
REM Fonction : Remplir la BD SPJ avec 4 tables : S, P, J et SPJ

PROMPT Effacement des contenus de tables S, P, J et SPJ de la BD SPJ

DELETE FROM SPJ;
DELETE FROM S;
DELETE FROM P;
DELETE FROM J;

PROMPT Remplissage de la BD SPJ

PROMPT Remplissage de la table S

INSERT INTO S VALUES ('S1', 'Smith' , 20, 'London');
INSERT INTO S VALUES ('S2', 'Jones' , 10, 'Paris');
INSERT INTO S VALUES ('S3', 'Blake' , 30, 'Paris');
INSERT INTO S VALUES ('S4', 'Clark' , 20, 'London');
INSERT INTO S VALUES ('S5', 'Adams' , 10, 'Athens');

PAUSE Affichage du contenu de la table S remplie. Appuyez sur Enter pour continuer;
SELECT * FROM S;
PAUSE Appuyez sur Enter pour continuer;

PROMPT Remplissage de la table P

INSERT INTO P VALUES ('P1', 'Nut' , 'Red', 12.0, 'London');
INSERT INTO P VALUES ('P2', 'Bolt' , 'Green', 17.0, 'Paris');
INSERT INTO P VALUES ('P3', 'Screw' , 'Blue', 17.0, 'Rome');
INSERT INTO P VALUES ('P4', 'Screw' , 'Red', 14.0, 'London');
INSERT INTO P VALUES ('P5', 'Cam' , 'Blue', 12.0, 'Paris');
INSERT INTO P VALUES ('P6', 'Cog' , 'Red', 19.0, 'London');

PAUSE Affichage du contenu de la table P remplie. Appuyez sur Enter pour continuer;
COLUMN P# FORMAT A5
COLUMN PName FORMAT A10
COLUMN Color FORMAT A10
COLUMN Weight FORMAT 999.9
COLUMN City FORMAT A10
SELECT * FROM P;
PAUSE Appuyez sur Enter pour continuer;

PROMPT Remplissage de la table J

INSERT INTO J VALUES ('J1', 'Sorter' , 'Paris');
INSERT INTO J VALUES ('J2', 'Display' , 'Rome');
INSERT INTO J VALUES ('J3', 'OCR' , 'Athens');
INSERT INTO J VALUES ('J4', 'Console' , 'Athens');
INSERT INTO J VALUES ('J5', 'RAID' , 'London');
INSERT INTO J VALUES ('J6', 'EDS' , 'Oslo');
INSERT INTO J VALUES ('J7', 'Tape' , 'London');

PAUSE Affichage du contenu de la table J remplie. Appuyez sur Enter pour continuer;
SELECT * FROM J;
PAUSE Appuyez sur Enter pour continuer;

PROMPT Remplissage de la table SPJ

INSERT INTO SPJ VALUES ('S1', 'P1' , 'J1', 200);
INSERT INTO SPJ VALUES ('S1', 'P1' , 'J4', 700);

Bases de données. 4 Elena Smagina

Collège de Rosemont Techniques de l'informatique
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J1', 400);
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J2', 200);
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J3', 200);
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J4', 500);
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J5', 600);
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J6', 400);
INSERT INTO SPJ VALUES ('S2', 'P3' , 'J7', 800);
INSERT INTO SPJ VALUES ('S2', 'P5' , 'J2', 100);
INSERT INTO SPJ VALUES ('S3', 'P3' , 'J1', 200);
INSERT INTO SPJ VALUES ('S3', 'P4' , 'J2', 500);
INSERT INTO SPJ VALUES ('S4', 'P6' , 'J3', 300);
INSERT INTO SPJ VALUES ('S4', 'P6' , 'J7', 300);
INSERT INTO SPJ VALUES ('S5', 'P2' , 'J2', 200);
INSERT INTO SPJ VALUES ('S5', 'P2' , 'J4', 100);
INSERT INTO SPJ VALUES ('S5', 'P5' , 'J5', 500);
INSERT INTO SPJ VALUES ('S5', 'P5' , 'J7', 100);
INSERT INTO SPJ VALUES ('S5', 'P6' , 'J2', 200);
INSERT INTO SPJ VALUES ('S5', 'P1' , 'J4', 100);
INSERT INTO SPJ VALUES ('S5', 'P3' , 'J4', 200);
INSERT INTO SPJ VALUES ('S5', 'P4' , 'J4', 800);
INSERT INTO SPJ VALUES ('S5', 'P5' , 'J4', 400);
INSERT INTO SPJ VALUES ('S5', 'P6' , 'J4', 500);

PAUSE Affichage du contenu de la table SPJ remplie. Appuyez sur Enter pour continuer;
SELECT * FROM SPJ;
PAUSE Appuyez sur Enter pour terminer;
commit;

2.4. Génération automatique d'un numéro.

L'objet SEQUENCE d'une BD Oracle permet de générer des numéros uniques. La création d'un
objet SEQUENCE met à disposition de l'utilisateur un générateur de nombres.

La séquence est généralement utilisée pour insérer automatiquement des valeurs numériques
uniques dans les colonnes des tables, plus particulièrement dans les colonnes de la clé primaire.

Quand la valeur de la clé primaire est numérique et non significative, il est préférable de laisser le
système gérer ce numéro par l'intermédiaire d'une séquence.

Chaque valeur séquence s'exprime au maximum sur 28 chiffres significatifs.

La commande pour créer une séquence est CREATE SEQUENCE.

La syntaxe simplifiée de la commande CREATE SEQUENCE :

CREATE SEQUENCE nom_sequence [INCREMENT BY pas] [START WITH valeur_départ]
[MAXVALUE valeur_max] [MINVALUE valeur_min] [CYCLE ];
[ORDER] [CACHE nombre]
où les options sont :

INCREMENT BY pas : permet de spécifier l'intervalle pas entre les numéros générés (pas est un
entier, qui peut être positif ou négatif, par défaut, il est 1);

START WITH valeur_départ : permet d'initialiser le premier numéro de la séquence (par défaut,
si la séquence est ascendante (pas est positive), valeur_départ est la valeur minimale de la
séquence; si la séquence est descendante (pas est négative), valeur_départ est la valeur maximale
de la séquence);

Bases de données. 5 Elena Smagina

Collège de Rosemont Techniques de l'informatique

MAXVALUE valeur_max : permet de spécifier la valeur maximale dans la séquence (par défaut,
1027 pour la séquence ascendante et 1 pour la séquence descendante);

MINVALUE valeur_min : permet de spécifier la valeur minimale dans la séquence (par défaut,
1027 pour la séquence descendante et 1 pour la séquence ascendante);

CYCLE : permet de spécifier que la séquence continue des numéros à partir de la valeur minimale
lorsqu'elle atteint la valeur maximale pour la séquence ascendante ou à partir de la valeur maximale
lorsqu'elle atteint la valeur minimale pour la séquence descendante (par défaut, la séquence arrêtera
de générer des numéros lorsqu'elle aura atteint son maximum ou minimum pour les séquences
ascendantes et descendantes respectivement).

ORDER : garantit un ordre d'affectation des nombres dans l'ordre des demandes. Cette option ne
présente d'intérêt que dans le cas de l'utilisation de l'option PARALLEL OPTION en mode
PARALLEL au niveau de l'instance Oracle (par défaut noorder).

CACHE nombre : force l'anticipation de la génération des valeurs suivantes de la séquence en

mémoire (tampon ou cache) et a pour effet d'améliorer le temps de réponse d'une séquence (par
défaut, nombre = 20).
Les options montrées ne sont pas obligatoires.

Une fois créée, la séquence peut être utilisée dans l’insertion (INSERT), modification (UPDATE) et
consultation (SELECT) des données dans une table. Le type de données des colonnes dans
lesquelles on insert le numéro de séquence doit être numérique (nombre entier).

On accède à la séquence par l'intermédiaire des pseudo-colonnes dans les instructions de

manipulation de données :
Nom_séquence.NEXTVAL : augmente la valeur au numéro suivant de la séquence et retourne
cette valeur de la séquence. Cette pseudo-colonne doit être la première référencée après la
création de la séquence ou une ouverture de session.
Nom_séquence.CURRVAL : donne la valeur courante de la séquence. Cette pseudo-colonne
n'est pas valorisée par la création de la séquence ni lors de l'ouverture d'une nouvelle session.

Remarques:
1. Pour réinitialiser une séquence, il faut la supprimer, puis la recréer.
2. Pour modifier les paramètres d’une séquence, il faut utiliser la commande ALTER
SEQUENCE en spécifiant les nouvelles valeurs de paramètres.
3. Pour supprimer une séquence, il faut utiliser la commande DROP SEQUENCE nom_séquence;
4. Lorsqu'un enregistrement est supprimé d'une table, le numéro correspondant n'est pas récupéré
dans la séquence. De plus, lorsqu'il y a une tentative de violation d'une contrainte d'intégrité lors
de l'insertion d'une rangée, le numéro de séquence est également perdu.
5. L'initialisation de la première valeur dans une séquence par la valeur précisée dans START
WITH est effectuée par la référence de la pseudo-colonne NEXTVAL. Chaque fois que la
pseudo-colonne NEXTVAL est référencée, la valeur dans la pseudo-colonne CURRVAL
change.
6. Si la même séquence est référencée à partir de plusieurs sessions, la valeur de la pseudo-colonne
CURRVAL dans une session n'est pas modifiée tant que l'utilisateur correspondant ne référence
pas la pseudo-colonne NEXTVAL; et ce, même si d'autres utilisateurs référencent NEXTVAL
de la même séquence dans leurs sessions.

Bases de données. 6 Elena Smagina

Collège de Rosemont Techniques de l'informatique

Pour afficher une séquence, on utilise la commande :

SELECT * FROM USER_SEQUENCES ;

Exemple :
CREATE SEQUENCE seq_client INCREMENT BY 1
START WITH 10
MAXVALUE 9999; - création d'une séquence seq_client

SELECT SEQUENCE_NAME, MIN_VALUE, MAX_VALUE, INCREMENT_BY,

CACHE_SIZE FROM USER_SEQUENCES ;

CREATE SEQUENCE seq_exemple START WITH 4 INCREMENT BY -1 MAXVALUE 4

MINVALUE 0 CYCLE ORDER CACHE 2;

COLUMN SEQUENCE_NAME FORMAT A15

SELECT * FROM USER_SEQUENCES ;

SELECT seq_client.NEXTVAL, seq_exemple.NEXTVAL FROM DUAL; - l'affichage de valeurs

suivantes dans des séquences créées
SELECT seq_client.CURRVAL, seq_exemple.CURRVAL FROM DUAL; - l'affichage de valeurs
courantes suivantes dans des séquences créées
INSERT INTO Client VALUES (seq_client.NEXTVAL, ‘Dupond’, 35); - insertion d'une valeur
de séquence dans une ligne d'une table
INSERT INTO Ventes VALUES (seq_client.CURRVAL, ………….);- insertion d'une valeur de
séquence une ligne d'une table.

3. Modifications des lignes dans une table existante.

La modification des données enregistrées dans des tables se fait à l'aide de la commande UPDATE.
Cette commande peut effectuer des modifications sur une seule table à la fois. Les modifications
peuvent s'appliquer pour une ligne (rangée) ou pour l'ensemble de lignes (rangées) d'une table qui
satisfont la condition spécifiée.

Remarque : on va voir plus loin l'expression des conditions complexes.

La syntaxe de la commande UPDATE est la suivante :

UPDATE nom_table SET nom_colonne1=nouvelle_valeur1, nom_colonne2=nouvelle_valeur2,
… , nom_colonneN=nouvelle_valeurN [WHERE condition];

Les noms de colonnes (nom_colonne1, nom_colonne2,…) doivent correspondre aux noms de

colonnes de la table spécifiée (nom_table) et les formats de nouvelles valeurs (nouvelle_valeur1,
nouvelle_valeur2, …) doivent respecter les mêmes règles que pour l'instruction INSERT (ne pas
violer les contraintes d'intégrité définies pour la table).
Les nouvelles valeurs peuvent être des expressions.
La clause WHERE condition est optionnelle. Si elle n'est pas spécifiée, les modifications se
porteront sur toutes les lignes de la table. Dans le cas contraire, seules les lignes pour lesquelles la
condition spécifiée dans la clause WHERE est vérifiée seront modifiées. Condition peut être
exprimée comme une requête (la commande SELECT).

Il est donc impossible de modifier la valeur d'une clé primaire si elle est référencée par une valeur
d'une clé étrangère ou de mettre à NULL le contenu d'une colonne NOT NULL.
Bases de données. 7 Elena Smagina
Collège de Rosemont Techniques de l'informatique

De plus, si la modification s'applique sur une clé étrangère, la nouvelle valeur doit correspondre à
une des valeurs de la clé primaire de la table parente correspondante.

Exemples :
1. SELECT * FROM P;
2. UPDATE P SET Color = 'White' WHERE PName = 'Screw'; - modification de couleurs de
toutes les pièces nommées Screw en blanc (White) – 2 lignes modifiées;
3. UPDATE P SET Weight = Weight*2; - double le poids de toutes les pièces de la table P;
4. UPDATE P SET City = 'London' WHERE P# = 'P2'; - modification de la ville de stockage de la
pièce P2 (une ligne seulement – P# est la clé primaire).
5. UPDATE P SET City = 'London', Color = 'White', Weight = 20 WHERE PName = 'Screw'; -
modification de valeurs de plusieurs colonnes dans plusieurs lignes de la table P (2 lignes
modifiées);
6. SELECT * FROM P; - pour voir toutes les modifications.

4. Suppression des lignes dans une table existante.

La suppression de données consiste à éliminer les lignes complètes dans une table à l'aide de la
commande DELETE.
Pour éliminer juste une ou plusieurs colonnes d'une ou plusieurs lignes, il faut modifier les valeurs
de ces colonnes en les mettant à NULL avec la commande UPDATE.
La commande DELETE peut effectuer des modifications sur une seule table à la fois. Les
suppressions peuvent s'appliquer pour une ligne (rangée) ou pour l'ensemble de lignes (rangées)
d'une table qui satisfont la condition spécifiée.

La syntaxe de la commande DELETE est la suivante :

DELETE [FROM] nom_table [WHERE condition];

Il sera impossible de supprimer une rangée dont la valeur de la clé primaire correspond à la valeur
d'une clé étrangère qui y réfère si la clause DELETE CASCADE n'était pas précisée dans
REFERENCES. Par contre, si cette clause a été précisée, l'ensemble de lignes de la table
référençante avec la même valeur sera également détruit avec la suppression d'une ligne de la table
référencée.

Exemples :
1. DELETE FROM S WHERE SNAME ='SMITH'; - tentative de violation de contrainte
d'intégrité référentielle;
2. ALTER TABLE SPJ DROP CONSTRAINT SPJ_FK_S; - suppression de la contrainte
d'intégrité référentielle sur S#;
ALTER TABLE SPJ ADD CONSTRAINT SPJ_FK_S FOREIGN KEY (S#) REFERENCES
S(S#) ON DELETE CASCADE; - l'ajout de la nouvelle contrainte d'intégrité référentielle
modifiée sur S#;
SELECT * FROM SPJ; - affichage du contenu de SPJ avant la suppression dans S
DELETE FROM S WHERE SNAME ='SMITH'; - suppression d'une ligne dans S (fournisseur
S1 est supprimé)
SELECT * FRON SPJ; - affichage du contenu de SPJ avant la suppression dans S (2 lignes avec
le fournisseur S1 sont supprimées en même temps que la suppression de S1 dans S).
3. CREATE TABLE SPJ1 ( S# , P# , J#, QTY ) AS SELECT * FROM SPJ; - création de la
table SPJ1 (double de la table SPJ) sans aucune contrainte et son remplissage par les valeurs de
SPJ

Bases de données. 8 Elena Smagina

Collège de Rosemont Techniques de l'informatique

Remarque : D'une manière générale, il faut supprimer toutes les lignes faisant référence à la valeur
de la clé primaire d'une ligne à supprimer dans la table référencée avant de supprimer cette ligne
dans la table référencée. Il existe la possibilité de désactiver la contrainte d'intégrité référentielle
(clé étrangère) de la table référençante avant la suppression des lignes dans la table référencée, mais
cette solution engendre l'incohérence su niveau de données et il fait l'éviter. On peut aussi modifier
la contrainte d'intégrité référentielle en lui ajoutant la clause ON DELETE CASCADE (on ne peut
pas modifier directement, il faut d'abord supprimer la contrainte et ajouter après la nouvelle
modifiée).

5. Structure CASE de SQL

Les conditions SQL ne sont pas forcément importantes pour l'optimisation, mais sont extrêmement
pratiques pour obtenir des données tirées d'autres données très rapidement. Elles permettent de
renvoyer une valeur si une expression est vraie, ou une autre valeur si elle est fausse...

La structure CASE est la structure conditionnelle la plus répandue parmi les SGBDR et la plus
complète. Elle peut être utilisée dans des instructions, telles que SELECT et UPDATE.

L’utilisation de CASE est possible de 2 manières différentes :

• Comparer une colonne à un ensemble de résultats possibles
• Élaborer une série de conditions booléennes pour déterminer un résultat

Voici la syntaxe nécessaire pour comparer une colonne à un ensemble de résultats possibles:
CASE nomColonne
WHEN valeur1 THEN expression1
WHEN valeur2 THEN expression 2
…….
WHEN valeurn THEN expressionn
[ELSE expression n+1]
END

A noter : la clause ELSE est facultative. Si les conditions précédentes ne sont pas respectées alors
ce sera l’expression d’ELSE qui sera retournée.

Exemple :
SELECT Pname "Nom de la pièce",
( CASE color
WHEN 'Red' THEN 'Rouge'
WHEN 'Green' THEN 'Vert'
WHEN 'Blue' THEN 'Bleue'
ELSE 'Inconnu'
END ) "Couleur"
FROM P;

Il est possible d’établir des conditions plus complexes pour récupérer un résultat ou un autre.
CASE
WHEN condition1 THEN expression1
WHEN condition2 THEN expression 2
…….
WHEN conditionn THEN expressionn
[ELSE expression n+1]

Bases de données. 9 Elena Smagina

Collège de Rosemont Techniques de l'informatique

Exemple :
SELECT Pname "Nom de la pièce",
( CASE
WHEN color='Red' THEN 'Rouge'
WHEN color='Green' THEN 'Vert'
WHEN color='Blue' THEN 'Bleue'
ELSE 'Inconnu'
END ) "Couleur"
FROM P;

Il est possible d’utiliser le CASE à la suite de la commande SET d’un UPDATE pour mettre à jour
une colonne avec une donnée spécifique selon une règle.

Exemple : Dans la BD SPJ on souhaite d’offrir une réduction pour toutes les expéditions qui ont la
quantité suffisante. Si la quantité est inférieure à 200, il n’a pas de réduction, si la quantité est entre
200 et 500, la réduction est 5%, si la quantité est entre 501 et 700, la réduction est 7%, si la quantité
est entre 701 et 1000, la réduction est 8%, si la quantité est entre 1001 et 1500, la réduction est 10%,
si la quantité est >1500, la réduction est 15%.

Tout d’abord on va modifier la table DSPJ en lui ajoutant la colonne reduction :

ALTER TABLE SPJ ADD (REDUCTION NUMBER(2));

Après, on la remplir cette colonne :

UPDATE SPJ SET reduction = (
CASE
WHEN qty < 200 THEN 0
WHEN qty between 200 and 500 THEN 5
WHEN qty between 501 and 700 THEN 7
WHEN qty between 501 and 1000 THEN 8
WHEN qty between 1001 and 1500 THEN 10
ELSE 15
END
);

6. Sauvegarde des mises à jour de données. Gestion des transactions.

En bases de données, le concept de transaction a été introduit depuis 1972. Ce concept est aussi
d'actualité dans les systèmes d'exploitation. Le concept de transaction est fondamental pour
maintenir la cohérence des données. La gestion de transaction mélange les problèmes de fiabilité et
de reprise après panne avec les problèmes de concurrence d'accès. Les problèmes de sécurité qui
recouvrent la confidentialité sont aussi connexes.

Une transaction est une unité logique de travail qui typiquement, se compose d'une suite
d'instructions du LMD (INSERT, UPDATE, DELETE) qui doivent être toutes exécutées ou pas du
tout.

Il est nécessaire pour l'utilisateur de pouvoir informer le système du début et de la fin d'une
transaction. En SQL*Plus. Une transaction est implicitement démarrée lors d'exécution de la
première commande du LMD (INSERT,DELETE, UPDATE) après la commande COMMIT,
ROLLBACK ou CONNECT.

Bases de données. 10 Elena Smagina

Collège de Rosemont Techniques de l'informatique

Une seule transaction est active à un instant donné. Cette transaction se termine lors de
l'utilisation de la commande de contrôle COMMIT ou ROLLBACK (ou lors de la déconnexion ou
de la fermeture d'une session SQL*PLUS). Une nouvelle transaction débute lors d'exécution de la
première commande du LMD (INSERT,DELETE, UPDATE) suivante.

La transaction permet de s'assurer que l'ensemble des instructions inclus dans celle-ci sera réalisée
dans sa totalité ou pas du tout. Chaque transaction permet également d'assurer la cohérence des
données vues par chaque utilisateur connecté au SGBDR. En effet, toutes les modifications faites
sur les données au cours d'une transaction se font par rapport à l'état de ces données su début de la
transaction. Les modifications apportées sur les données au cours d'une transaction exécutée par un
utilisateur ne seront visibles des autres utilisateurs qu'après la validation par COMMIT de cette
transaction. Lors de l'accès simultané aux mêmes données (tables) à partir de plusieurs transactions
dans plusieurs instances, Oracle garantit la cohérence des données dans la transaction par rapport à
la lecture initiale. Lorsqu'une commande de mise à jour INSERT, UPDATE ou DELETE est
exécutée, les changements sont enregistrés temporairement (instance d'Oracle). Ceci permet de
revenir en arrière et de remettre les données dans l'état où elles étaient lors de la dernière
sauvegarde physique.

Les SGBDs doivent garantir les propriétés ACID des transactions (Atomicité, Cohérence,
Isolation, Durabilité).

L'atomicité. Une transaction doit effectuer toutes ses mises à jour ou ne rien faire du tout. En cas
d'échec, le système doit annuler toutes les modifications que la transaction a engagées. L'atomicité
est menacée par les pannes de programme, du système ou du matériel, et plus généralement par tout
événement susceptible d'interrompre une transaction en cours.

La cohérence. Une transaction doit faire passer la BD d'un état cohérent à un autre. En cas d'échec,
l'état cohérent initial doit être restauré. La cohérence de la base peut être violée par un programme
erroné ou un conflit d'accès concurrent entre transactions.

L'isolation. Les résultats d'une transaction ne doivent être visibles aux autres transactions qu'une
fois la transaction validée (committed) par la commande COMMIT afin d'éviter les interférences
avec les autres transactions. Les accès concurrents peuvent mettre en question l'isolation.

La durabilité. Dès qu'une transaction valide ses modifications, le système doit garantir qu'elles
seront conservées en cas de panne. Le problème essentiel survient en cas de panne de disques.

Remarque : Une exécution entrelacée d'un ensemble de transactions concurrentes est sériable, au
sens où elle produit le même résultat que si on exécute ces mêmes transactions une à la fois et dans
n'importe quel ordre.

Les propriétés des transactions doivent être garanties dans le cadre d'un système SGBD centralisé,
mais aussi dans les systèmes répartis. Elles nécessitent 2 types de contrôle :
Contrôle de concurrence;
Résistance aux pannes avec la validation de reprise.

Les données sont sauvegardées de façon permanente (physiquement) lorsque la commande

COMMIT est émise ou lorsqu'une commande de définition de données est exécutée (commande
auto-commit). Tant qu'une transaction n'est pas validée par l'instruction COMMIT, les
modifications faites sur les données sont visibles dans l'instance courante et pas par les autres
utilisateurs qui se connectent et créent plusieurs autres instances.

Bases de données. 11 Elena Smagina

Collège de Rosemont Techniques de l'informatique

La commande COMMIT valide la transaction, c'est-à-dire toutes les modifications de données

depuis le dernier COMMIT ou CONNECT deviennent définitives et seront sauvegardées
physiquement dans les fichiers d'une BD.

La syntaxe de la commande COMMIT : COMMIT;

La commande ROLLBACK annule la transaction, c'est-à-dire toutes les modifications de données

depuis le dernier COMMIT ou CONNECT ou SAVEPOINT seront annulées.

La syntaxe de la commande ROLLBACK : ROLLBACK [TO nom_point_contrôle];

Si le ROLLBACK indique le point de contrôle, la transaction en cours est toujours active après
l'exécution de cette commande.
Attention! La commande ROLLBACK n'annule pas seulement la dernière commande du LMD
(INSERT, UPDATE, DELETE), mais l'ensemble des commandes dans une transaction.

La commande SAVEPOINT permet de mettre un point de contrôle qui mémorise un état des
données au cours de la transaction et permet d'annuler les modifications faites après la pose de
celui-ci seulement.

La transaction en cours est toujours active après la pose de SAVEPOINT.

La syntaxe de la commande SAVIPOINT : SAVEPOINT nom_point_contrôle;

Lorsqu'on quitte une session normalement (QUIT, EXIT), ou on se déconnecte

(DISCONNECT), la transaction courante est validée automatiquement.

Lorsqu'on quitte une session anormalement (redémarrage de la station, panne de courant,…) ou

lorsqu'on quitte une session avec la commande EXIT ROLLBACK (QUIT ROLLBACK), la
transaction courante est annulée.

Exemple 1:
1. Ouvrez 2 sessions avec le même nom d'utilisateur (création de 2 instances).
2. Dans la session 1 (instance 1), effectuez les commandes suivantes :
SELECT * FROM J;
INSERT INTO J VALUES ('J8', 'Display', 'Paris');
SELECT * FROM J; - la ligne 'J8', 'Display', 'Paris' est ajoutée à la table J dans cette session
(instance).
3. Dans la session 2 (instance 2), afficher le contenu de la même table J. La ligne 'J8', 'Display',
'Paris' n'est pas visible (propriété d'isolation d'une transaction).
4. Revenez dans la session 1 et effectuez la commande COMMIT;
5. Dans la session 2 (instance 2), afficher encore une fois le contenu de la même table J. La ligne
'J8', 'Display', 'Paris' devient visible (propriété d'isolation d'une transaction). Supprimez
cette ligne avec la commande
DELETE FROM J WHERE J# = 'J8';
6. Dans la session 1 (instance 1), afficher le contenu de la même table J. La ligne 'J8', 'Display',
'Paris' reste visible (propriété d'isolation d'une transaction).
7. Revenez dans la session 2 et effectuer la commande COMMIT;
8. Dans la session 1 (instance 1), afficher encore une fois le contenu de la même table J. La ligne
'J8', 'Display', 'Paris' n'est plus visible (propriété d'isolation d'une transaction).
9. Dans la session 1 (instance 1), effectuez les commandes suivantes :
Bases de données. 12 Elena Smagina
Collège de Rosemont Techniques de l'informatique

SELECT * FROM J;
INSERT INTO J VALUES ('J9', 'Display', 'Rome');
SELECT * FROM J; - la ligne 'J9', 'Display', 'Rome' est ajoutée à la table J dans la session 1
(instance 1).
10. Essayez d'effectuer les mêmes commandes dans la session 2 (instance 2). La commande
SELECT * FROM J; va afficher le contenu de la table J sans ligne 'J9', 'Display', 'Rome'. Mais
la commande INSERT INTO J VALUES ('J9', 'Display', 'Rome'); ne va pas s'exécuter, car
l'utilisateur dans l'instance 1 a verrouillé l'accès à la table J (la commande bloque la session 2).
Une transaction de mise à jour d'une table verrouille cette table et ne permet que l'accès en
lecture vers cette table pour que 2 utilisateurs ne puissent pas modifier les données en même
temps (propriété de cohérence d'une transaction).
11. Revenez dans la session 1 et effectuez la commande COMMIT; (le verrou est enlevé) : on peut
voir que la commande INSERT INTO J VALUES ('J9', 'Display', 'Rome'); en suspense dans la
session 2 est maintenant exécutée et donne une erreur (violation de contrainte unique). Si, dans
la session 1, on effectue la commande ROLLBACK à la place de la commande COMMIT; on
peut voir que la commande INSERT INTO J VALUES ('J9', 'Display', 'Rome'); en suspense
dans la session 2 est maintenant exécutée avec le succès.

Exemple 2:
1. SELECT * FROM J;
2. INSERT INTO J VALUES('J8', 'Display', 'Paris');
INSERT INTO J VALUES('J9', 'Display', 'Rome');
SELECT * FROM J; - l'ajout de 2 lignes dans la table J
3. SAVEPOINT S1;
4. INSERT INTO J VALUES('J10', 'Display', 'Madrid'); - l'ajout de la 3-ème ligne dans la table J
5. DELETE J WHERE J# = 'J9'; - suppression d'une ligne de la table J
6. SELECT * FROM J;
7. ROLLBACK TO S1; - annulation des modifications jusqu'au point de contrôle S1.

Bases de données. 13 Elena Smagina