Programmation Des BD Avec MySQL

CYCLE DE FORMATION : LICENCE PRO
PROGRAMMATION DES BASES

DE DONNÉES AVEC MYSQL
SUPPORT DE COURS
M. Eric Vekout, M. Ing., PMP, Prince2, PSM2

Programmation des BD avec MySql Eric Vekout, M. Ing.,
Table des matières

I. Introduction à la Programmation avec MySQL .................................................... 4
1. Présentation du langage SQL .............................................................................................. 4
2. Les opérations sur les bases de données ........................................................................... 4
3. Les opérations sur les tables ................................................................................................ 6
II. Les contraintes d’intégrité ..................................................................................... 9
1. La clé primaire ....................................................................................................................... 9
2. La clé étrangère ................................................................................................................... 10
III. Les opérations sur les données d’une table ..........................................................12
1. L’insertion des données d’une table ................................................................................. 12
2. La modification des données dans une table .................................................................. 12
3. La suppression des données dans une table ................................................................... 13
IV. Les jointures .........................................................................................................14
V. Les fonctions d’agrégation ...................................................................................16
VI. Les clauses group by et having.............................................................................17
VII. Les sous-requêtes ...........................................................................................19
VIII. Les fonctions ..................................................................................................21
IX. Les procédures stockées ...................................................................................... 23
X. Les déclencheurs ................................................................................................. 24
XI. Les transactions ................................................................................................... 26
Page 2 sur 27
Objectif général
L’objectif général de ce cours est de vous apprendre à utiliser le langage SQL pour manipuler
des données stockées dans des bases de données relationnelles.
Objectifs spécifiques
Les objectifs spécifiques de ce cours sont les suivant :
❖ Savoir utiliser le langage SQL pour créer, modifier, supprimer et interroger des tables
❖ Savoir utiliser les contraintes d’intégrité pour garantir la cohérence et la qualité des
données
❖ Savoir utiliser les jointures pour combiner les données de plusieurs tables
❖ Savoir utiliser les fonctions d’agrégation pour calculer des statistiques sur les données
❖ Savoir utiliser les clauses GROUP BY et HAVING pour réaliser des calculs sur des
groupes de lignes
Page 3 sur 27
I. Introduction à la Programmation avec MySQL

1. Présentation du langage SQL
Le langage SQL (Structured Query Language) est un langage de programmation qui
permet de manipuler des données stockées dans des bases de données relationnelles.
Une base de données relationnelle est un ensemble de tables, qui sont des structures
organisées en lignes (appelées enregistrements ou tuples) et en colonnes (appelées
attributs ou champs). Chaque table représente un type d’entité, par exemple une table
client contient les informations sur les clients, une table produit contient les
informations sur les produits, etc.
Le langage SQL permet de réaliser les opérations suivantes sur les tables :
❖ Créer une table avec la commande CREATE TABLE
❖ Modifier la structure d’une table avec la commande ALTER TABLE
❖ Supprimer une table avec la commande DROP TABLE
❖ Insérer des données dans une table avec la commande INSERT INTO
❖ Modifier des données dans une table avec la commande UPDATE
❖ Supprimer des données dans une table avec la commande DELETE FROM
❖ Interroger une table avec la commande SELECT
2. Les opérations sur les bases de données

a) Création d’une base de données
Une base de données est un ensemble de tables qui contiennent des données
structurées en lignes et en colonnes. Pour créer une base de données avec
MySQL, vous devez utiliser la commande CREATE DATABASE
nom_base_donnees;, où nom_base_donnees est le nom que vous voulez
donner à votre base de données. Par exemple, la commande suivante permet de
créer une base de données nommée magasin :
CREATE DATABASE magasin;
Vous pouvez vérifier que la base de données a bien été créée en utilisant la
commande SHOW DATABASES;, qui affiche la liste des bases de données
existantes :
Page 4 sur 27
SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| magasin |
| mysql |
| performance_schema |
| sys |
+--------------------+
b) Sélection d’une base de données

Pour utiliser la base de données que vous venez de créer, vous devez la
sélectionner avec la commande USE nom_base_donnees;, où
nom_base_donnees est le nom de la base de données que vous voulez utiliser.
Par exemple, la commande suivante permet de sélectionner la base de données
magasin :
USE magasin;
Vous pouvez vérifier que la base de données est bien sélectionnée en utilisant la
commande SELECT DATABASE();, qui affiche le nom de la base de données
courante :
SELECT DATABASE();
+------------+
| DATABASE() |
+------------+
| magasin |
+------------+
c) Modification d’une base de données

Pour modifier la structure d’une base de données existante, vous devez utiliser
la commande ALTER DATABASE nom_base_donnees action;, où
nom_base_donnees est le nom de la base de données à modifier et action est
l’action à effectuer, par exemple RENAME TO nouveau_nom_base_donnees
pour renommer la base de données, CHARACTER SET charset pour changer
le jeu de caractères de la base de données, etc.
Page 5 sur 27
Par exemple, la commande suivante permet de renommer la base de données

magasin en boutique :
ALTER DATABASE magasin RENAME TO boutique;
d) Suppression d’une base de données

Pour supprimer une base de données existante, vous devez utiliser la commande
DROP DATABASE nom_base_donnees;, où nom_base_donnees est le nom
de la base de données à supprimer. Attention, cette commande supprime
également toutes les tables et les données contenues dans la base de données.
Par exemple, la commande suivante permet de supprimer la base de données
boutique :
DROP DATABASE boutique;
3. Les opérations sur les tables

