Partie théorique

Pourquoi ce module?

1

Le module BDD (Base de données) est une suite logique du module SI(Systèmes d’information) étudiés en S3.

La ou dans SI tout était sur papier, ce module nous permettra d’appliquer sur machines et de programmer nos bases de données; ce qui deviendra nécessaire pour plus tard lorsqu’on créera un logiciel assez conséquent ou bien des sites Web dynamiques (Projet de fin d’étude par exemple).

On se basera sur les derniers chapitres étudiés, le MCD et le MLD-R.

Définition d'une base de données

2

Une BDD est un moyen de stockage de données ordonné et structuré permettant de facilement
accéder, modifier, mettre à jour, et supprimer toute données d’une manière simple et optimisée
en se servant d’un SGBD pour toute opération.

Définition d’un SGBD

3

Un système de Gestion de Base de Données est un logiciel qui fait office de lien entre la BDD et
toute application s’en servant; Il gère toutes modifications sur les données.
Il permet donc de créer, modifier et contrôler l'accès au BDD.

Pourquoi utiliser une BDD au lieu de fichiers

4

Avant les BDD, et encore aujourd’hui dans certains cas, le stockage à base de fichiers est utilisé.
Plusieurs problèmes apparaissent en utilisant ce système, dont:
La décentralisation:
ou chaque application crée ses propres fichiers pour stocker ses données, une application volumineuse aura donc un nombre
très conséquent de fichiers.
La Redondance:
si chaque application a ses propres fichiers, et que ces applications sont liées, plusieurs données seront dupliquées, L’espace
de stockage deviendra limité et le programme sera non-optimisé.
La Dépendance Logique et Physique:
Pour mettre à jour notre système(pour modifier une donnée par exemple) il devient nécessaire de parcourir tous les fichiers un à un pour
modifier toute occurrence de cette donnée.
La BDD corrige tous ces problèmes et ça en transformant toutes les données en une seule
collection logiquement liée et seulement accessible et modifiable par un SGBD (Système de gestion de base de données);
Les applications utilisant ces données enverront alors des requêtes au SGBD qui se chargera des modifications nécessaires.
Comparé au système à base de fichiers, les BDD permettent de stocker plusieurs fichiers de
taille relativement large de façon sécurisée, tout en permettant à plusieurs applications et utilisateurs d’y accéder en même temps.

Architecture de la BDD

5

Une BDD est composée de 3 niveaux:

Niveau Externe:

Ce niveau est composé de plusieurs vues, qui sont une visualisation unique des données fournies par le SGBD uniques pour chaque utilisateurs; Il permet donc à chaque application/utilisateur d’exploiter les données pour afficher les relations nécessaires.
Il est donc possible de modifier les données dans ce niveau pour changer la vue de l’utilisateur, mais ces changements n’affectent pas le reste des niveaux.

Niveau Conceptuel:

Ce niveau permet une vue globale de toutes les données stockées dans la BDD, et comment ces données sont inter-reliées, tout en définissant la structure de chaque utilisateur; Seuls les administrateurs (DBA) peuvent accéder et modifier ce niveau.

Niveau Interne:

Ce niveau définit comment les données sont représentées sur le stockage Physique(Ordinateur, Serveur); il est donc dépendant du Hardware utilisé.
Cette architecture permet une séparation entre utilisateurs et admins qui simplifie la modération et l'accès aux données.

Modèle Relationnel

6

Un modèle Relationnel est une méthode de modélisation des données basée sur les concepts mathématiques de relations.

Ce modèle permet l’indépendance des données, ainsi qu’une sémantique et une cohérence entre elles tout en évitant la redondance.

Éléments du modèle

7

Une relation dans un modèle relationnel est une table composée de lignes et de colonnes.
Une base de données est donc un ensemble de tables/relations.

Un attribut:

Aussi appelé Colonne ou champ , est la colonne d’une relation, caractérisée par un nom.

Un Domaine:

Un domaine est l’ensemble des valeurs possibles pour 1 ou plusieurs attributs.

Un tuple:

Ou bien enregistrement, est la ligne d’une relation.

Degré/Cardinalité:

Le Degré est le nombre de colonnes dans la relation.
Ainsi, une relation a 1 attribut sera nommée unaire, a 2 attributs binaire, 3 ternaire, et toute autre relation a attributs>3 sera nommée n-aire.

