Chapitre I : Harmonisation des connaissances en base de données

I-Concepts de base :
1-Définitions
• Une base de données est un ensemble structuré de données enregistrées dans un ordinateur et accessibles de
façon sélective par plusieurs utilisateurs.
• Un logiciel qui permet d'interagir avec une base de données s'appelle un système de gestion de base de
données (SGBD).
Exemples :
• SGBD bureautiques: Access, Base, Filemaker, Paradox ;
• SGBD serveurs : Oracle, DB2, SQL Server, PostgreSQL, MySQL, MariaD.

2-Fonctions d'un SGBD

• Décrire les données qui seront stockées ;
• Manipuler ces données (ajouter, modifier, supprimer) ;
• Consulter et traiter les données ;
• Définir des contraintes d'intégrité sur les données ;
 Définir des protections d'accès (mots de
passe, autorisations,...)
• Résoudre les problèmes d'accès multiples
aux données (blocages, inter blocages)
• Prévoir des procédures de reprise en cas
d'incident (sauvegardes, journaux,...)

II- Aide syntaxique du langage SQL : (Bases du langage SQL et des bases de données)
Le SQL (Structured Query Language) est un langage structuré des requêtes, il est découpé en trois types de
langages : le LDD, le LMD, le LCD.
Conventions sur la notation syntaxique :
Répétition : …. Facultatif : [ ] Obligatoire : { } Alternative : |

II-1 Langage de définition des données :

Le langage de définition des données (LDD) est la partie de SQL qui permet de décrire les objets utilisés par les
SGBD à savoir : les bases de données, les tables, les index, les vues, les fonctions, les procédures stockées, les
déclencheurs, les utilisateurs, les groupes d’utilisateurs, …
Les commandes ou instructions du LDD sont : Create, Alter, Drop, Truncate, Audit, Analyze, Rename.
Dans le cadre de ce cours nous examinerons uniquement les 4 premières commandes.