a) Création d’une table
La commande CREATE TABLE permet de créer une nouvelle table dans la
base de données. La syntaxe générale est la suivante :
b)CREATE TABLE nom_table (
nom_colonne1 type_donnee1 [contraintes1],
nom_colonne2 type_donnee2 [contraintes2],
...
nom_colonneN type_donneeN [contraintesN]
);
❖ nom_table est le nom de la table à créer

❖ nom_colonne est le nom d’une colonne de la table
❖ type_donnee est le type de données de la colonne, par exemple INT pour
les nombres entiers, VARCHAR(n) pour les chaînes de caractères de
longueur maximale n, DATE pour les dates, etc.
❖ contraintes sont des règles qui s’appliquent aux valeurs de la colonne, par
exemple NOT NULL pour indiquer que la colonne ne peut pas être vide,
UNIQUE pour indiquer que la colonne ne peut pas contenir de
Page 6 sur 27
doublons, DEFAULT valeur pour indiquer la valeur par défaut de la

colonne, etc.
Par exemple, la commande suivante permet de créer une table client avec les
colonnes id, nom, prenom, email et date_naissance :
CREATE TABLE client (
id INT NOT NULL,
nom VARCHAR(50) NOT NULL,
prenom VARCHAR(50) NOT NULL,
email VARCHAR(100) UNIQUE,
date_naissance DATE
);
b) Modification d’une table

La commande ALTER TABLE permet de modifier la structure d’une table
existante. La syntaxe générale est la suivante :
ALTER TABLE nom_table action;
❖ nom_table est le nom de la table à modifier

❖ action est l’action à effectuer, par exemple ADD nom_colonne
type_donnee [contraintes] pour ajouter une nouvelle colonne, DROP
nom_colonne pour supprimer une colonne, RENAME TO
nouveau_nom_table pour renommer la table, etc.
Par exemple, la commande suivante permet d’ajouter une colonne adresse à la
table client :
ALTER TABLE client ADD adresse VARCHAR(200);
c) Suppression d’une table

La commande DROP TABLE permet de supprimer une table existante de la
base de données. La syntaxe générale est la suivante :
DROP TABLE nom_table;
Page 7 sur 27
❖ nom_table est le nom de la table à supprimer

Par exemple, la commande suivante permet de supprimer la table client :
DROP TABLE client;
d) Interrogation d’une table

La commande SELECT permet d’interroger une table et de récupérer les
données qui répondent à des critères spécifiés. La syntaxe générale est la suivante
:
SELECT nom_colonne1, nom_colonne2, ... nom_colonneN
FROM nom_table
[WHERE condition]
[ORDER BY nom_colonne [ASC|DESC]]
[LIMIT nombre];
❖ nom_colonne est le nom d’une colonne de la table ou * pour sélectionner

toutes les colonnes
❖ nom_table est le nom de la table à interroger
❖ condition est une expression logique qui filtre les lignes de la table, par
exemple nom_colonne = valeur pour sélectionner les lignes où la
colonne a une valeur donnée, nom_colonne1 < nom_colonne2 pour
sélectionner les lignes où la première colonne est inférieure à la deuxième,
etc. On peut combiner plusieurs conditions avec les opérateurs logiques
AND, OR et NOT.
❖ ORDER BY nom_colonne [ASC|DESC] permet de trier les résultats
par ordre croissant (ASC) ou décroissant (DESC) selon la valeur d’une
colonne
❖ LIMIT nombre permet de limiter le nombre de résultats à afficher
Par exemple, la commande suivante permet de sélectionner les noms, prénoms
et emails des clients nés après le 1er janvier 2000 et de les trier par ordre
alphabétique :
Page 8 sur 27
SELECT nom, prenom, email

FROM client
WHERE date_naissance > '2000-01-01'
ORDER BY nom ASC, prenom ASC;
II. Les contraintes d’intégrité

Les contraintes d’intégrité sont des règles qui garantissent la cohérence et la qualité des
données dans la base de données. Il existe deux types de contraintes d’intégrité :
❖ Les contraintes d’intégrité intra-relationnelles, qui s’appliquent à une seule table,
par exemple la contrainte NOT NULL qui interdit les valeurs vides, la contrainte
UNIQUE qui interdit les doublons, la contrainte CHECK qui impose une
condition sur les valeurs d’une colonne, etc.
❖ Les contraintes d’intégrité inter-relationnelles, qui s’appliquent à plusieurs tables,
par exemple la contrainte de clé primaire, qui identifie de manière unique chaque
ligne d’une table, la contrainte de clé étrangère, qui établit une relation entre deux
tables, la contrainte de référence, qui impose que la valeur d’une clé étrangère
corresponde à la valeur d’une clé primaire dans une autre table, etc.
1. La clé primaire
La clé primaire est une colonne ou un ensemble de colonnes qui permettent d’identifier
de manière unique chaque ligne d’une table. Une table ne peut avoir qu’une seule clé
primaire, qui doit respecter les conditions suivantes :
❖ La clé primaire ne peut pas être vide (NOT NULL)
❖ La clé primaire ne peut pas contenir de doublons (UNIQUE)
❖ La clé primaire ne peut pas être modifiée (CONSTRAINT)
La syntaxe pour définir une clé primaire est la suivante :
CREATE TABLE nom_table (
...
nom_colonne type_donnee [contraintes],
...
PRIMARY KEY (nom_colonne)
);
nom_colonne est le nom de la colonne qui constitue la clé primaire.
Page 9 sur 27
Si la clé primaire est composée de plusieurs colonnes, on les sépare par des virgules :
...
nom_colonne1 type_donnee [contraintes],
nom_colonne2 type_donnee [contraintes],
...
PRIMARY KEY (nom_colonne1, nom_colonne2)
);
Par exemple, la commande suivante permet de créer une table produit avec une clé
primaire sur la colonne id :
CREATE TABLE produit (
id INT NOT NULL,
nom VARCHAR(50) NOT NULL,
prix DECIMAL(10,2) NOT NULL,
categorie VARCHAR(20),
PRIMARY KEY (id)
);
2. La clé étrangère
La clé étrangère est une colonne ou un ensemble de colonnes qui permettent d’établir
une relation entre deux tables. Une table peut avoir plusieurs clés étrangères, qui
doivent respecter les conditions suivantes :
❖ La clé étrangère doit correspondre à la clé primaire d’une autre table
(REFERENCES)
❖ La clé étrangère peut être vide (NULL)
❖ La clé étrangère peut contenir des doublons
❖ La clé étrangère peut être modifiée, mais il faut respecter la contrainte de
référence (ON UPDATE)
La syntaxe pour définir une clé étrangère est la suivante :
Page 10 sur 27

