Vous êtes sur la page 1sur 15

La syntaxe de création d’une table est :

Create Table <nom de la table> (<nom attribut> type(taille), ….) ;


 
Exemple : soit la table Etudiant décrite par les attributs :
-          Matricule : une chaine de 12 caractères,
-          Nom : une chaine de 25 caractères,
-          Prénom : une chaine de 25 caractères,
-          Section : une chaine de 7 caractères,
-          Groupe : Un caractère.
 
Pour sa création on écrit :
Create Table Etudiant (Matricule varchar2(12), Nom varchar2(25), Prenom varchar2(25), Section
varchar2(7), Groupe char) ;
 
Remarques :
-          Pour exécuter, chaque commande doit se terminer par un point-virgule,
-          Pour les types on a : varchar2 : chaine de caractères, char : un caractère et on peut écrire
varchar2(1), number(nb1, nb2) : un réel sur nb1 positions (y compris le point décimal) dont nb2
chiffres après la virgule, number(n) : un entier d’une taille n.
 
Pour afficher la structure de la table : Desc <nom de la table> ;
Ex : Desc Etudiant ;
 
Un tableau s'affiche décrivant les attributs de la table, leurs types et tailles.
 
La table étant vide (ne contient aucune donnée), on commence par insérer des tuples :
 
Syntaxe d’insertion :
Insert Into <nom table> Values (valeur1, valeur2,…) ;
 
Les valeurs seront attribuées aux différents attributs suivant l’ordre de leur création dans la table.
 
Exemple :
Insert Into Etudiant Values (‘170000121110’, ‘Ali’, ‘Ahmed’, ‘L3ISILB’,’1’) ;
On ne peut insérer qu’un tuple à la fois.
 
On peut afficher les tuples insérés par :
Select * From Etudiant ;
 
Sur une table créée, on peut appliquer deux types d’opérations :
1-      La mise à jour de la structure de la table,
2-      La mise à jour des données de la table.
 
Mise à jour de la structure de la table :
On peut :
 
Ajouter un attribut
Alter Table <nom table> Add (<nom attribut> type(taille)) ;
 
Modifier un attribut existant : (lui changer le type et/ou la taille)
Alter Table <nom table> Modify (<nom attribut> type(taille)) ;
 
Supprimer un attribut
Alter Table <nom table> Drop Column <nom attribut> ;
 
La table peut être supprimée par
Drop Table <nom table> ;
 
Mise à jour des données de la table :
 
Insérer des lignes :
Insert Into <nom table> Values (valeur1, valeur2, .. , ..) ;
 
Remarque : On peut ne renseigner que quelques attributs, ces derniers doivent être mentionnés après
le nom de la table (entre parenthèses), les autres attributs auront la valeur Null. Le nombre de valeurs
après Values doit être égal au nombre d’attribut mentionnés :
Insert Into <nom table>(<nom attribut1>, <nom attribut2>,..) Values (valeur1, valeur2,..) ;
 
Modifier les données d’une ou plusieurs lignes :
Update <nom tablle> Set <modification> [Where <condition>] ;
 
Remarque :
La clause Where est facultative. Sans Where, la modification va toucher toutes les lignes de la table.
 
Supprimer une ou plusieurs lignes :
Delete From <nom table> [Where <condition>] ;
Remarque: Sans Where, toutes  les lignes de la table sont supprimées, mais la table existe toujours.
 
Exemples :
Ex1 : Modifier le groupe de l’étudiant dont le matricule est ‘170000111110’ à ‘2’.
Update Etudiant Set groupe=’2’ Where matricule=’ 170000111110’’ ;
 
Ex2 : Supprimer les étudiants dont la section est Null.
Delete From Etudiant Where section is Null;
Remarque: La valeur Null n’admet pas le symbole d’égalité, on ne peut pas mettre section=Null.
 
Ex3 : Ajouter à la table Etudiant la date de naissance (DateN) qui est de type Date.
Alter Table Etudiant Add( DateN date) ;
Remarque : Dans le nom d’attributs on n’admet pas l’espace, on peut le remplacer par le blanc
souligné (tiret du chiffre 8), ex : Date_N
 
Ex4 : Modifier la taille de l’attribut nom de la table Etudiant, à 35.
Alter Table Etudiant Modify  (nom varchar2(35)) ;
 