1- Commande CREATE :
Elle permet de créer tous les objets utilisés dans les SGBD. Les objets utilisés dans les SGBD sont :
Les bases de données, les tables, les index, les vues, les procédures, les fonctions, les utilisateurs, les groupes
d’utilisateurs, les déclencheurs.
Syntaxe de création d’une base de données : Exemples :
Create Database NomBDD Create Table T_Etudiant
[emplacement de la BDD] ( Matricule varchar(8), Noms varchar(30),
Exemple : Create Database BD_IntroAuSQL ; Prenoms varchar(30), Sexe char(8),
DateNaiss Date, Age integer)
Syntaxe de création d’une table :
Create table Nomtable NB : Cette table a été créée sans contrainte
(Colonne1 type1, d’intégrité
Colonne2 type2, …..
……, Syntaxe de création d’un index :
Colonnen typen) Create [UNIQUE] index NomIndexe
Les types de données peuvent être : On NomTable(colonne [ASC|DESC]
INTEGER, BIGINT, REAL, Exemple :
NUMERIC[(précision, [longueur])], Create index MatriculeIndex
CHAR(longueur), VARCHAR(longueur) On T_Etudiant(Matricule asc) ;
DATE, TIMESTAMP : (Ce type de données permet de
stocker des données constituées d'une date et d'une NB : Les index facilitent la recherche des données
heure), BOOLEAN, MONEY, TEXT. dans une base de données.

2- Commande ALTER :
Elle permet de modifier la structure d’une table, d’une vue, d’une procédure stockée ou d’une fonction.
Syntaxe d’ajout d’une colonne dans une table: Syntaxe de suppression d’une colonne d’une table
Alter table NomTable ADD NomColonne Type Alter table NomTable Drop column NomColonne

Page 1 sur 8
Exemples: Exemple:
Alter table T_Etudiant ADD Adresse text Alter table T_Etudiant Drop column Ville
Alter table T_Etudiant ADD Ville varchar(15)

3- Commande DROP :
Elle permet de supprimer un objet de la base de données ou la base de données elle-même.
Syntaxe :
DROP { TABLE | VIEW|DATABASE|INDEX|USER|FUNCTION|PROCEDURE|…..} NomObjet

Exemples de suppression d’une base de données et d’une table

Drop Database BD_IntroAuSQL ; Drop Table T_Etudiant ;

4- Commande Truncate :
Elle permet de vider le contenu d’une table.
Syntaxe : Truncate Table Nomtable ; Exemple : Truncate Table T_Etudiant

II-2 Langage de manipulation des données (LMD) :

Le langage de manipulation des données (LMD) est la partie de SQL qui permet de modifier le contenu des
données contenues dans les tables de la base de données.
Les commandes du LMD sont : Select, Insert, Update, Delete, Explain, LOCK TABLE.
Dans le cadre de ce chapitre nous examinerons uniquement les 4 premières commandes.

1- La commande Select :
Elle permet de lister les données
Syntaxe : Select [ALL|DISTINCT [ON (expression)]] * | expression| Fonctions SQL
FROM expresion
[Where (condition)]
[GROUP BY expression]
[Having (condition)]
[ {UNION | INTERSECT | EXCEPT [ALL]} requête ]
[ORDER BY col1, col2, …]
Alias sur une colonne: Alias sur une table
SELECT colonne1 AS A1, colonne2 as A2, colonne3 Select T.Colonne1, T.Colonne2
FROM NomTable From NomTable T

Opérateur de comparaison à utiliser au niveau de la clause where:

Page 2 sur 8
Cas de like : Ci-dessous la syntaxe
SELECT * FROM table WHERE colonne LIKE modèle
Modèle représente tout ce qui suit :
• LIKE ‘%a’ : recherche toutes les chaines de caractère qui se termine par un « a ».
• LIKE ‘a%’ : recherche toutes les chaines de caractère qui se commence par un « a ».
• LIKE ‘%a%’ : recherche toutes les chaines de caractère qui contiennent « a »
• LIKE ‘pa%on’ : recherche les chaines qui commence par « pa » et se terminent par « on ».
Autres combinaisons :
Il y a la possibilité d’utiliser la négation pour tous ces prédicats : NOT BETWEEN, NOT NULL, NOT LIKE, NOT IN.
Exemples :
Select * SELECT Matricule,Noms,Prenoms SELECT Matricule,
from T_Etudiant FROM T_Etudiant Nom+Prenoms as NomsEtPrenoms,
Order by Matricule Where Prenoms IS NULL and Age as [Age de l’Etudiant]
Desc Noms is not null FROM T_Etudiant
Where Age between 20 and 25
Order by Matricule Asc

Select * Select * Select *

from T_Etudiant from T_Etudiant from T_Etudiant
Where Sexe='Masculin' and Where Sexe='Masculin' and Where Sexe='Masculin' and
(ville='BZV' or ville='PNR') ville in ('BZV', 'PNR') and ville not in ('DOL', 'OYO')
Noms like '%BA%'

Jointure SQL :
Les jointures en SQL permettent d’associer plusieurs tables dans une même requête.
Types de jointures
• INNER JOIN : jointure interne pour retourner les enregistrements quand la condition est vraie dans les 2
tables. C’est l'une des jointures les plus communes.
• LEFT JOIN (ou LEFT OUTER JOIN) : jointure externe pour retourner tous les enregistrements de la table de
gauche (LEFT = gauche) même si la condition n’est pas vérifiée dans l’autre table.
• RIGHT JOIN (ou RIGHT OUTER JOIN) : jointure externe pour retourner tous les enregistrements de la table
de droite (RIGHT = droite) même si la condition n’est pas vérifiée dans l’autre table.

SELECT * SELECT * SELECT *

FROM A INNER JOIN B FROM A LEFT JOIN B FROM A RIGHT JOIN B
ON A.key = B.key ON A.key = B.key ON A.key = B.key

Exemples : soient les deux tables ci-dessous contenant les données

Table - Employes Table - Departement
+----+---------+-----+---------+------------+------+ +--------+--------------+
| Id | Nom | Age | Salaire | Profession | Dep | | Id_dep | Nom_dep |
+----+---------+-----+---------+------------+------+ +--------+--------------+
| 1 | Ismail | 25 | 6000.00 | Assistant | 2 | | 1 | Informatique |
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 | | 2 | RH |
| 3 | Fatima | 29 | 6000.00 | Directeur | 3 | | 3 | Vente |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 | | 4 | Strategies |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | +--------+--------------+
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL |
+----+---------+-----+---------+------------+------+

La requête : SELECT * FROM Departement AS D INNER JOIN Employes AS E ON D.Id_dep=E.Dep;

Produira le jeu de résultats suivant :
+--------+--------------+----+---------+-----+---------+------------+------+
| Id_dep | Nom_dep | Id | Nom | Age | Salaire | Profession | Dep |
+--------+--------------+----+---------+-----+---------+------------+------+
| 2 | RH | 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 1 | Informatique | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 3 | Vente | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 4 | Strategies | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 1 | Informatique | 5 | Omar | 29 | 9000.00 | Ingenieur | 1 |
+--------+--------------+----+---------+-----+---------+------------+------+

Page 3 sur 8
La requête : SELECT * FROM Employes AS E LEFT JOIN Departement as D ON D.Id_dep=E.Dep; donneras ce qui
suit :
+----+---------+-----+---------+------------+------+--------+--------------+
| Id | Nom | Age | Salaire | Profession | Dep | Id_dep | Nom_dep |
+----+---------+-----+---------+------------+------+--------+--------------+
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 | 1 | Informatique |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | 1 | Informatique |
| 1 | Ismail | 25 | 6000.00 | Assistant | 2 | 2 | RH |
| 3 | Fatima | 29 | 6000.00 | Directeur | 3 | 3 | Vente |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 | 4 | Strategies |
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL | NULL | NULL |
+----+---------+-----+---------+------------+------+--------+--------------+
La requête SELECT * FROM Employes AS E RIGHT JOIN Departement as D ON D.Id_dep=E.Dep;
+------+---------+------+---------+------------+------+--------+--------------+
| Id | Nom | Age | Salaire | Profession | Dep | Id_dep | Nom_dep |
+------+---------+------+---------+------------+------+--------+--------------+
| 1 | Ismail | 25 | 6000.00 | Assistant | 2 | 2 | RH |
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 | 1 | Informatique |
| 3 | Fatima | 29 | 6000.00 | Directeur | 3 | 3 | Vente |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 | 4 | Strategies |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | 1 | Informatique |
+------+---------+------+---------+------------+------+--------+--------------+
2- Commande insert:
permet d’insérer les données dans une table
Syntaxe1 : Syntaxe2 :
Insert into NomTable(col1,col2, …,colx) Insert into NomTable(col1,col2, …,colx)
Values( val1, val2, …., valx) Select col1, col2, …., colx
From expression
[Where (condition)]
Exemples :
Insert into T_Etudiant(Matricule,Noms,Prenoms,Sexe,Age,Adresse)
Values('Etu01','OKO','Henri','Masculin',10,'10 rue Ball Bacongo');
Insert into T_Etudiant(Matricule,Noms,Prenoms,Sexe,Age,Adresse)
Values('Etu02','SAMBA','Yvette','Feminin',10,'10 rue LOBI Moungali');

Commande Update:
Elle permet de modifier les données contenues dans une ou plusieurs lignes d’une table.
Syntaxe : Update Nomtable
Set col1=exp1, col2=exp2, …., colx=expx
[Where (condition]
Update T_Etudiant set Age=18 where Matricule=’Etu01’ ;
Update T_Etudiant set Prenoms=’Yvette Francine’ where Matricule=’Etu02’ ;

Commande Delete :
Elle permet de supprimer une ou plusieurs lignes de données d’une table.
Syntaxe : Delete from NomTable [Where condition]
Exemple:
Delete from T_Etudiant; // *** Supression de toutes les lignes de la table ***///
Delete from T_Etudiant where Matricule=’Etu02’; // ** Suppression de l’étudiant dont le matricule est Etu02 */

II-3 Langage de contrôle de données :

Il est utilisé pour la gestion de la sécurisation d’accès aux données.
Les commandes du LCD sont : GRANT, REVOKE.
Chaque créateur d'un objet est propriétaire de cet objet. En créant par exemple une table, on obtient tous les
droits d'accès à cette table (les droits d'effectuer les opérations SELECT, INSERT, UPDATE, DELETE).
Le propriétaire d'une table peut passer ses privilèges sélectivement à d'autres utilisateurs ou à tout le monde
(PUBLIC).
La commande GRANT
Elle permet de passer des droits d'accès à un utilisateur ou un groupe d'utilisateurs
Syntaxe de Grant :
Grant {{select|insert|update|delete|trigger|…}|ALL [PRIVILEGES]
ON [table] NomTable
To {username|Groupname|public}
[With Grant Option]

Page 4 sur 8
La Commande Revoke:
La commande REVOKE permet de retirer des droits à un utilisateur ou groupe d'utilisateurs.
Syntaxe de Revoke :
REVOKE {{select|insert|update|delete|trigger|…}|ALL [PRIVILEGES]
ON [table] NomTable
FROM {username|Groupname|public}
Syntaxe pour la creation d’un utilisateur en MySQL: Syntaxe pour la creation d’un utilisateur en SqlServer:
CREATE USER 'NomUtilisateur'@'NomServeur' CREATE LOGIN [commisLivraison] WITH
IDENTIFIED BY 'mot_de_passe'; PASSWORD=N'Com@2023' ;

Exemples de creation d’utilisateur et d’octroi des CREATE USER [User_commisLivraison] FOR LOGIN
droits: [commisLivraison]
Code Mysql:
GRANT SELECT ON Commande TO
CREATE USER 'nkelet'@'localhost' IDENTIFIED BY [User_commisLivraison]
'456@nkelet';
GRANT ALL PRIVILEGES ON * . * TO GRANT SELECT, DELETE, INSERT, UPDATE ON
'nkelet'@'localhost'; Commande TO user_commisAchat
REVOKE ALL PRIVILEGES ON *.* FROM
'nkelet'@'localhost';

III- Schéma d’une base de données et Contraintes d’Intégrité

1- Schéma d’une base de données :
Un schéma de base de données représente la configuration logique de tout ou partie d'une base de données
relationnelle.

Schéma d’une base de données relationnel

Ensemble de noms de tables, chaque table contenant ses attributs, son identifiant et les identifiants externes.
Avec la méthodologie Merise, le schéma est une représentation du Modèle Logique des Données.
Notations :
Dans un schéma de base de données, les clés primaires soulignées, clés étrangères postfixées par le caractère #.
Exemple :
Le schéma ci-dessous contient 3 tables, chacune des tables contient une clé primaire, les tables Employe et
sevice contiennent les clés étrangères.
Direction(CodeDir,LibelleDir) ;
Employe(Matricule,Noms,Prenoms,DateEmbauche,Adresse,#CodeSer) ;
Service(CodeSer,LibelleSer,#CodeDir) ;

2- Contrainte d’Intégrité :
Une contrainte d'intégrité est une règle qui définit la cohérence d'une donnée ou d'un ensemble de données de
la BD.
Les contraintes d'intégrité sont:
 PRIMARY KEY : définit l'attribut comme la clé primaire
 UNIQUE : interdit que deux tuples de la relation aient la même valeur pour l'attribut.
 REFERENCES <nom table> (<nom colonnes>) : contrôle l'intégrité référentielle entre l'attribut et la table
et ses colonnes spécifiées
 CHECK (<condition>) : contrôle la validité de la valeur de l'attribut spécifié dans la condition dans le
cadre d'une restriction de domaine
 NOT NULL : contrôle le fait qu’une colonne n’accepte pas les valeurs nulles
 NULL : acceptation des valeurs nulles sur une colonne
 DEFAULT : définition de la valeur par défaut d’une colonne
 CONSTRAINT : ajout d’une contrainte

Contrainte applicable à une colonne :

PRIMARY KEY, NOT NULL, UNIQUE, CHECK (condition), FOREIGN KEY (nom_colonne) REFERENCES nom_table
(nom_colonne)

Page 5 sur 8
Exemple1 :
Create Table T_Direction(
Dir_Id integer primary key,
Dir_Libelle varchar(20) unique not null) ;
Create Table T_Service(
Ser_Id integer primary key,
Ser_Libelle varchar(20) unique not null,
Ser_Dir_ID integer) ;
Alter table T_Service
Add Constraint Ck_FK foreign key(Ser_Dir_ID)
references T_Direction(Dir_Id);
Exemple2 :
Ci-dessous le code MySQL :
Create DataBase BD_VoyageExpress;
Use BD_VoyageExpress;
Create Table T_Bus(
Bus_Numero integer primary key auto_increment,
Bus_Immatricul varchar(6) unique not null,
Bus_Libelle varchar(30) unique not null,
Bus_DateAcquisition Date,
Bus_NbrePlace integer not null);
Create Table T_CategoriePermis(
CatP_Cod char(3) primary key,
CatP_Libelle varchar(15) unique not null);
Create Table T_Chauffeur(
Chf_Numero integer primary key auto_increment,
Chf_Nom varchar(30) not null,
Chf_PreNom varchar(30) ,
Chf_Tel varchar(15) unique not null,
Chf_Adresse varchar(50) not null,
CatP_Cod char(3) not null,
Foreign key(CatP_Cod) references
T_CategoriePermis(CatP_Cod));
Create Table T_Ville(
Vil_Code varchar(3) primary key,
Vil_Libelle varchar(30) unique not null);
Create Table T_Conduire(
Cdr_Id integer primary key auto_increment,
Cdr_DateConduite date not null,
Chf_Numero integer not null,
Bus_Numero integer not null,
foreign key(Chf_Numero) references
T_Chauffeur(Chf_Numero),
foreign key(Bus_Numero) references
T_Bus(Bus_Numero));
Page 6 sur 8
CREATE TABLE T_Employe(
Emp_Matricule integer identity(1,1) primary key,
Emp_Nom char(30) NOT NULL DEFAULT ' ',
Emp_Prenom char(30),
Emp_Age integer Default 0, check (Emp_Age < 100),
Emp_Email char(50) NOT NULL, check (Emp_Email LIKE
'%@%'),
Emp_Ser_Id integer foreign key(Emp_Ser_Id)
references T_Service(Ser_Id)
);
Ci-dessous le code SQL Server :
Create DataBase BD_VoyageExpress;
Use BD_VoyageExpress;
Create Table T_Bus(
Bus_Numero integer primary key identity(1,1),
Bus_Immatricul varchar(6) unique not null,
Bus_Libelle varchar(30) unique not null,
Bus_DateAcquisition Date,
Bus_NbrePlace integer not null);
Create Table T_CategoriePermis(
CatP_Cod char(3) primary key,
CatP_Libelle varchar(15) unique not null);
Create Table T_Chauffeur(
Chf_Numero integer primary key identity(1,1),
Chf_Nom varchar(30) not null,
Chf_PreNom varchar(30) ,
Chf_Tel varchar(15) unique not null,
Chf_Adresse varchar(50) not null,
CatP_Cod char(3) not null foreign key references
T_CategoriePermis(CatP_Cod));
Create Table T_Ville(
Vil_Code varchar(3) primary key,
Vil_Libelle varchar(30) unique not null);
Create Table T_Conduire(
Cdr_Id integer primary key identity(1,1),
Cdr_DateConduite date not null,
Chf_Numero integer not null foreign key references
T_Chauffeur(Chf_Numero),
Bus_Numero integer not null foreign key references
T_Bus(Bus_Numero));
IV- Les vues :
1- Définition :
Une vue est une table virtuelle dont les données ne sont pas stockées dans une table de la base de données, et
dans laquelle il est possible de rassembler des informations provenant de plusieurs tables.
Techniquement les vues sont créées à l'aide d'une requête SELECT. Elles ne stockent pas les données qu'elles
contiennent mais conservent juste la requête permettant de les créer.
2- Intérêts des vue :
Une vue permet de :
 Sélectionner les données à afficher ;
 Restreindre l'accès aux tables concernées par la vue pour l'utilisateur, c'est-à-dire une sécurité des
données accrue ;
 Regrouper les informations au sein d'une entité ;
 Centralisation des règles métier ;
 Gagner du temps sur l’écriture de requêtes ;

3- Création de la vue :
La création d'une vue se fait grâce à la clause CREATE VIEW suivie du nom que l'on donne à la vue, puis des noms
des colonnes dont on désire agrémenter cette vue (il faut autant de redéfinitions de colonne qu'il y en aura en
sortie), puis enfin d'une clause AS précédant la sélection.

La syntaxe de création d'une vue ressemble donc à ceci :

CREATE VIEW NomDeLaVue
AS SELECT Expression
FROM NomTable|Plusieurs tables en jointure|NomAutreVue
[WHERE (Condition)]
Exemples :
//Vue pour l’affichage de la liste des Directions// //Vue pour l’affichage de la liste des Services//
Create View ListeDesDirections Create View ListeDesServicesDelaDG
As As
Select Dir_ID, Dir_Libelle Select Ser_ID,Ser_Libelle
From T_Diection ; From T_Direction D join T_Service S
On D.Dir_ID=S.Dir_ID
Where D.Dir_Libelle=’Direction Générale’

4- Modification d’une vue :

La modification d’une vue se fait avec la clause ALTER VIEW suivie du nom de la vue que l’on veut modifier puis
des noms des nouvelles colonnes que l’on désir pour cette vue voir même la nouvelle table ou les nouvelles
tables que l’on explorer.
Ci-dessous la syntaxe :
ALTER VIEW NomDeLaVue
AS SELECT Expression
FROM NomTable|Plusieurs tables en jointure|NomAutreVue
[WHERE (Condition)]
Exemples :
Alter View ListeDesDirections Alter View ListeDesServicesDelaDG
As As
Select * Select Ser_ID,Ser_Libelle
From T_Diection ; From T_Direction D join T_Service S On D.Dir_ID=S.Dir_ID
Where D.Dir_ID=1

5- Suppression d’une vue :

La suppression d’une vue se fait avec la clause DROP VIEW suivie du nom de la vue que l’on veut supprimer. Ci-
après la syntaxe de suppression d'une vue : DROP VIEW NomDeLaVue ;
Exemples :
DROP View ListeDesDirections ; DROP View ListeDesServicesDelaDG ;

Page 7 sur 8