...
nom_colonne type_donnee [contraintes],
...
FOREIGN KEY (nom_colonne) REFERENCES nom_autre_table (nom_autre_colonne)
[ON UPDATE action]
[ON DELETE action]
);
❖ nom_colonne est le nom de la colonne qui constitue la clé étrangère

❖ nom_autre_table est le nom de l’autre table à laquelle la clé étrangère fait
référence
❖ nom_autre_colonne est le nom de la colonne de l’autre table qui constitue la clé
primaire
❖ ON UPDATE action est l’action à effectuer si la valeur de la clé primaire de
l’autre table est modifiée, par exemple CASCADE pour mettre à jour la valeur
de la clé étrangère en conséquence, SET NULL pour mettre la valeur de la clé
étrangère à NULL, NO ACTION pour interdire la modification de la clé
primaire, etc.
❖ ON DELETE action est l’action à effectuer si la ligne de la clé primaire de
l’autre table est supprimée, par exemple CASCADE pour supprimer la ligne de
la clé étrangère en conséquence, SET NULL pour mettre la valeur de la clé
étrangère à NULL, NO ACTION pour interdire la suppression de la clé
primaire, etc.
Par exemple, la commande suivante permet de créer une table commande avec une clé
étrangère sur la colonne id_client qui fait référence à la colonne id de la table client :
CREATE TABLE commande (
id INT NOT NULL,
date DATE NOT NULL,
montant DECIMAL(10,2) NOT NULL,
id_client INT,
PRIMARY KEY (id),
FOREIGN KEY (id_client) REFERENCES client (id)
ON UPDATE CASCADE
ON DELETE SET NULL
); Page 11 sur 27
III. Les opérations sur les données d’une table

1. L’insertion des données d’une table
L’insertion des données dans une table consiste à ajouter des lignes (appelées
enregistrements ou tuples) dans une table existante. Pour insérer des données dans une
table avec MySQL, vous devez utiliser la commande INSERT INTO nom_table
(nom_colonne1, nom_colonne2, ... nom_colonneN) VALUES (valeur1, valeur2, ...
valeurN);, où nom_table est le nom de la table dans laquelle vous voulez insérer les
données, nom_colonne est le nom d’une colonne de la table, et valeur est la valeur à
insérer dans la colonne. Vous pouvez insérer plusieurs lignes à la fois en séparant les
valeurs par des virgules.
Par exemple, la commande suivante permet d’insérer deux lignes dans la table client :
INSERT INTO client (id, nom, prenom, email, date_naissance) VALUES
(1, 'Atangana', 'Jean', 'jean.atango@email.com', '1990-01-01'),
(2, 'Ngo oum', 'Marie', 'marie.ngo@email.com', '1992-02-02');
Vous pouvez vérifier que les données ont bien été insérées en utilisant la commande
SELECT * FROM nom_table;, qui affiche toutes les lignes et toutes les colonnes de
la table :
SELECT * FROM client;
+----+--------+--------+----------------------+---------------+
| id | nom | prenom | email | date_naissance |
+----+--------+--------+----------------------+---------------+
| 1 | Atangana | Jean | jean.atango@email.com | 1990-01-01 |
| 2 | Ngo oum | Marie | marie.ngo@email.com | 1992-02-02 |
+----+--------+--------+----------------------+---------------+
2. La modification des données dans une table

La modification des données dans une table consiste à changer les valeurs d’une ou
plusieurs colonnes dans une ou plusieurs lignes d’une table existante. Pour modifier
des données dans une table avec MySQL, vous devez utiliser la commande UPDATE
nom_table SET nom_colonne1 = valeur1, nom_colonne2 = valeur2, ...
nom_colonneN = valeurN [WHERE condition];, où nom_table est le nom de la table
dans laquelle vous voulez modifier les données, nom_colonne est le nom d’une
colonne de la table, valeur est la nouvelle valeur à affecter à la colonne, et condition
Page 12 sur 27
est une expression logique qui filtre les lignes à modifier, par exemple nom_colonne =
valeur pour sélectionner les lignes où la colonne a une valeur donnée, nom_colonne1
< nom_colonne2 pour sélectionner les lignes où la première colonne est inférieure à
la deuxième, etc. On peut combiner plusieurs conditions avec les opérateurs logiques
AND, OR et NOT. Si vous ne spécifiez pas de condition, la commande modifie toutes
les lignes de la table.
Par exemple, la commande suivante permet de modifier l’email du client dont l’id est
1:
UPDATE client SET email = 'jean.atango@newemail.com' WHERE id = 1;
Vous pouvez vérifier que les données ont bien été modifiées en utilisant la commande
la table :
+----+--------+--------+----------------------+---------------+
+----+--------+--------+----------------------+---------------+
| 1 | Atangana | Jean | jean.atango@newemail.com | 1990-01-01 |
| 2 | Ngo oum | Marie | marie.ngo@email.com | 1992-02-02 |
+----+--------+--------+----------------------+---------------+
3. La suppression des données dans une table