La Cardinalité d’une relation est le nombre de tuples présent dans la relation(nombres de lignes).
La cardinalité n’est donc pas statique, et change au fur et à mesure que la relation se modifie.

Propriétés des Relations

8

*Chaque relation doit avoir un nom unique.
*Chaque attribut a un nom distinct et doit contenir une valeur atomique.
*Toutes valeurs d’un attribut doivent appartenir au même domaine.
*Chaque ligne d’une relation est distincte, aucune ligne doit être en double.
Pour pouvoir appliquer ces propriétés, le concept de clés a été introduit.

Superclé:
Une Superclé est un attribut, ou bien un ensemble d’attributs, permettant d’identifier de manière unique les lignes d’une relation.
Les superclés peuvent contenir d’autres attributs non nécessaires à l’identification des tuples.

Clé Candidate:

Une clé candidate est une superclé irréductible, autrement, tous les attributs de la clé candidate sont nécessaire pour l’identification;
- Si on prend un sous-ensemble d’attributs de la clé candidate, il est impossible de déterminer nos tuples
*Plusieurs clés Candidates peuvent exister dans une relation.
*Si cette clé est composée de plusieurs attributs, elle sera nommée Clé Composée.

Clé Primaire:

La clé primaire est une clé candidate choisie pour identifier les tuples de la relation.
Une seule clé primaire existe par relation.
La clé primaire est nécessaire dans une relation.

Clé étrangère:

La clé étrangère est un attribut ou ensemble d’attributs dans une relation servant comme clé candidate ou primaire dans une autre relation.
La clé étrangère est donc le lien entre les relations.
Il est impossible d’insérer une valeur dans la clé étrangère tant qu’elle existe pas dans sa relation originale.
Pour plus d’exemples et d’explications, veuillez vous référer à la partie pratique du Résumé.

Partie Pratique

Apprendre le SQL

1

Le SQL (Structured Query Language) est un langage permettant de communiquer avec une base
de données.

MySQL

2

MySQL est un SGBDR (System de Gestion de bases de donnes Relationnel), qui utilise le langage SQL.

Dans ce résumé nous allons traiter les principales commandes SQL telles que: SELECT, INSERT INTO, UPDATE, DELETE, DROP TABL, etc... . De plus nous allons voir quelques fonctions SQL telles que : AVG (), COUNT (), MAX (), etc...

SHOW

3

Show est utilisé pour afficher des informations sur une base de données

 SHOW DATABASES ;

Pour afficher toutes les Bases de données qui existent dans notre SGBDR.

SHOW Tables

4

Pour afficher toutes les tables qui existent dans notre Base de données.

 mysql> show tables;
+---------------------------+
| Tables_in_cabinet_medical |
+---------------------------+
| consultation              |
| medecin                   |
| medicament                |
| patient                   |
| prescrire                 |
+---------------------------+
5 rows in set (0.51 sec)

Show CREATE Table Name_table ;

5

Pour afficher les instructions de la création de la table.