Ex5 : Supprimer l’attribut DateN de la table Etudiant.
 
Alter Table Etudiant Drop Comumn DateN ;
 
Exercice
Créer la table suivante:
Client(IDclient, Nom, Adr): proposer des types et des tailles pour les attributs.
- Insérer des lignes dans cette table.
- Ajouter une nouvelle colonne 'email'.
- Modifier l'adresse d'u client connu par son IDclient.

Correction :
Create table client (Idclient varchar2(5), nom varchar2(25), Adr varchar2(35)); 

Insert into client values ('00011', 'hhhh', 'aaaa'); 


Alter table client Add(Email varchar2(35)); 

Update client set Adr='eeee' where Idclient='00011';

Les contraintes d'intégrité :

Représentent des contrôles sur les données et les liens entre les données.

La contrainte de clé primaire :


Une clé primaire est un attribut, ou ensemble d'attributs, qui détermine tous les autres attributs.
Autrement dit,  chaque tuple de la table,  a une valeur unique pour la clé.

Description de la clé d'une table:

1- la clé est composée d'un seul attribut :

Si la clé d'une table est composée d'un seul attribut,  On peut la décrire suivant deux manières 

1ère manière : sur la ligne de description de l'attribut (in line)

Create table nomtable (nom attribut clé type(taille) primary key,.....);

2ème manière : en dehors de la ligne de description de l'attribut (out of line) , Comme contrainte
dite nominale.

Create table nomtable (nom attribut clé type(taille),....., constraint  nomContrainte Primary


key(nomAttribut));

NomContrainte c'est un nom que vous donnez à la contrainte, doit respecter les mêmes conditions que
les noms d'attributs. 

Exemple :
Soit la table Etudiant
Matricule : chaîne de12 caractères,
Nom: chaîne de 25 caractères,
Prenom : chaîne de 35 caractères,
Section : chaîne de 5 caractères.
Matricule est la clé primaire de la table.

1ère méthode :
Create table Etudiant (Matricule  varchar2(12) primary key,  Nom varchar2(25), Prenom
varchar2(25), Section  varchar2(5));

2ème methode:
Create table Etudiant (Matricule  varchar2(12),  Nom varchar2(25), Prenom varchar2(25), Section 
varchar2(5), constraint cleP primary key (Matricule) );

Remarque: si la table est déjà créée,  On peut soit modifier l'attribut Matricule ou ajouter la contrainte
de clé primaire :

Alter table Etudiant modify (matricule  varchar2(12) primary key);

Ou

Alter table Etudiant Add ( constraint cleP primary key (matricule));


2- La clé est composée de plusieurs attributs :

Si la clé primaire est composée de plusieurs attributs,  Elle ne peut être décrite que par une contrainte :

Exemple : la table examen est décrite par les attributs 


Matricule : varchar2(12) qui représente l'étudiant ayant passé l'examen 
CodeMod: varchar2(5) qui représente le module dans lequel a eu lieu l'examen 
Note: number(5,2): qui représente la note obtenue par l'étudiant dans l'examen du module. 

Les attributs (matricule,  CodeMod), ensemble,  forment la clé de la table. 

On écrit alors:

Create table examen (matricule  varchar2(12), CodeMod varchar2(5), note number(5,2), constraint 


Cle  primary key (matricule,  CodeMod)); 

Remarque : si la table est déjà créée,  on ajoute la contrainte de clé primaire 

Alter table Examen Add (constraint  Cle  primary key (matricule,  CodeMod)); 

La contrainte Not Null 

Oblige l'attribution d'une valeur lors d'une insertion

Exemple : Chaque Etudiant doit avoir un nom,  On écrit alors lors de la création de la table 

Create table Etudiant (Matricule  varchar2(12),  Nom varchar2(25) Not Null, Prenom varchar2(25),
Section  varchar2(5), constraint cleP primary key (Matricule) );

Lors d'une insertion on doit saisir une valeur por l'attribut Nom. 

La contrainte Unique :

On l'utilise quand un attribut (ou ensemble d'attributs) , autre que la clé primaire,  Sa valeur est unique
(clé secondaire).  

Exemple: soit la table client décrite par 