La suppression des données dans une table consiste à supprimer une ou plusieurs lignes
d’une table existante. Pour supprimer des données dans une table avec MySQL, vous
devez utiliser la commande DELETE FROM nom_table [WHERE condition];, où
nom_table est le nom de la table dans laquelle vous voulez supprimer les données, et
condition est une expression logique qui filtre les lignes à supprimer, par exemple
nom_colonne = valeur pour sélectionner les lignes où la colonne a une valeur donnée,
nom_colonne1 < nom_colonne2 pour sélectionner les lignes où la première colonne
est inférieure à la deuxième, etc. On peut combiner plusieurs conditions avec les
opérateurs logiques AND, OR et NOT. Si vous ne spécifiez pas de condition, la
commande supprime toutes les lignes de la table.
Par exemple, la commande suivante permet de supprimer le client dont l’id est 2 :
Page 13 sur 27
DELETE FROM client WHERE id = 2;
Vous pouvez vérifier que les données ont bien été supprimées en utilisant la commande
la table :
+----+--------+--------+----------------------+---------------+
+----+--------+--------+----------------------+---------------+
| 1 | Atangana | Jean | jean.atango@newemail.com | 1990-01-01 |
+----+--------+--------+----------------------+---------------+
IV. Les jointures

Les jointures sont des opérations qui permettent de combiner les données de plusieurs
tables en fonction d’une condition de correspondance entre les colonnes. Il existe
différents types de jointures, qui diffèrent par la manière dont ils gèrent les lignes qui
n’ont pas de correspondance dans l’autre table. Les principaux types de jointures sont :
❖ La jointure interne (INNER JOIN), qui ne conserve que les lignes qui ont une
correspondance dans les deux tables
❖ La jointure externe gauche (LEFT JOIN), qui conserve toutes les lignes de la
table de gauche et les lignes correspondantes de la table de droite, en mettant à
NULL les valeurs manquantes
❖ La jointure externe droite (RIGHT JOIN), qui conserve toutes les lignes de la
table de droite et les lignes correspondantes de la table de gauche, en mettant à
NULL les valeurs manquantes
❖ La jointure externe complète (FULL JOIN), qui conserve toutes les lignes des
deux tables, en mettant à NULL les valeurs manquantes
❖ La jointure naturelle (NATURAL JOIN), qui effectue une jointure interne sur les
colonnes qui ont le même nom dans les deux tables
❖ La jointure croisée (CROSS JOIN), qui produit le produit cartésien des deux
tables, c’est-à-dire toutes les combinaisons possibles de lignes
La syntaxe pour effectuer une jointure est la suivante :
Page 14 sur 27

FROM nom_table1
[type_de_jointure] nom_table2
[ON condition | USING (nom_colonne)]
[WHERE condition]
[LIMIT nombre];
❖ nom_colonne est le nom d’une colonne de l’une des tables ou * pour sélectionner
toutes les colonnes
❖ nom_table1 et nom_table2 sont les noms des tables à joindre
❖ type_de_jointure est le type de jointure à effectuer, par exemple INNER JOIN,
LEFT JOIN, etc.
❖ ON condition est la condition de correspondance entre les colonnes des deux
tables, par exemple nom_table1.nom_colonne = nom_table2.nom_colonne
❖ USING (nom_colonne) est une alternative à ON condition qui permet de
spécifier le nom d’une colonne commune aux deux tables
❖ WHERE condition est une expression logique qui filtre les lignes du résultat de
la jointure, par exemple nom_colonne = valeur pour sélectionner les lignes où la
colonne a une valeur donnée, nom_colonne1 < nom_colonne2 pour sélectionner
les lignes où la première colonne est inférieure à la deuxième, etc. On peut
combiner plusieurs conditions avec les opérateurs logiques AND, OR et NOT.
❖ ORDER BY nom_colonne [ASC|DESC] permet de trier les résultats par ordre
croissant (ASC) ou décroissant (DESC) selon la valeur d’une colonne
Par exemple, la commande suivante permet de sélectionner les noms, prénoms et emails
des clients qui ont passé au moins une commande, ainsi que le montant total de leurs
commandes :
SELECT client.nom, client.prenom, client.email, SUM(commande.montant) AS total

FROM client
INNER JOIN commande
ON client.id = commande.id_client
GROUP BY client.id, client.nom, client.prenom, client.email
Page 15 sur 27
ORDER BY total DESC;
V. Les fonctions d’agrégation