mysql> show create table medecin;
+--------------------+
| Table   | Create Table|
+---------+----------+
| medecin | CREATE TABLE `medecin` (
  `MatMed` int NOT NULL,
  `NomMed` varchar(30) NOT NULL,
  `PreMed` varchar(30) NOT NULL,
  `SpeMed` varchar(30) NOT NULL,
  `AdrMed` text,
  `TelMed` int DEFAULT NULL,
  PRIMARY KEY (`MatMed`),
  UNIQUE KEY `TelMed` (`TelMed`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci |
+---------+-------------------------+
1 row in set (2.61 sec)

Show Columns From Name_table;

6

Pour afficher la description de la table.

 mysql> show columns from medecin;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| MatMed | int         | NO   | PRI | NULL    |       |
| NomMed | varchar(30) | NO   |     | NULL    |       |
| PreMed | varchar(30) | NO   |     | NULL    |       |
| SpeMed | varchar(30) | NO   |     | NULL    |       |
| AdrMed | text        | YES  |     | NULL    |       |
| TelMed | int         | YES  | UNI | NULL    |       |
+--------+-------------+------+-----+---------+-------+
6 rows in set (1.12 sec)

note : on peut remplacer

 Show Columns From

par

 DESC

 mysql> desc medicament;
+-----------+------+------+-----+---------+-------+
| Field     | Type | Null | Key | Default | Extra |
+-----------+------+------+-----+---------+-------+
| codeMedic | int  | NO   | PRI | NULL    |       |
| LIbMedic  | text | YES  |     | NULL    |       |
+-----------+------+------+-----+---------+-------+
2 rows in set (0.28 sec)

CREATE

7

CREATE est utilisée pour créer des objets dans une base de données en SQL.

 CREATE DATABASE Name_DB;

Exemple:

CREATE DATABASE tp1 ;

 CREATE TABLE Name_table (....);

 mysql> create table hotel(
    -> numhotel int,
    -> nomhotel varchar(30),
    -> ville varchar(30)
    -> );
Query OK, 0 rows affected (0.17 sec)

USE

8

Use est utilisée pour sélectionner une base de données existante

 USE Name_BDD ;

Exemple:

  USE tp1 ;

mysql> use store;
Database changed

SELECT

9

Select est considérée comme un afficheur (printf), on peut afficher avec une chaine ou le résultat d’une équation mathématique, et généralement on l’utilise pour afficher nos tables dans une BDD.

Afficher une chaine:

mysql> select "hello sinjab!";
+---------------+
| hello sinjab! |
+---------------+
| hello sinjab! |
+---------------+
1 row in set (0.00 sec)

Afficher une équation:

mysql> select 5+5+6+9+8+9+(5*8);
+-------------------+
| 5+5+6+9+8+9+(5*8) |
+-------------------+
|                82 |
+-------------------+
1 row in set (0.04 sec)

Dans le cas d'affichage d'un tableau:
Pour afficher les colonnes souhaitées seulement:

  SELECT nom_column1,nom_column2  FROM Nom_Table;

mysql> select numhotel from hotel;
+----------+
| numhotel |
+----------+
|       13 |
|       14 |
|      118 |
|      185 |
|     1887 |
|    18198 |
+----------+
6 rows in set (0.08 sec)

Sinon si on veut afficher toute la table on peut utiliser (*) à la place des noms de la colonne :

  SELECT * FROM hotel;

mysql> select * from hotel;
+----------+-----------+-----------+
| numhotel | nomhotel  | ville     |
+----------+-----------+-----------+
|       18 | El amine  | Boumerdes |
|       12 | El Badre  | Boumerdes |
|       13 | Salim     | alger     |
|       14 | AZ        | Alger     |
|      185 | Jumia     | Chine     |
|    18198 | Parisien  | paris     |
|     1468 |           | Boumerdes |
|     1887 | Hamadach  | tlemcen   |
|      118 | abdelAziz | tlemcen   |
+----------+-----------+-----------+
9 rows in set (0.00 sec)

Aussi si on veut préciser notre recherche dans la table nous allons utiliser WHERE
Exemple :

 SELECT * FROM hotel WHERE nomhotel = ‘AZ’;

mysql> SELECT * FROM hotel WHERE nomhotel = 'AZ';
+----------+----------+-------+
| numhotel | nomhotel | ville |
+----------+----------+-------+
|       14 | AZ       | Alger |
+----------+----------+-------+
1 row in set (0.04 sec)

Si nous voulons sélectionner tous les lignes qui contiennent un alphabet précis nous allons
utiliser le mot clé LIKE a la place de =, et le % aussi :

 SELECT * FROM hotel WHERE nomhotel LIKE '%A%';

% on le lit :
%A% : quelque soit + A + quelque soit ;(un mot qui contient 'a')

mysql> SELECT * FROM hotel WHERE nomhotel LIKE '%a%';
+----------+-----------+-----------+
| numhotel | nomhotel  | ville     |
+----------+-----------+-----------+
|       18 | El amine  | Boumerdes |
|       12 | El Badre  | Boumerdes |
|       13 | Salim     | alger     |
|       14 | AZ        | Alger     |
|      185 | Jumia     | Chine     |
|    18198 | Parisien  | paris     |
|     1887 | Hamadach  | tlemcen   |
|      118 | abdelAziz | tlemcen   |
+----------+-----------+-----------+
8 rows in set (0.07 sec)

A% : A + quelque soit ;(un mot qui débute par 'a')

mysql> SELECT * FROM hotel WHERE nomhotel LIKE 'a%';
+----------+-----------+---------+
| numhotel | nomhotel  | ville   |
+----------+-----------+---------+
|       14 | AZ        | Alger   |
|      118 | abdelAziz | tlemcen |
+----------+-----------+---------+
2 rows in set (0.00 sec)

%A : quelque soit + A ;(un mot qui se termine par 'a')

mysql> SELECT * FROM hotel WHERE nomhotel LIKE '%a';
+----------+----------+-------+
| numhotel | nomhotel | ville |
+----------+----------+-------+
|      185 | Jumia    | Chine |
+----------+----------+-------+
1 row in set (0.00 sec)

INSERT

10

Insert est utilisé pour ajouter des éléments dans une table, pour cela on utilise :

INSERT INTO Name_Table VALUES (valeur1, valeur2...);

mysql> insert into hotel values (13,"Salim","alger");
Query OK, 1 row affected (0.07 sec)

ALTER

11

Alter est un mot clé pour modifier la conception de la table elle-même, il suffit juste d’écrire :

 Alter Table Name_table [mot clé] instruction;

Nous avons dans le mot clé : drop et add qu’on va utiliser pour supprimer ou ajouter des instructions. Exemple:
Si on veut ajouter une Colonne Nombre Etoile on doit utiliser la syntaxe suivante:

 ALTER TABLE Name_table ADD COLUMN Name_column Type_column;

mysql> alter table hotel add column etoile int ;
Query OK, 0 rows affected (2.24 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> select * from hotel;
+----------+-----------+-----------+--------+
| numhotel | nomhotel  | ville     | etoile |
+----------+-----------+-----------+--------+
|       18 | El amine  | Boumerdes |   NULL |
|       12 | El Badre  | Boumerdes |   NULL |
|       13 | Salim     | alger     |   NULL |
|       14 | AZ        | Alger     |   NULL |
|      185 | Jumia     | Chine     |   NULL |
|    18198 | Parisien  | paris     |   NULL |
|     1468 |           | Boumerdes |   NULL |
|     1887 | Hamadach  | tlemcen   |   NULL |
|      118 | abdelAziz | tlemcen   |   NULL |
+----------+-----------+-----------+--------+
9 rows in set (0.00 sec)

Exemple si on a oublié de définir une clé primaire a notre table donc pas de panique, nous pouvant la définir avec ALTER comme suite :

ALTER TABLE Name_table ADD PRIMARY KEY (Select_Column);

mysql> alter table hotel add primary key (numhotel);
Query OK, 0 rows affected (3.76 sec)
Records: 0  Duplicates: 0  Warnings: 0

Et comme nous le remarquons, notre table a maintenant une clé primaire :

mysql> desc hotel;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| numhotel | int         | NO   | PRI | NULL    |       |
| nomhotel | varchar(30) | YES  |     | NULL    |       |
| ville    | varchar(30) | YES  |     | NULL    |       |
| etoile   | int         | YES  |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+
4 rows in set (0.56 sec)

On peut aussi utiliser Drop au lieu de ADD pour supprimer quelque chose dans notre table :

 ALTER TABLE Name_table DROP COLUMN Name_column;

mysql> alter table hotel drop column etoile;
Query OK, 0 rows affected (0.47 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> select * from hotel;
+----------+-----------+-----------+
| numhotel | nomhotel  | ville     |
+----------+-----------+-----------+
|       12 | El Badre  | Boumerdes |
|       13 | Salim     | alger     |
|       14 | AZ        | Alger     |
|       18 | El amine  | Boumerdes |
|      118 | abdelAziz | tlemcen   |
|      185 | Jumia     | Chine     |
|     1468 |           | Boumerdes |
|     1887 | Hamadach  | tlemcen   |
|    18198 | Parisien  | paris     |
+----------+-----------+-----------+
9 rows in set (0.00 sec)

UPDATE

12

La syntaxe est comme suit :
Update permet de modifier une instance d’une table, on peut changer le nom ou prénom et même les deux selon ce dont on a besoin. La syntaxe est comme suit :

 Update name_table SET column_1='valeur1',column_2='valeur2' WHERE condition

mysql> select * from hotel;
+----------+-----------+-----------+
| numhotel | nomhotel  | ville     |
+----------+-----------+-----------+
|       12 | El Badre  | Boumerdes |
|       13 | Salim     | alger     |
|       14 | AZ        | Alger     |
|       18 | El amine  | Boumerdes |
|      118 | abdelAziz | tlemcen   |
|      185 | Jumia     | Chine     |
|     1468 |           | Boumerdes |
|     1887 | Hamadach  | tlemcen   |
|    18198 | Parisien  | paris     |
+----------+-----------+-----------+
9 rows in set (0.00 sec)

mysql> update hotel set nomhotel='sinjab-hotel' where numhotel = 14 ;
Query OK, 1 row affected (0.18 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from hotel;
+----------+--------------+-----------+
| numhotel | nomhotel     | ville     |
+----------+--------------+-----------+
|       12 | El Badre     | Boumerdes |
|       13 | Salim        | alger     |
|       14 | sinjab-hotel | Alger     |
|       18 | El amine     | Boumerdes |
|      118 | abdelAziz    | tlemcen   |
|      185 | Jumia        | Chine     |
|     1468 |              | Boumerdes |
|     1887 | Hamadach     | tlemcen   |
|    18198 | Parisien     | paris     |
+----------+--------------+-----------+
9 rows in set (0.00 sec)

DELETE

13

Delete est une commande pour supprimer une ou plusieurs lignes (selon la condition) dans une table SQL.
La requête s’écrit comme ça :

DELETE FROM name_table WHERE condition;

mysql> delete from hotel where ville='boumerdes';
Query OK, 3 rows affected (1.20 sec)

mysql> select * from hotel;
+----------+--------------+---------+
| numhotel | nomhotel     | ville   |
+----------+--------------+---------+
|       13 | Salim        | alger   |
|       14 | sinjab-hotel | Alger   |
|      118 | abdelAziz    | tlemcen |
|      185 | Jumia        | Chine   |
|     1887 | Hamadach     | tlemcen |
|    18198 | Parisien     | paris   |
+----------+--------------+---------+
6 rows in set (0.00 sec)

DROP

14

On utilise DROP pour supprimer un objet (Table, BDD, View...) ;

DROP table name_table;

 Drop database name_BDD;

mysql> drop table hotel_1;
Query OK, 0 rows affected (2.90 sec)

Primary Key

15

On a 3 styles pour déclarer une clé primaire ( Primary key )

La 1ére:

mysql> create table hotel_1(
    -> numhotel int PRIMARY KEY,
    -> nomhotel varchar(30),
    -> ville char(20)
    -> );
Query OK, 0 rows affected (2.04 sec)

Le 2ème:

mysql> create table hotel_2(
    -> numhotel int,
    -> nomhotel varchar(30),
    -> ville char(20),
    -> PRIMARY KEY (numhotel)
    -> );
Query OK, 0 rows affected (1.54 sec)

Le 3ème:

mysql> create table hotel_3(
    -> numhotel int,
    -> nomhotel varchar(30),
    -> ville char(20),
    -> CONSTRAINT pk_numhotel PRIMARY KEY (numhotel)
    -> );
Query OK, 0 rows affected (0.30 sec)

Et les trois font exactement le même travail, personnellement je préfère la première.
Note : Pour les clés composées on peut utiliser que le 2eme et 3eme style d’écriture.

Clé composé:

Supposons que l'on veuille faire la composition du ( nom + le numero d’hotel ) comme clé primaire, alors nous allons l’écrire comme suit :

mysql> create table hotel_4(
    -> numhotel int,
    -> nomhotel varchar(30),
    -> ville char(20),
    -> PRIMARY KEY (numhotel,nomhotel)
    -> );
Query OK, 0 rows affected (0.30 sec)

FOREIGN KEY

16

Pour la clé étrangère, comme on le sait, elle est une clé qui vient d’une autre table.

Sa syntaxe s’écrit comme suit :

Et pour mieux comprendre la syntaxe on peut le lire comme ça :
numhotel de la table chambre devient une référence de Numhotel de la table hotel

mysql> create table chambre(
    -> Numchambre int,
    -> numhotel int,
    -> FOREIGN KEY (numhotel) REFERENCES hotel (Numhotel)
    -> );
Query OK, 0 rows affected (1.85 sec)