CodeCl: varchar2(5), clé primaire 
Nom: varchar2(25)
NumCarteNationale:varchar2(12)

CodeCl est une clé primaire,  Et on ne peut pas avoir plusieurs clients avec le même numéro de carte
nationale (la valeur est unique). 
On ecrit:

Create table client(CodeCl varchar2(5) primary key,  nom varchar2(25), NumCarteNationale


varchar2(12) unique); 

La contrainte Check :

Impose une condition sur les valeurs d'une ou plusieurs colonnes. 

Condition sur Les valeurs d'une colonne:


Ex: la note d'examen ne doit pas être inférieure à zéro,  On écrit :

Create table examen (matricule  varchar2(12), CodeMod varchar2(5), note number(5,2) check


(note>0), constraint  Cle  primary key (matricule,  CodeMod)); 

Condition sur les valeurs de plusieurs colonnes:

Dans ce cas la  contrainte doit être nominale (out of line) 


Ex:
Personne(codep, nom,  salaire, salairemin)
Avec:
Codep: clé primaire 
Salaire>=salairemin

La commande de création est:

Create table personne (codep varchar2(5) primay key,  nom varchar2(25), salaire number(8,2),
salairemin number(8,2), constraint verifier check (salaire>=salairemin)); 

Remarque : verifier est le nom donné à la contrainte .

Exercice :(devoir) 
Pour la table client que vous avez déjà créée , ajoutez la contrainte de clé primaire sur l'attribut
IdClient.
Quel type de problème pouvez-vous  rencontrer ? 
Ajouter une nouvelle colonne Telephone avec la contrainte Not Null.
Que remarquez-vous ?  (quelle est l'erreur  obtenue) . Proosez une solution pour régler ce
problème.

Corrigé :

Pour l'ajout de la contrainte de clé primaire  on écrit :

Alter table client modify (Idclient varchar2(5) primary key) ; 


Ou
Alter table client add (constraint PK primary key (Idclient)); 

Comme la contrainte primary key regroupe les deux contraintes not null et unique,  
Les problèmes qu'on peut rencontrer:

- existance de plusieurs lignes avec la même valeur pour l'attribut Idclient .(ce qui contredit
unique) .
- existance d'une ligne dont l'attribut Idclient n'est pas  renseigné .(ce qui contredit not null). 

Ajout de l'attribut email avec la contrainte  not null :

Alter table client add (email varchar2(30) not null); 

L'attribut ne peut pas être ajouté si la table contient des tuples, puisque ne peut attribuer null
comme valeur par défaut.

Solution: 
. ajouter l'attribut sans la contraite not null, . donner des valeurs pour l'attribut email des
differents tuples, 
. ajouter la contrainte  not null.
 
Les contraintes d’intégrité (suite)

La contrainte de clé étrangère :

La clé étrangère est un attribut d’une table qui est la clé primaire d’une autre table (vient par migration
lors du passage au modèle relationnel).

La table portant la clé étrangère est appelée table fille, l’autre est la table mère.

Un tel attribut permet de faire un lien entre les deux tables, un lien fonctionnel.

Avant de définir la contrainte de clé étrangère entre les deux tables, il faut que :

 La table mère soit créée en premier,


 L’attribut commun doit avoir le même type et taille dans les deux tables,
 L’attribut doit être clé primaire dans la table mère.

 
Pour déclarer la contrainte de la clé étrangère (Foreign Key), on écrit :

Constraint <nom contrainte> Foreign Key (nom attribut) References <Nom table mère> [(nom
attribut)] ;

Exemple : on a les tables :

Section : CodeS : varchar2(7) clé primaire

                Specialite : varchar2(25)

Etudiant : Matricule varchar2(12) clé primaire

                Nom : varchar2(25)

                Prenom : varchar2(25)

                CodeS : varchar2(7) clé étrangère faisant référence à CodeS de la table Section.

On déclare de la manière suivante :

On crée d’abord la table Section :

Create Table Section (CodeS  varchar2(7) Primary Key, Specialite varchar2(25)) ;

On crée  ensuite la table Etudiant en précisant que CodeS est une clé étrangère faisant référence à la
table Section :