Les fonctions d’agrégation sont des fonctions qui permettent de calculer des statistiques
sur les données d’une table ou d’un groupe de lignes. Il existe plusieurs fonctions
d’agrégation, qui diffèrent par le type de calcul qu’elles effectuent. Les principales
fonctions d’agrégation sont :
❖ La fonction SUM qui calcule la somme des valeurs d’une colonne numérique
❖ La fonction COUNT qui calcule le nombre de lignes ou de valeurs distinctes
d’une colonne
❖ La fonction AVG qui calcule la moyenne des valeurs d’une colonne numérique
❖ La fonction MIN qui calcule la valeur minimale d’une colonne
❖ La fonction MAX qui calcule la valeur maximale d’une colonne
❖ La syntaxe pour utiliser une fonction d’agrégation est la suivante :
SELECT fonction_d_agregation (nom_colonne) [AS alias]
FROM nom_table
[WHERE condition]
[GROUP BY nom_colonne]
[HAVING condition]
[LIMIT nombre];
❖ fonction_d_agregation est le nom de la fonction d’agrégation à utiliser, par

exemple SUM, COUNT, etc.
❖ nom_colonne est le nom de la colonne sur laquelle appliquer la fonction
d’agrégation
❖ AS alias est une option qui permet de renommer le résultat de la fonction
d’agrégation, par exemple AS total
❖ WHERE condition est une expression logique qui filtre les lignes de la table, par
exemple nom_colonne = valeur pour sélectionner les lignes où la colonne a une
valeur donnée, nom_colonne1 < nom_colonne2 pour sélectionner les lignes où
Page 16 sur 27
la première colonne est inférieure à la deuxième, etc. On peut combiner

plusieurs conditions avec les opérateurs logiques AND, OR et NOT.
❖ GROUP BY nom_colonne permet de regrouper les lignes de la table selon la
valeur d’une colonne, et d’appliquer la fonction d’agrégation à chaque groupe
❖ HAVING condition est une expression logique qui filtre les groupes de lignes,
par exemple fonction_d_agregation (nom_colonne) > valeur pour sélectionner
les groupes dont le résultat de la fonction d’agrégation est supérieur à une valeur
donnée, etc. On peut combiner plusieurs conditions avec les opérateurs logiques
AND, OR et NOT.
Par exemple, la commande suivante permet de calculer le montant total des
commandes passées par le magasin :
SELECT SUM(montant) AS total
FROM commande;
VI. Les clauses group by et having

Les clauses GROUP BY et HAVING sont des clauses qui permettent de réaliser des
calculs statistiques sur des groupes de lignes. La clause GROUP BY permet de regrouper
les lignes de la table selon la valeur d’une ou plusieurs colonnes, et d’appliquer une
fonction d’agrégation à chaque groupe. La clause HAVING permet de filtrer les groupes
de lignes selon une condition qui porte sur le résultat de la fonction d’agrégation.
La syntaxe pour utiliser les clauses GROUP BY et HAVING est la suivante :
SELECT nom_colonne1, nom_colonne2, ... nom_colonneN, fonction_d_agregation

(nom_colonne) [AS alias]
FROM nom_table
[WHERE condition]
GROUP BY nom_colonne1, nom_colonne2, ... nom_colonneN
[HAVING condition]
[LIMIT nombre];
Page 17 sur 27
❖ nom_colonne est le nom d’une colonne de la table ou * pour sélectionner toutes

les colonnes
❖ fonction_d_agregation est le nom de la fonction d’agrégation à utiliser, par
exemple SUM, COUNT, etc.
❖ AS alias est une option qui permet de renommer le résultat de la fonction
d’agrégation, par exemple AS total
❖ WHERE condition est une expression logique qui filtre les lignes de la table, par
exemple nom_colonne = valeur pour sélectionner les lignes où la colonne a une
valeur donnée, nom_colonne1 < nom_colonne2 pour sélectionner les lignes où
la première colonne est inférieure à la deuxième, etc. On peut combiner
plusieurs conditions avec les opérateurs logiques AND, OR et NOT.
❖ GROUP BY nom_colonne1, nom_colonne2, ... nom_colonneN permet de
regrouper les lignes de la table selon la valeur d’une ou plusieurs colonnes, et
d’appliquer la fonction d’agrégation à chaque groupe
AND, OR et NOT.
Par exemple, la commande suivante permet de calculer le nombre de produits
commandés par catégorie, et de n’afficher que les catégories dont le nombre de
produits est supérieur à 10 :
SELECT produit.categorie, COUNT(detail_commande.id_produit) AS nombre_produits
FROM produit
INNER JOIN detail_commande
ON produit.id = detail_commande.id_produit
GROUP BY produit.categorie
HAVING nombre_produits > 10
ORDER BY nombre_produits DESC;
Page 18 sur 27
VII. Les sous-requêtes

Une sous-requête est une requête SQL qui est imbriquée dans une autre requête SQL.
Elle peut être utilisée dans différentes parties d’une requête principale, par exemple
dans la clause SELECT, FROM, WHERE, HAVING, etc. Elle présente aussi d’autres
caractéristiques :
❖ Une sous-requête peut renvoyer un seul résultat, une seule ligne, une seule
colonne ou plusieurs lignes et colonnes.
❖ Une sous-requête peut être dépendante ou indépendante de la requête
principale.
❖ Une sous-requête dépendante fait référence à des éléments de la requête
principale, tandis qu’une sous-requête indépendante ne le fait pas.
La syntaxe pour utiliser une sous-requête est la suivante :
FROM nom_table1
[WHERE condition]
[HAVING condition]
[LIMIT nombre]
[OPERATEUR (SELECT nom_colonne
FROM nom_table2
[WHERE condition]
[HAVING condition]
[LIMIT nombre])];
❖ nom_colonne est le nom d’une colonne de l’une des tables ou * pour

