Explorer les Livres électroniques
Catégories
Explorer les Livres audio
Catégories
Explorer les Magazines
Catégories
Explorer les Documents
Catégories
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.
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.
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:
• 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).
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.
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
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 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.
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
2.3. Exercice.
Soit la base de données SPJ (FournisseursPiecesProjets) créée précédemment.
Travail à faire :
1. Créer le script de remplissage de la base de données SPJ créée InsertSPJ.sql.
PAUSE Affichage du contenu de la table S remplie. Appuyez sur Enter pour continuer;
SELECT * FROM S;
PAUSE Appuyez sur Enter pour continuer;
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;
PAUSE Affichage du contenu de la table J remplie. Appuyez sur Enter pour continuer;
SELECT * FROM J;
PAUSE Appuyez sur Enter pour continuer;
PAUSE Affichage du contenu de la table SPJ remplie. Appuyez sur Enter pour continuer;
SELECT * FROM SPJ;
PAUSE Appuyez sur Enter pour terminer;
commit;
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.
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);
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).
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).
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.
Exemple :
CREATE SEQUENCE seq_client INCREMENT BY 1
START WITH 10
MAXVALUE 9999; - création d'une séquence seq_client
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.
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.
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.
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
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).
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.
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]
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%.
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.
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.
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.
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.