Create Table Etudiant (Matricule varchar2(12) Primary Key, Nom varchar2(25), Prenom
varchar2(25), CodeS varchar2(7), Constraint CleEt Foreign Key (CodeS) References Section) ;

Remarque :
 Si la table Etudiant est déjà créée, on ajoute la contrainte de clé étrangère par Alter Table :
Alter Table Etudiant Add (Constraint CleEt Foreign Key (CodeS) References Section) ;
 S’il y a au moins un étudiant dont la section ne figure pas dans la table section, on aura un
message d’Erreur(aucune référence dans la table Section).
 La contrainte de clé étrangère ne peut pas être définiesur la ligne de description de l’attribut
(doit être décrite Out Of Line).
 Après le nom de la table de référence (dans notre exemple la table Section), on peut ne pas
préciser le nom de l’attribut commun puisque c’est la clé de la relation.

 
La contrainte References :

 On peut l’utiliser pour décrire une clé étrangère sur la lgne de description de l’attribut :

Ex : pour la table Etudiant décrite plus haut on aura :

Create Table Etudiant (Matricule varchar2(12) Primary Key, Nom varchar2(25), Prenom
varchar2(25), CodeS varchar2(7)  References Section (CodeS)) ;

Ici, on doit préciser l’attribut de référence dans la table Section.

 On peut aussi utiliser References  quand la clé primaire de la table est composée de plusieurs
pour préciser la table de référence de chaque partie de la clé.

Ex : On reprend la table Examen décrite en Tp3 :

Create Table Examen (Matricule varchar2(12) References Etudiant(Matricule), CodeMod


varchar2(5) References Module(CodeMod)), Note number(5,2), Constraint CleP Primay Key
(Matricule, CodeMod)) ;

Les deux tables Etudiant et Module doivent être crées avant la table Module (les tables de référence),
on doit préciser les attributs de références après le nom de chacune des deux tables.

On ne peut pas insérer un tuple dans la table examen si l’étudiant ou la matière ne figurent pas dans les
tables de référence.

La contrainte On Delete Cascade/ Set Null :

Définie lors de la description de la table de référence (avec Foreign Key)  pour préciser l’action à
entreprendre si le tuple de référence est supprimé dans la table mère.

Pour notre exemple,  que faire des étudiants si leur section est supprimée ? .

On Delete  Cascade: la suppression d’une section  entraine la suppression de tous ses étudiants.

On Delete  Set Null : la suppression d’une section n’entraine pas la suppression de ses étudiant, mais
CodeS aura la valeur Null.

Ex :

Create Table Etudiant (Matricule varchar2(12) Primary Key, Nom varchar2(25), Prenom
varchar2(25), CodeS varchar2(7), Constraint CleEt Foreign Key (CodeS) References Section On
Delete Set Null) ;

La Manipulation Des Données LMD


Le langage de manipulation des données.
 
Après création des tables,  Il est possible de récupérer les données stockées grâce à des requêtes
d'interrogation de la base de données. 
 
Ex: 
Select matricule, nom 
From Etudiant; 
 
Permet d'afficher le matricule et le nom de tous les étudiants. On peut choisir un ordre d'affichage en
utilisant la clause ORDER BY, ex: afficher les étudiants dans l'ordre alphabétique des noms
(Ascendant)
 
Select Matricule, Nom
From Etudiant
Order By Nom Asc;
 
Remarque: L'ordre par défaut est Ascendant.
L'ordre Descendant est défini par l'abréviation Desc.
 
Si on désire afficher les étudiants (matricule et nom) d'une certaine section on ajoute la clause where:
 
Select matricule,  nom
From Etudiant 
Where section ='IsilB'; 
 
Remarque :
La condition peut être simple,  Ou composée de sous conditions combinées avec les opérateurs
logiques: AND et OR. 
 
Ex:
 
Select matricule,  nom
From Etudiant 
Where (section='IsilB') Or (section='AcadC'); 
 
Dans Where on peut:
- Utiliser les opérateurs de comparaison  =, <, >, <=, >=.
 
- Vérifier l'appartenance des valeurs d'un  attribut à un intervalle (Where Art Between val1 and val2).
 