sélectionner toutes les colonnes
❖ nom_table1 et nom_table2 sont les noms des tables à interroger
❖ condition est une expression logique qui filtre les lignes de la table, par exemple
nom_colonne = valeur pour sélectionner les lignes où la colonne a une valeur
donnée, nom_colonne1 < nom_colonne2 pour sélectionner les lignes où la
Page 19 sur 27
première colonne est inférieure à la deuxième, etc. On peut combiner plusieurs

conditions avec les opérateurs logiques AND, OR et NOT.
❖ GROUP BY nom_colonne permet de regrouper les lignes de la table selon la
valeur d’une colonne, et d’appliquer une fonction d’agrégation à chaque groupe
AND, OR et NOT.
❖ OPERATEUR est un opérateur qui compare le résultat de la requête principale
avec le résultat de la sous-requête, par exemple =, <>, <, >, IN, NOT IN,
EXISTS, NOT EXISTS, ANY, ALL, etc.
Par exemple, la requête suivante permet de sélectionner les noms et les prénoms des
clients qui ont commandé le produit le plus cher :
SELECT client.nom, client.prenom
FROM client
INNER JOIN commande
ON client.id = commande.id_client
ON commande.id = detail_commande.id_commande
WHERE detail_commande.id_produit = (SELECT id
FROM produit
ORDER BY prix DESC
LIMIT 1);
Les sous-requêtes présentent des avantages et des inconvénients par rapport aux
requêtes simples ou aux jointures. Voici quelques-uns de ces avantages et
inconvénients :
Les avantages des sous-requêtes sont :
Page 20 sur 27
❖ Elles permettent d’écrire des requêtes plus complexes et plus flexibles, en

utilisant des résultats intermédiaires.
❖ Elles permettent d’éviter la duplication des données, en utilisant une seule fois
une table dans la sous-requête.
❖ Elles permettent d’améliorer la lisibilité et la compréhension des requêtes, en
séparant les différentes étapes du calcul.
Les inconvénients des sous-requêtes sont :
❖ Elles peuvent réduire les performances des requêtes, en augmentant le nombre
d’opérations et le temps d’exécution
❖ Elles peuvent être difficiles à écrire et à déboguer, en nécessitant une bonne
maîtrise de la syntaxe et de la logique SQL
❖ Elles peuvent être limitées par les capacités du système de gestion de bases de
données, en ne supportant pas certains types de sous-requêtes ou en imposant
des restrictions sur leur utilisation
VIII. Les fonctions

Une fonction est un bloc de code qui prend des paramètres en entrée, effectue des
opérations sur ces paramètres, et renvoie un résultat en sortie. Elle peut être utilisée
pour encapsuler une logique complexe, réutiliser du code, ou simplifier une requête
SQL.
Pour créer une fonction avec MySQL, vous devez utiliser la commande CREATE
FUNCTION nom_fonction (parametre1 type1, parametre2 type2, ... parametreN
typeN) RETURNS type_retour [DETERMINISTIC | NOT DETERMINISTIC]
[CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA]
BEGIN ... END;,
❖ nom_fonction est le nom que vous voulez donner à votre fonction,
❖ parametre est le nom d’un paramètre d’entrée,
❖ type est le type de données du paramètre ou du résultat,
❖ DETERMINISTIC ou NOT DETERMINISTIC indique si la fonction renvoie
toujours le même résultat pour les mêmes paramètres,
❖ CONTAINS SQL, NO SQL, READS SQL DATA ou MODIFIES SQL
DATA indique le type d’accès aux données que la fonction effectue,
Page 21 sur 27
❖ BEGIN ... END est le bloc de code qui contient la logique de la fonction.
Par exemple, la fonction suivante permet de calculer le prix TTC (toutes taxes
comprises) d’un produit à partir de son prix HT (hors taxes) et du taux de TVA (taxe
sur la valeur ajoutée) :
CREATE FUNCTION prix_ttc (prix_ht DECIMAL(10,2), taux_tva DECIMAL(4,2))
RETURNS DECIMAL(10,2) DETERMINISTIC READS SQL DATA
BEGIN
DECLARE prix_ttc DECIMAL(10,2);
SET prix_ttc = prix_ht * (1 + taux_tva / 100);
RETURN prix_ttc;
END;
Pour utiliser une fonction que vous avez créée, vous devez l’appeler avec le nom de la
fonction et les paramètres entre parenthèses, comme si c’était une fonction intégrée à
MySQL. Par exemple, la commande suivante permet d’utiliser la fonction prix_ttc pour
afficher le nom et le prix TTC des produits :
SELECT produit.nom, prix_ttc(produit.prix, 20) AS prix_ttc
FROM produit;
Les fonctions présentent des avantages et des inconvénients par rapport aux requêtes
simples ou aux procédures stockées.
Les avantages des fonctions sont :
❖ Elles permettent d’écrire des requêtes plus simples et plus lisibles, en utilisant des noms
de fonctions explicites
❖ Elles permettent de réduire la duplication du code, en utilisant une seule fois une
fonction dans plusieurs requêtes
❖ Elles permettent de modulariser le code, en séparant les différentes étapes du calcul
Les inconvénients des fonctions sont :
d’appels et le temps d’exécution.
❖ Elles peuvent être difficiles à écrire et à déboguer, en nécessitant une bonne
maîtrise de la syntaxe et de la logique SQL.
Page 22 sur 27
❖ Elles peuvent être limitées par les capacités du système de gestion de bases de
données, en ne supportant pas certains types de fonctions ou en imposant des
restrictions sur leur utilisation.
IX. Les procédures stockées

Une procédure stockée est un bloc de code qui peut être exécuté à la demande, et qui
peut prendre des paramètres en entrée et en sortie, effectuer des opérations sur les
données, et renvoyer des résultats ou des messages. Elle peut être utilisée pour
automatiser des tâches répétitives, simplifier la logique complexe, ou améliorer la
sécurité et la performance des requêtes SQL.
Pour créer une procédure stockée avec MySQL, vous devez utiliser la commande
CREATE PROCEDURE nom_procedure ([IN|OUT|INOUT] parametre1 type1,
[IN|OUT|INOUT] parametre2 type2, ... [IN|OUT|INOUT] parametreN typeN)
[DETERMINISTIC | NOT DETERMINISTIC] [CONTAINS SQL | NO SQL |
READS SQL DATA | MODIFIES SQL DATA] BEGIN ... END;, où
❖ nom_procedure est le nom que vous voulez donner à votre procédure stockée,
❖ IN, OUT ou INOUT indique le mode du paramètre, c’est-à-dire s’il s’agit d’un
paramètre d’entrée, de sortie ou des deux,
❖ parametre est le nom d’un paramètre,
❖ type est le type de données du paramètre,
❖ DETERMINISTIC ou NOT DETERMINISTIC indique si la procédure renvoie
toujours le même résultat pour les mêmes paramètres,
❖ CONTAINS SQL, NO SQL, READS SQL DATA ou MODIFIES SQL DATA
indique le type d’accès aux données que la procédure effectue,
❖ BEGIN ... END est le bloc de code qui contient la logique de la procédure.
Par exemple, la procédure stockée suivante permet de calculer le montant total des
commandes passées par un client donné :
CREATE PROCEDURE total_commandes (IN id_client INT, OUT total DECIMAL(10,2))
DETERMINISTIC READS SQL DATA
BEGIN
SELECT SUM(montant) INTO total
FROM commande
WHERE id_client = id_client;
END;
Page 23 sur 27
Pour utiliser une procédure stockée que vous avez créée, vous devez l’appeler avec la
commande CALL nom_procedure (parametre1, parametre2, ... parametreN);, où
nom_procedure est le nom de la procédure stockée et parametre est la valeur ou la
variable à passer en paramètre. Par exemple, la commande suivante permet d’appeler la
procédure total_commandes pour le client dont l’id est 1, et d’afficher le résultat :
CALL total_commandes (1, @total);
SELECT @total AS total;
Les procédures stockées présentent des avantages et des inconvénients par rapport aux
requêtes simples ou aux fonctions.
Les avantages des procédures stockées sont :
❖ Elles permettent d’améliorer les performances des requêtes, en réduisant le
nombre d’appels et le temps de compilation
❖ Elles permettent d’améliorer la sécurité des données, en limitant l’accès et les
permissions aux utilisateurs autorisés
❖ Elles permettent d’implémenter une logique complexe, en utilisant des structures
de contrôle, des variables, des boucles, des exceptions, etc.
Les inconvénients des procédures stockées sont :
❖ Elles peuvent augmenter la complexité et la maintenance du code, en nécessitant
une bonne documentation et une bonne organisation
❖ Elles peuvent réduire la portabilité et l’interopérabilité du code, en dépendant du
système de gestion de bases de données utilisé
❖ Elles peuvent introduire des risques d’erreurs ou d’incohérences, en modifiant les
données sans contrôle de version ou de transaction
X. Les déclencheurs
Un déclencheur est un bloc de code qui s’exécute automatiquement lorsqu’un
événement se produit sur une table, par exemple une insertion, une modification ou une
suppression de données. Il peut être utilisé pour effectuer des actions complémentaires,
vérifier des contraintes, enregistrer des historiques, etc.
Pour créer un déclencheur avec MySQL, vous devez utiliser la commande CREATE
TRIGGER nom_declencheur [BEFORE | AFTER] [INSERT | UPDATE |
DELETE] ON nom_table FOR EACH ROW BEGIN ... END;, où
Page 24 sur 27
❖ nom_declencheur est le nom que vous voulez donner à votre déclencheur,

❖ BEFORE ou AFTER indique si le déclencheur s’exécute avant ou après
l’événement,
❖ INSERT, UPDATE ou DELETE indique le type d’événement qui déclenche le
déclencheur,
❖ nom_table est le nom de la table sur laquelle le déclencheur s’applique,
❖ BEGIN ... END est le bloc de code qui contient la logique du déclencheur.
Par exemple, le déclencheur suivant permet de mettre à jour le montant d’une
commande après l’insertion ou la modification d’un détail de commande :
CREATE TRIGGER maj_montant AFTER INSERT OR UPDATE ON detail_commande FOR EACH
ROW
BEGIN
UPDATE commande
SET montant = (SELECT SUM(produit.prix * detail_commande.quantite)
FROM produit
ON produit.id = detail_commande.id_produit
WHERE detail_commande.id_commande = NEW.id_commande)
WHERE id = NEW.id_commande;
END;
Pour utiliser un déclencheur que vous avez créé, vous n’avez pas besoin de l’appeler
explicitement, car il s’exécute automatiquement lors de l’événement spécifié. Par
exemple, si vous insérez ou modifiez un détail de commande, le déclencheur
maj_montant s’exécute et met à jour le montant de la commande correspondante.
Les déclencheurs présentent des avantages et des inconvénients par rapport aux
requêtes simples ou aux procédures stockées.
Les avantages des déclencheurs sont :
❖ Ils permettent d’automatiser des actions, en les exécutant sans intervention
humaine
❖ Ils permettent de garantir l’intégrité des données, en vérifiant des contraintes ou
en corrigeant des erreurs
Page 25 sur 27
❖ Ils permettent de tracer les modifications des données, en enregistrant des