- Vérifier qu'un attribut possède comme valeur une chaine de caractères:
se terminant par un ensemble de caractères précis (Chaine): Where <Nom attribut> Like '%Chaine';
commence par une Chaine: Where <Nom attribut> Like 'Chaine%';
ou contient Chaine: Where <Nom attribut> Like '%Chaine%';
 
- Préciser que les valeurs d'un attribut appartiennent à un ensemble: Where <Nom attribut> in (x, y, z);
(on peut aussi utiliser la négation pour les prédicats: Not Between, Not Like, Not In).
 
Exemple:
Afficher les modules contenant le mot 'système':
Select CodMod, Libelle
From Module
Where Libelle Like (%système%);
 
Afficher les étudiants (Matricule) , ayant une note entre 10 et 15:
Select Matricule
From examen
Where Note Between 10 and 15;
ou
Select Matricule
From examen
Where (Note>=10) And (Note<=15);
 
Les fonctions d'agrégation:
Agréger un ensemble de données consiste à les présenter par une données de synthèse, par exemple j'ai
les valeurs 10,12,11,9. Leur somme est une donnée de synthèse et donne 42.
 
Les fonctions d'agrégation  sont:
SUM(): la somme de valeurs numériques, pour notre exemple 42
MIN():le minimum, pour notre exemple 9
MAX(): le maximum, pour notre exemple 12
AVG(): la moyenne, pour notre exemple 10.5
COUNT(): le denombrement, pour notre exemple 4 (4 valeurs).
 
Exemple: 
- Donner le nombre de modules ayant un coefficient supérieur à 2:
Select Count()
From Module
Where Coef>2;
 
- Donner la meilleure note dans le module base de données (BDD)
Select Max(Note)
From Examen
Where CodeMod='BDD';
 
On remarque que l'intitulé de l'attribut résultat est Max(Note), on peut lui changer d'intitulé en utilisant
AS:
Select Max(Note) As MeilleureNote
From Examen
Where CodMod='BDD';
 
Devoir 4:  

Soit la base de données suivante :

·          Départements :( DNO, DNOM, DIR, VILLE)

·          Employés : ( ENO, ENOM, PROF, DATEEMB, SAL, COMM, #DNO)

Après avoir créé les tables (à vous de choisir le type et taille des attributs)

Exprimez en SQL les requêtes suivantes :

1.    Donnez la liste des employés ayant une commission

2.    Donnez les noms, emplois et salaires des employés par emploi croissant, et pour chaque emploi, par
salaire décroissant
 
3.    Donnez le salaire moyen des employés

Correction:

Create table Departements (DNO varchar2(5) primary key,  Dnom varchar2(30), Dir  varchar2(25), Ville
varchar2(25)); 

Create table employes (ENO varchar2(5) primary key,  Enom varchar2(25), Prof varchar2(25), DateEmb
date,  Sal number (7,2), Comm varchar2(25), DNO varchar2(5) references Departments (DNO)); 

La liste des employés ayant une commission :


Select ENO,  Enom
From employes 
Where Comm is not null ; 
(is not null pour dire que commission contient une valeur) 

Les noms,  emplois,  Et salaires des employés par emploi croissant et pour chaque emploi par salaire
décroissant :
Select Enom,  Prof,  Sal
From employes 
Order by Prof, Sal desc ; 

Le salaire moyen des employés :


Select avg(Sal) as SalMoy
From employes ;  
La manipulation des données (Suite)
 
Partitionnement d’une table :
Consiste à diviser la table en sous-tables au nombre de valeurs de l’attribut de partitionnement.
 
Exemple: Soit la table
Examen (matricule, codmod, note)
001 BD 12
002 BD 13
001 SI 15
002 SI 13
001 SYS 10
002 SYS 16
 
-         1-  La moyenne par module :
Select codmod , AVG (note)
From examen
Group by codmod;
Comme on a trois valeurs pour l'attribut de partitionnement qui est codmod, on aura trois sous
groupes, un pour BD, un pour SI et un autre pour SYS.
Le calcul AVG se fera pour les valeurs de chaque sous groupe.
 
Ce qui donne:
 
Cod mod AVG (note)
BD 12.5
SI 14
SYS 14
 
-       2/    La moyenne par Étudiant :
Select matricule, AVG (note)
From examen
Group by matricule ;
Le résultat est:
matricule AVG (note)
001 12.33
002 14
 
-          3/ Le nombre d’examens par module
Select count (+), codmod
From examen
Group by codmod ;
Résultat:
Codmod Count (+)           
BDD 2
SI 2
SYS 2
 
La clause having :
Elle est utilisée si on désire mettre une condition sur le résultat du partitionnement :
 
Ex : les étudiants admis (pour lesquels la moyenne est >= 10)
Select matricule, AVG (note)
From examen
Group by matricule
Having AVG (note) >= 10;
 
La manipulation de plusieurs tables : (la jointure)
La jointure est une opération relationnelle qui sert à chercher des résultats à partir d’une ou plusieurs
tables ayant au moins un attribut commun.
 
Ex : soient les tables :
 
Etudiant (matricule varchar2(5) Primary key, nom varchar2(25), prénom varchar2(25), section
varchar2(5)) ;
 
Module (codmod varchar2(5) Primary key, design varchar2(25), coef  number(1));
 
Examen (matricule varchar2 (5) references Etudiant (matricule), codmod varchar2(5)  references
module (codmod), note number (5, 2), constraint PK Primary key (matricule, codmod));
 
On désire avoir le nom, prénom des étudiants (se trouvent dans la table Etudiant), qui ont passé
Examen dans le module BDD (c’est le codmod qui se trouve dans les tables Examen et module).
Pour répondre à cette requête con va utiliser les deux tables Etudiant et Examen, qui ont comme
attribut commun matricule : ça sera l’attribut de jointure .
On a aussi une condition sur l’attribut codmod qui doit avoir comme valeur BDD.
 
La requête est :
 
Select     Etudiant. Nom, Etudiant. Prénom
From      Etudiant, Examen
Where    Etudiant. Matricule= examen. Matricule        l’égalité de jointure)
AND        Examen. Codmod= ‘ BDD ‘ ;
 