historiques ou des logs
Les inconvénients des déclencheurs sont :
❖ Ils peuvent réduire les performances des requêtes, en augmentant le nombre
❖ Ils peuvent augmenter la complexité et la maintenance du code, en nécessitant
❖ Ils peuvent introduire des risques d’erreurs ou d’incohérences, en modifiant les
données de manière invisible ou imprévisible
XI. Les transactions

Une transaction est un ensemble d’opérations sur les données qui sont exécutées comme
une unité logique, c’est-à-dire que soit toutes les opérations réussissent, soit aucune n’est
appliquée. Elle permet de garantir la cohérence et la fiabilité des données, en respectant
les propriétés ACID (Atomicité, Cohérence, Isolation, Durabilité).
Pour créer une transaction avec MySQL, vous devez utiliser les commandes START
TRANSACTION;, COMMIT; et ROLLBACK;, qui permettent respectivement de
démarrer, de valider et d’annuler une transaction.
Par exemple, la transaction suivante permet de transférer 100 euros du compte 1 au
compte 2 :
START TRANSACTION;
UPDATE compte SET solde = solde - 100 WHERE id = 1;
UPDATE compte SET solde = solde + 100 WHERE id = 2;
COMMIT;
Si une erreur se produit pendant la transaction, vous pouvez utiliser la commande

ROLLBACK; pour annuler les modifications effectuées par la transaction :
START TRANSACTION;
UPDATE compte SET solde = solde - 100 WHERE id = 1;
UPDATE compte SET solde = solde + 100 WHERE id = 2;
-- Une erreur se produit ici
ROLLBACK;
Page 26 sur 27
Les transactions présentent des avantages et des inconvénients par rapport aux
requêtes simples ou aux procédures stockées.
Les avantages des transactions sont :
❖ Elles permettent de garantir la cohérence et la fiabilité des données, en
respectant les propriétés ACID
❖ Elles permettent de gérer les erreurs et les exceptions, en annulant les
modifications en cas de problème
❖ Elles permettent de contrôler le niveau d’isolation, en définissant le degré de
visibilité des modifications entre les transactions concurrentes
Les inconvénients des transactions sont :
❖ Elles peuvent augmenter la complexité et la maintenance du code, en nécessitant
❖ Elles peuvent introduire des risques de blocage ou de conflit, en verrouillant les
données pendant la durée de la transaction
Page 27 sur 27

Programmation Des BD Avec MySQL

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation Des BD Avec MySQL

Transféré par

Droits d'auteur :

Formats disponibles

CYCLE DE FORMATION : LICENCE PRO

PROGRAMMATION DES BASES

M. Eric Vekout, M. Ing., PMP, Prince2, PSM2

Table des matières

I. Introduction à la Programmation avec MySQL

2. Les opérations sur les bases de données

CREATE DATABASE magasin;

b) Sélection d’une base de données

c) Modification d’une base de données

Par exemple, la commande suivante permet de renommer la base de données

d) Suppression d’une base de données

3. Les opérations sur les tables

❖ nom_table est le nom de la table à créer

doublons, DEFAULT valeur pour indiquer la valeur par défaut de la

b) Modification d’une table

❖ nom_table est le nom de la table à modifier

c) Suppression d’une table

❖ nom_table est le nom de la table à supprimer

d) Interrogation d’une table

❖ nom_colonne est le nom d’une colonne de la table ou * pour sélectionner

SELECT nom, prenom, email

II. Les contraintes d’intégrité

nom_colonne est le nom de la colonne qui constitue la clé primaire.

CREATE TABLE nom_table (

❖ nom_colonne est le nom de la colonne qui constitue la clé étrangère

III. Les opérations sur les données d’une table

2. La modification des données dans une table

3. La suppression des données dans une table

DELETE FROM client WHERE id = 2;

IV. Les jointures

SELECT nom_colonne1, nom_colonne2, ... nom_colonneN

SELECT client.nom, client.prenom, client.email, SUM(commande.montant) AS total

V. Les fonctions d’agrégation

❖ fonction_d_agregation est le nom de la fonction d’agrégation à utiliser, par

la première colonne est inférieure à la deuxième, etc. On peut combiner

VI. Les clauses group by et having

SELECT nom_colonne1, nom_colonne2, ... nom_colonneN, fonction_d_agregation

❖ nom_colonne est le nom d’une colonne de la table ou * pour sélectionner toutes

VII. Les sous-requêtes

❖ nom_colonne est le nom d’une colonne de l’une des tables ou * pour

première colonne est inférieure à la deuxième, etc. On peut combiner plusieurs

❖ Elles permettent d’écrire des requêtes plus complexes et plus flexibles, en

VIII. Les fonctions

IX. Les procédures stockées

❖ nom_declencheur est le nom que vous voulez donner à votre déclencheur,

❖ Ils permettent de tracer les modifications des données, en enregistrant des

XI. Les transactions

Si une erreur se produit pendant la transaction, vous pouvez utiliser la commande

Vous aimerez peut-être aussi