On peut aussi Ecrire :
Select     nom, prénom
From      Etudiant
Where    matricule IN (select matricule from Examen where codmod =’BDD’);
 
 
Devoir : 
 
Créer les tables ci-dessous.
Etudiant
(matricule_etu, nom_etu, prenom_etu, date_naissance, Adresse)
(20190001, BOUSSAI, Ahmed,12/01/2000, Alger )
(20190002, CHAID, LAMIA, 01/10/1999, Batna)
(20190003, BRAHIMI, SOUAD, 18/11/2000, Sétif)
(20190004, LAMA, SAID, 23/05/1999, Oran )
Enseignant
(matricule_ens, nom_ens, prenom_ens)
(20000001, HAROUNI, AMINE)
(19990011, FATHI, OMAR )
(19980078, BOUZIDANE, FARAH )
(20170015, ARABI, ZOUBIDA)
Examen
(Matricule_etu, code_Unite, note_CC, note_TP, note_examen)
(20190001, FEI0001, 10, 15, 9)
(20190002, FEI0001, 20, 13, 10 )
(20190004, FEI0001, 13, 17, 16)
(20190002, FEI0002, 10, 16, 17)
(20190003, FEI0002, 9, 8, 15)
(20190004, FEI0002, 15, 9, 20)
(20190002, FEI0004, 12, 18, 14)
(20190003, FEI0004, 17, 12, 15)
(20190004, FEI0004, 12, 13, 20)
Module
(code_Unité, libelle, nbr_heures, matricule_ens)
(FEI0001, POO, 6, 20000001)
(FEI0002, BDD, 6, 19990011)
(FEI0003, RESEAU, 3, 20170015)
(FEI0004, SYSTEME, 6, 19980078)
Les requêtes:
1. Afficher les noms et prénoms des étudiants ayant obtenus des notes d'examens égales à 20.
2. Afficher les noms et prénoms des étudiants qui ne sont pas inscrits dans l'unité « POO ».
3. Afficher pour chaque étudiant, son nom, son prénom sa moyenne par unité d'enseignement ainsi
que le libellé de l'unité.

Correction :

Il faut créer les tables tout en respectant l'ordre de leur création à savoir: 
. Tables enseignant,  Etudiant 
. Table module 
. Table examen. 

Les requêtes :

1. Select nom_etu, prenom_etu


From Etudiant 
Where Matricule_etu in (select Matricule_etu from examen where note_examen=20); 

2. Select nom_etu, prenom_etu


From Etudiant 
Where Matricule_etu not in (select Matricule_etu from examen where code_Unité in (select
code_Unité from module where libelle='POO')); 

3. Select Etudiant.nom_etu, Etudiant.prenom_etu, Module.libelle,


(Examen.note_CC+Examen.note_TP+Examen.note_examen)/3
From Etudiant, Module, Examen 
Where (Etudiant.Matricule_etu=Examen.Matricule_etu) and
(Examen.code_Unite=Module.code_Unite); 
Création Des Utilisateurs
Pour créer un utilisateur il faut être un administrateur de la base de données. 
La commande de création est :

Create user <nom utilisateur > identified by <mot de passe >; 

Ex: on va créer un utilisateur ayant comme nom utilisateur votre nom de famille,  Et comme mot de
passe votre prénom,  On écrit :

Create user Hank identified by karima ; 

L'utilisateur créé ne peut pas se connecter à notre base de données parce qu'on ne lui a pas encore
donné le droit de se connecter (créer une session de travail). 

Il faut lui donner ce droit par:

Attribution des droits :

Grant create session to <nom utilisateur >; 

Ex:
Grant create session to Hank ; 

On peut se connecter par :

Connect Hank/karima ; 

(d'une manière générale par


Connect <nom utilisateur >/<mot de passe >;) 

Droits sur les tables :

Une fois connecté essayant la commande :

Select * from Etudiant ; 

Qui consiste à lire toutes les données de la table Etudiant,  cette dernière est créée par l'administrateur. 

Une erreur s'affiche disant que la table n'existe pas.  C'est parceque l'utilisateur n'a pas le droit de faire
une lecture (select)  sur la table Etudiant. 
On doit se reconnecter comme administrateur puis donner le droit de lecture sur la table Etudiant à
l'utilisateur créé par:

Grant select on Etudiant to Hank ; 

D'une manière générale :

Grant <droit> on <nom table> to <nom utilisateur >; 

<droit> peut être : select,  insert, update,  delete. 

On peut donner plusieurs droits sur une table ou sur plusieurs tables,  séparées par virgule. 

On peut donner tous les droits par:

Grant dba to <nom utilisateur >; 

Dba pour data base administrator,  autrement dit administrateur de base de données. 

Dans ce cas il peut créer des tables,  faire toutes les opérations dessus,  créer des utilisateurs et les
gérer. 

On se reconnecte à notre utilisateur créé : connect Hank /karima ; 


Et on execute :
Select * from system.Etudiant ; 

Vous avez remarqué qu'on a précédé le nom de la table par system (ici l'administrateur), car c'est lui
qui a créé la table. 

Donc,  en présence de plusieurs utilisateurs chaque nom de table est précédé par le nom de l'utilisateur
qui l'a créé :
<nom utilisateur >.<nom table>

Retrait de droits:

On peut retirer un droit donné par la commande revoque :(en étant administrateur) 

Revoke <droit> on <nom table> from <nom utilisateur >; 

Ex:
Revoque select on Etudiant from Hank ; 

L'utilisateur n'aura plus le droit de lire les données de la table Etudiant. 

Suppression d'un utilisateur :

Un utilisateur peut être supprimé par:

Drop user <nom utilisateur >; 

Ex:  drop user Hank ; 

Devoir 6:(à remettre au plus tard dimanche 14 juin minuit) 


1/ Donnez le script de création d’un utilisateur ayant comme nom utilisateur votre nom de
famille et comme mot de passe votre prénom.
 2/ Donnez à cet utilisateur les privilèges suivants :  - Créer une session, - Lire les données des
tables Etudiant  et Module, - Lire et écrire les données de la table Examen.
 3/ Avec l’utilisateur créé, insérer un tuple dans la table Examen.
 4/ Avec l’utilisateur créé, insérer un tuple dans la table Etudiant . Que se passe-t-il ? Pourquoi? 
5/ Supprimer touts les étudiants de la section  ‘ISILA’. Que devez vous faire en premier ? 
6/ Retirer le droit d’insertion sur la table Examen  de l’utilisateur créé, puis le supprimer.

Vous aimerez peut-être aussi