Langage SQL

LANGAGE SQL
SQL signifie langage de requête structuré (Structured Query Language). SQL est
un langage de programmation standard spécialement conçu pour stocker, extraire,
gérer ou manipuler les données à l'intérieur d'un système de gestion de bases de
données relationnelles (SGBDR). SQL est devenu une norme ISO en 1987.
SQL est le langage de base de données le plus largement mis en œuvre et soutenu
par les systèmes de base de données relationnelles populaires,
comme MySQL, SQL Server, et Oracle. Cependant, certaines fonctionnalités de la
norme SQL sont implémentées différemment dans différents systèmes de bases de
données.
SQL a été développé à l'origine par IBM au début des années 1970. Initialement, il
s’appelait SEQUEL (Structured English Query Language), qui a ensuite été remplacé
par SQL
 Ce que vous pouvez faire avec SQL
Il y a beaucoup de choses que vous pouvez faire avec SQL:
 Créer une base de données.
 Créer des tables dans une base de données.
 Interroger ou demander des informations à partir d'une base de données.
 Insérer des enregistrements dans une base de données.
 Mettre à jour ou modifier des enregistrements dans une base de données.
 Supprimer des enregistrements de la base de données.
 Définir les permissions ou le contrôle d'accès dans la base de données pour la
sécurité des données.
 Créer des vues pour éviter de taper des requêtes complexes fréquemment
utilisées.
La liste ne se termine pas ici, vous pouvez effectuer de nombreuses autres tâches
liées à la base de données avec SQL. Vous en apprendrez plus sur chacune d'elles
en détail dans les prochains cours.
 Objectifs
Cette série de cours SQL couvre tous les concepts fondamentaux du langage SQL,
tels que la création de bases de données et de tables, l'utilisation de contraintes,
l'ajout d'enregistrements à une table, la sélection d'enregistrements à partir d'une
table basée sur des conditions différentes, la mise à jour et la suppression
d'enregistrements dans une table, et ainsi de suite.
Une fois que vous êtes familiarisé avec les bases, vous passerez au niveau suivant
qui expliquent les méthodes de récupération des enregistrements en rejoignant
plusieurs tables, la recherche des enregistrements dans la table basée sur le
modèle, etc.
Enfin, vous explorerez quelques concepts avancés, tels que la modification de la
structure de la table existante, effectuer des agrégations et regrouper des données,
créer des vues pour simplifier et sécuriser l'accès à la table, créer des index pour les
tables, Gérer les dates et les heures, cloner une table existante, créer des tables
temporaires, ainsi que le concept de sous-séries SQL et L'injection SQL.
INTRODUCTION
SQL est un langage pour exploiter des bases de données; elle inclut la création, la
suppression, l'extraction de lignes, la modification de lignes, etc. de bases de
données. SQL est un langage standard ANSI (American National Standards
Institute), mais il existe de nombreuses versions différentes du langage SQL.
 Qu'est-ce que le SQL?
SQL est un langage de requête structuré, qui est un langage informatique permettant
de stocker, manipuler et récupérer des données stockées dans une base de
données relationnelle.
SQL est la langue standard pour les systèmes de base de données relationnelle.
Tous les systèmes de gestion de base de données relationnelle (SGBDR) tels
que MySQL, MS Access, Oracle, Sybase, Informix, Postgres et SQL
Server utilisent SQL comme langage de base de données standard.
 Pourquoi SQL ?
SQL est très populaire car il offre les avantages suivants:
 Permet aux utilisateurs d'accéder aux données des systèmes de gestion de base
de données relationnelle.
 Permet aux utilisateurs de décrire les données.
 Permet aux utilisateurs de définir les données dans une base de données et de
les manipuler.
 Permet d'intégrer dans d'autres langages en utilisant des modules SQL, des
bibliothèques et des pré-compilateurs.
 Permet aux utilisateurs de créer et de supprimer des bases de données et des
tables.
 Permet aux utilisateurs de créer une vue, une procédure stockée et des fonctions
dans une base de données.
 Permet aux utilisateurs de définir des autorisations sur les tables, les procédures
et les vues.
 Processus SQL
Le traitement des requêtes inclut des traductions sur des requêtes de haut niveau en
expressions de bas niveau pouvant être utilisées au niveau physique du système de
fichiers, une optimisation de la requête et une exécution réelle de la requête pour
obtenir le résultat réel.
Le schéma fonctionnel du traitement des requêtes est le suivant:
Cela se fait dans les étapes suivantes:
 Etape 1
Analyseur - lors de l'appel d'analyse, la base de données effectue les contrôles
suivants: contrôle de syntaxe, contrôle sémantique et contrôle de pool partagé, après
conversion de la requête en algèbre relationnelle.
Analyse dure et analyse douce - S'il y a une nouvelle requête et que son code de
hachage n'existe pas dans le pool partagé, cette requête doit passer par les étapes
supplémentaires connues sous le nom d'analyse dure. Sinon, si le code de hachage
existe, la requête ne passe pas par des étapes supplémentaires. . Il passe
directement au moteur d’exécution (voir schéma). Ceci est appelé analyse douce.
L'analyse dure comprend les étapes suivantes - optimiseur et génération de sources
de lignes.
 Etape 2
Optimiseur - au cours de la phase d'optimisation, la base de données doit effectuer
une analyse syntaxique stricte au moins pour une instruction LMD unique et effectuer
une optimisation au cours de cette analyse. Cette base de données n'optimise jamais
la LDD à moins d'inclure un composant LMD, tel qu'une sous-requête, qui nécessite
une optimisation.
Il s'agit d'un processus dans lequel plusieurs plans d'exécution de requêtes pour
satisfaire une requête sont examinés et le plan de requêtes le plus efficace est
satisfait pour son exécution. Le catalogue de base de données stocke les plans
d'exécution, puis l'optimiseur transmet le plan d'exécution le moins coûteux.
Génération de source en ligne - Est un logiciel qui reçoit un plan d’exécution
optimal de l’optimiseur et génère un plan d’exécution itératif utilisable par le reste de
la base de données. le plan itératif est le programme binaire qui, lorsqu'il est exécuté
par le moteur SQL, produit le résultat.
 Etape 3
Moteur d'exécution - Exécute enfin la requête et affiche le résultat souhaité.
 Commandes SQL
Les commandes SQL standard pour interagir avec les bases de données
relationnelles sont CREATE, SELECT, INSERT, UPDATE, DELETE et DROP. Ces
commandes peuvent être classées dans les groupes suivants en fonction de leur
nature : Langage de définition de données(LDD), Langage de manipulation de
données (LMD), Langage de contrôle de données (LCD).
LDD - Langage de définition de données

Commande Description
CREATE Crée une nouvelle table, une vue d’une table ou un autre objet de la base de données.
ALTER Modifie un objet de base de données existant, tel qu'une table.
DROP Supprime une table entière, une vue d'une table ou d'autres objets de la base de données.
LMD - Langage de manipulation de données
SELECT Récupère certains enregistrements d'une ou de plusieurs tables.
INSERT Crée un enregistrement.
UPDATE Modifie les enregistrements.
DELETE Supprime les enregistrements.
LCD - Langage de contrôle de données

GRANT Donne un privilège à l'utilisateur.
REVOKE Reprend les privilèges accordés par l'utilisateur.
Nous reviendrons sur toutes ces commandes en détail dans les prochains cours
CONCEPTS DE BASE DE SGBDR
Un système de gestion de base de données relationnelle (SGBDR) est un système

de gestion de base de données basé sur le modèle relationnel introduit par E.F
Codd. Dans le modèle relationnel, les données sont stockées dans des relations
(tables) et sont représentées sous la forme de nuplets (lignes).
Le SGBDR est utilisé pour gérer la base de données relationnelle. Une base de
données relationnelle est une collection d'un ensemble organisé de tables liées les
unes aux autres et à partir desquelles il est facile d'accéder aux données. La base de
données relationnelle est la base de données la plus utilisée de nos jours.
Le SGBDR est la base de SQL et de tous les systèmes de base de données
modernes tels que MS SQL Server, IBM DB2, Oracle, MySQL et Microsoft Access.
 Concepts de base de SGBDR

 Qu'est-ce qu'une table ?
Dans le modèle de base de données relationnelle, une table est un ensemble
d'éléments de données organisés en lignes et en colonnes. Un tableau est
également considéré comme une représentation commode des relations. Mais une
table peut avoir une ligne de données en double alors qu'une relation vraie ne peut
pas avoir de données en double. La table est la forme la plus simple de stockage de
données.
Vous trouverez ci-dessous un exemple de table d'employes.
 Qu'est-ce qu'un tuple ?

Une seule entrée dans une table est appelée un tuple ou un enregistrement ou une
ligne. Un tuple dans une table représente un ensemble de données liées. Par
exemple, la table des employes ci-dessus a 4 n-uplets/enregistrements/lignes.
Voici un exemple d'enregistrement simple ou de tuple.
 Qu'est-ce qu'un attribut ?
Une table est constituée de plusieurs enregistrements (lignes), chaque
enregistrement pouvant être décomposé en plusieurs parties de données plus petites
appelées attributs. La table des employés ci-dessus comprend quatre attributs, ID,
Nom, Age et Salaire.
Domaine d'attribut
Lorsqu'un attribut est défini dans une relation (table), il est défini pour ne contenir
qu'un certain type de valeurs, appelé domaine d'attribut.
Par conséquent, l'attribut Nom contiendra le nom de l'employé pour chaque tuple. Si
nous sauvegardons l'adresse de l'employé ici, ce sera une violation du modèle de
base de données relationnelle.
 Quel est le schéma de relation ?
Un schéma de relation décrit la structure de la relation, avec le nom de la relation
(nom de la table), ses attributs, leurs noms et leur type.
 Qu'est-ce qu'une clé de relation?
Une clé de relation est un attribut qui peut identifier de manière unique un tuple
(ligne) particulier dans une relation (table).
 Contraintes d'intégrité relationnelle

Chaque relation dans un modèle de base de données relationnelle doit respecter ou
suivre quelques contraintes pour être une relation valide. Ces contraintes sont
appelées contraintes d'intégrité relationnelle.
Les trois principales contraintes d'intégrité sont :
 Contraintes de clé
 Contraintes de domaine
 Contraintes d'intégrité référentielle
a) Contraintes de clé
Nous stockons les données dans des tableaux, pour y accéder plus tard lorsque cela
est nécessaire. Dans chaque tableau, un ou plusieurs attributs sont utilisées pour
récupérer les données des tableaux. La contrainte clé spécifie qu'il doit y avoir un tel
attribut (colonne) dans une relation (table), qui peut être utilisé pour récupérer des
données pour n'importe quel tuple (ligne).
L'attribut clé ne doit jamais être NULL ou identique pour deux lignes de données
différentes.
Par exemple, dans la table des employés, nous pouvons utiliser l'attribut Id pour
extraire des données pour chacun des employés. Aucune valeur de Id n'est nulle et
elle est unique pour chaque ligne. Il peut donc s'agir de notre attribut clé.
b) Contraintes de domaine
Les contraintes de domaine font référence aux règles définies pour les valeurs
pouvant être stockées pour un certain attribut.
Comme nous l'avons expliqué ci-dessus, nous ne pouvons pas enregistrer l'adresse
de l'employé dans la colonne Nom.
De même, un numéro de téléphone mobile ne peut pas dépasser 10 chiffres.
c) Contraintes d'intégrité référentielle
Les lignes ne peuvent pas être supprimées, si elles sont utilisées par d'autres
enregistrements.
Si une table fait référence à des données d'une autre table, cette table et ces
données doivent être présentes pour que la contrainte d'intégrité référentielle soit
vérifiée.
Nous étudierons cela en détail plus tard.
 Normalisation de la base de données
La normalisation de base de données est le processus d’organisation efficace des
données dans une base de données. Ce processus de normalisation a deux raisons
 Éliminer les données redondantes, par exemple, stocker les mêmes données dans
plusieurs tables.
 S'assurer que les dépendances de données ont un sens.
Ces deux raisons sont des objectifs valables, car elles réduisent la quantité d'espace
utilisée par une base de données et garantissent que les données sont stockées de
manière logique.
La normalisation consiste en une série de directives qui vous aideront à créer une
bonne structure de base de données.
Les directives de normalisation sont divisées en formes normales. Le but des formes
normales est d’organiser la structure de la base de données, de sorte qu’elle
respecte les règles de la première forme normale, puis de la deuxième forme
normale et enfin de la troisième forme normale.
C'est votre choix d'aller plus loin et d'aller à la quatrième forme normale, cinquième
forme normale, etc., mais en général, la troisième forme normale est plus que
suffisant.
Nous parlerons plus tard en détail de ces formes normales
SYNTAXES DE DIFFERENTES INSTRUCTIONS SQL
SQL est suivi d'un ensemble unique de règles et de directives appelé syntaxe. Ce
cours vous permet de démarrer rapidement avec SQL en listant toute la syntaxe SQL
de base.
Toutes les instructions SQL commencent par l'un des mots clés tels que SELECT,
INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW et toutes les
instructions se terminent par un point-virgule (;).
Le point le plus important à noter ici est que SQL est insensible à la casse, ce qui
signifie que SELECT et select ont la même signification dans les instructions SQL.
Alors que MySQL fait la différence dans les noms de table. Donc, si vous travaillez
avec MySQL, vous devez donner les noms de table tels qu’ils existent dans la base
de données.
 Instruction SELECT
1 SELECT colonne1, colonne2 ... colonneN
2 FROM nom_table;
Clause DISTINCT
SELECT DISTINCT colonne1, colonne2 ... colonneN
1 FROM nom_table;
2
Clause WHERE
SELECT colonne1, colonne2 ... colonneN
1 FROM nom_table
2
WHERE CONDITION;
3
Clause AND/OR
SELECT colonne1, colonne2 ... colonneN
1 FROM nom_table
2
WHERE CONDITION-1 {AND|OR} CONDITION-2;
3
Clause IN
2 FROM nom_table
3 WHERE nom_colonne IN (val-1, val-2,...val-N);
Clause BETWEEN
2 FROM nom_table
3 WHERE nom_colonne BETWEEN val-1 AND val-2;
Clause LIKE
2 FROM nom_table
3 WHERE nom_colonne LIKE { PATTERN };
Clause ORDER BY
2 FROM nom_table
3 WHERE CONDITION
4 ORDER BY nom_colonne {ASC|DESC};
Clause GROUP BY
1 SELECT SUM(nom_colonne)
2 FROM nom_table
3 WHERE CONDITION
4 GROUP BY nom_colonne;
Clause COUNT
1 SELECT COUNT(nom_colonne)
2 FROM nom_table
3 WHERE CONDITION;
Clause HAVING
1 SELECT SUM(nom_colonne)
2 FROM nom_table
3 WHERE CONDITION
4 GROUP BY nom_colonne
5 HAVING (condition de la fonction arithmétique);
 Instruction CREATE TABLE

1
CREATE TABLE nom_table(
2 colonne1 type_donnees,
5 .....
colonneN type_donnees,
6
PRIMARY KEY( une ou plusieurs colonnes )
7 );
8
 Instruction DROP TABLE
1 DROP TABLE nom_table;
 Instruction CREATE INDEX

1 CREATE UNIQUE INDEX nom_index
2 ON nom_table ( colonne1, colonne2,...colonneN);
 Instruction DROP INDEX

1 ALTER TABLE nom_table
2 DROP INDEX nom_index;
 Instruction DESC
1 DESC nom_table;
 Instruction TRUNCATE TABLE
1 TRUNCATE TABLE nom_table;
 Instruction ALTER TABLE

1 ALTER TABLE nom_table {ADD|DROP|MODIFY} nom_colonne {type_donnees};
 Instruction ALTER TABLE (rename)

1 ALTER TABLE nom_table RENAME TO nouveau_nom_table;
 Instruction INSERT INTO

1 INSERT INTO nom_table( colonne1, colonne2 ... colonneN)
2 VALUES ( valeur1, valeur2....valeurN);
 Instruction UPDATE
1 UPDATE nom_table
2 SET colonne1 = valeur1, colonne2 = valeur2....colonneN=valeurN
3 [ WHERE CONDITION ];
 Instruction DELETE
1 DELETE FROM nom_table
2 WHERE {CONDITION};
 Instruction CREATE DATABASE

1 CREATE DATABASE nom_bd;
 Instruction DROP DATABASE

1 DROP DATABASE nom_bd;
 Instruction USE
1 USE nom_bd;
 Instruction COMMIT
1 COMMIT;
 Instruction ROLLBACK
ROLLBACK;
1
Plus loin dans ce tutoriel, nous allons discuter chacune de ces instructions en
profondeur
OPERATEURS SQL
Un opérateur est un mot réservé ou un caractère utilisé principalement dans la

clause WHERE d'une instruction SQL pour effectuer des opérations, telles que des
comparaisons et des opérations arithmétiques. Ces opérateurs sont utilisés pour
spécifier des conditions dans une instruction SQL et pour servir de conjonctions pour
plusieurs conditions dans une instruction.
 Opérateurs arithmétiques
 Opérateurs de comparaison
 Opérateurs logiques
Opérateurs arithmétiques
Opérateur Description
+ (Addition) Ajoute des valeurs de chaque côté de l'opérateur.
- (Soustraction) Soustrait l'opérande droit de l'opérande gauche.
* (Multiplication) Multiplie les valeurs de chaque côté de l'opérateur.
/ (Division) Divise l'opérande gauche par l'opérande droit.
% (Reste de
Divise l'opérande gauche par l'opérande droit et renvoie le reste.
division)
Opérateurs de comparaison
Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, la condition
=
devient vraie.
Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas
!=
égales, alors la condition devient vraie.
Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas
<>
égales, alors la condition devient vraie.
Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande

>
droit. Si oui, la condition devient vraie.
Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande

<
droit. Si oui, la condition devient vraie.
Vérifie si la valeur de l'opérande de gauche est supérieure ou égale à la valeur de

>=
l'opérande de droite, si oui, la condition devient vraie.
Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de

<=
l'opérande droit. Si oui, la condition devient vraie.
Vérifie si la valeur de l'opérande gauche n'est pas inférieure à la valeur de

!<
l'opérande droit. Si la réponse est oui, la condition devient vraie.
Vérifie si la valeur de l'opérande de gauche n'est pas supérieure à la valeur de

!>
l'opérande de droite, si oui, la condition devient vraie.
Opérateurs logiques
L'opérateur ALL permet de comparer une valeur à toutes les valeurs d'un autre jeu de
ALL
valeurs.
L'opérateur ANY est utilisé pour comparer une valeur à une valeur applicable de la liste
ANY
conformément à la condition.
L'opérateur BETWEEN permet de rechercher des valeurs comprises dans un ensemble de

BETWEEN
valeurs, en fonction de la valeur minimale et de la valeur maximale.
L'opérateur EXISTS est utilisé pour rechercher la présence d'une ligne dans une table
EXISTS
spécifiée qui répond à un certain critère.
L'opérateur IN est utilisé pour comparer une valeur à une liste de valeurs littérales
IN
spécifiées.
L'opérateur LIKE est utilisé pour comparer une valeur à des valeurs similaires à l'aide
LIKE
d'opérateurs génériques.
L'opérateur NOT inverse la signification de l'opérateur logique avec lequel il est utilisé.
NOT
Ex.: NOT EXISTS, NOT BETWEEN, NOT IN, etc. Ceci est un opérateur de négation.
L'opérateur AND permet l'existence de plusieurs conditions dans la clause WHERE d'une
AND
instruction SQL.
L'opérateur OR est utilisé pour combiner plusieurs conditions dans la clause WHERE d'une
OR
instruction SQL.
IS NULL L'opérateur IS NULL est utilisé pour comparer une valeur avec une valeur NULL.
L'opérateur UNIQUE recherche dans chaque ligne de la table spécifiée l'unicité (pas de
UNIQUE
doublons).
CREATION ET SUPPRESSION D’UNE BASE DE DONNEES
 Création d'une base de données

L'instruction CREATE DATABASE est utilisée pour créer une nouvelle base de
données SQL.
Syntaxe :
1 CREATE DATABASE nomBDonnees;
Le nom de la base de données doit toujours être unique dans le SGBDR.

Exemple :
Si vous souhaitez créer une nouvelle base de données "devInfo",

l'instruction CREATE DATABASE sera comme ci-dessous.
1 CREATE DATABASE devInfo;
Assurez-vous de disposer du privilège administrateur avant de créer une base de

données.
Une fois la base de données créée, vous pouvez la vérifier comme suit dans la liste
des bases de données.
1 SHOW DATABASES;
 Supprimer une base de données

L'instruction DROP DATABASE est utilisée pour supprimer une base de données
existante dans un schéma SQL.
Syntaxe :
1 DROP DATABASE nomBDonnees;
Exemple :
Si vous souhaitez supprimer une base de données existante "devInfo",

l'instruction DROP DATABASE sera comme ci-dessous.
DROP DATABASE devInfo;

1
Attention! Soyez prudent avant d'utiliser cette opération, car la suppression d'une base de
données existante entraînerait la perte des informations complètes stockées dans la base de
données.
Assurez-vous de disposer du privilège administrateur avant de supprimer une base
de données. Une fois qu'une base de données est supprimée, vous pouvez la vérifier
dans la liste des bases de données, comme indiqué ci-dessous.
1 SHOW DATABASES;
Sélectionner une base de données

Lorsque vous avez plusieurs bases de données dans votre schéma SQL, avant de
commencer votre opération, vous devez sélectionner une base de données sur
laquelle toutes les opérations seront effectuées.
L'instruction USE permet de sélectionner une base de données existante dans le
schéma SQL.
Syntaxe :
1 USE nomBDonnees;
Exemple :
Si vous souhaitez utiliser la base de données "devInfo", vous pouvez exécuter la

commande SQL suivante et commencer à utiliser la base de données "devInfo".
1 USE devInfo;
TYPES DE DONNEES SQL
Les types de données sont utilisés pour représenter une nature de données pouvant
être stockée dans la base de données. Le type de données est l'ensemble des
valeurs représentables. Il est également connu sous le nom d'attribut qui spécifie un
type de données de l'objet. Chaque colonne, variable et expression à le type de
données associé dans le code SQL lors de la création de la table.
Points importants sur les types de données SQL
 Les fournisseurs de bases de données relationnelles ne prennent pas en charge tous les
types de données. Par exemple, la base de données Oracle ne prend pas en
charge DATETIME et MySQL ne prend pas en charge le type de données CLOB. Ainsi,
lors de la conception du schéma de base de données et de l'écriture des requêtes SQL,
assurez-vous de vérifier si les types de données sont pris en charge ou non.
 Les types de données listés ici n'incluent pas tous les types de données; Ce sont les
types de données les plus couramment utilisés. Certains fournisseurs de bases de
données relationnelles ont leurs types de données qui ne sont peut-être pas répertoriés
ici. Par exemple, Microsoft SQL Server comporte des types de données money et
smallmoney, mais étant donné que les autres fournisseurs de bases de données préférés
ne les prennent pas en charge, elles ne sont pas répertoriées ici.
 Chaque fournisseur de base de données relationnelle a sa taille maximale pour les
différents types de données et vous n'avez pas besoin de vous en rappeler. L'idée est de
savoir quel type de données utiliser dans un scénario spécifique.
Types de données SQL

Le développeur SQL doit décider du type de données à stocker dans chaque
colonne lors de la création de la table. Le type de données est le guide que SQL
utilise pour comprendre le type de données attendu dans chaque colonne. Il indique
également comment SQL interagira avec les données stockées.
Types de données SQL principalement classés en six catégories pour chaque base
de données.
 Types de données de chaînes
 Types de données numériques
 Date et heure
 Types de données binaires tels que binaire, varbinaire, etc.
 Types de données de chaîne de caractères Unicode tels que nchar, nvarchar,
ntext, etc.
 Autres types de données tels que clob, blob, XML, curseur, table, etc.
Types de données numériques
Type de données De A
bit 0 1
tinyint 0 255
smallint -32,768 32,767
int -2,147,483,648 2,147,483,647

Type de données De A
bigint -9,223,372,036,854,775,808 9,223,372,036,854,775,807
decimal -10^38 +1 10^38 -1
numeric -10^38 +1 10^38 -1
float -1.79E + 308 1.79E + 308
real -3.40E + 38 3.40E + 38
Types de données Date et Heure
Type de
Description
données
DATE Stocke la date dans le format YYYY-MM-DD
TIME Stocke l'heure dans le format HH:MI:SS
DATETIME Stocke les informations de date et heure au format YYYY-MM-DD HH:MI:SS
Stocke le nombre de secondes écoulées depuis l'époque Unix (Horodatage) (‘1970-01-

TIMESTAMP
01 00:00:00’ UTC)
Stocke l'année en format 2 chiffres ou 4 chiffres. Plage 1901 à 2155 en format à 4

YEAR
chiffres. Plage 70 à 69, représentant 1970 à 2069.
Types de données caractères et chaînes
Type de
Description
données
CHAR Longueur fixe avec une longueur maximale de 8 000 caractères
VARCHAR Stockage de longueur variable avec une longueur maximale de 8 000 caractères
Stockage à longueur variable avec le nombre maximum de caractères fourni, non pris
VARCHAR(max)
en charge dans MySQL
TEXT Le stockage de longueur variable avec une taille maximale de 2 Go de données

Types de données Unicode caractères et chaînes
Type de données Description
NCHAR Longueur fixe avec une longueur maximale de 4 000 caractères
NVARCHAR Stockage de longueur variable avec une longueur maximale de 4 000 caractères
NVARCHAR(max) Stockage de longueur variable avec max caractères fournis
NTEXT Stockage de longueur variable avec une taille maximale de 1 Go de données
Types de données binaires
BINARY Longueur fixe avec une longueur maximale de 8 000 octets
VARBINARY Stockage de longueur variable avec une longueur maximale de 8 000 octets
VARBINARY(max) Stockage de longueur variable avec le nombre max d'octets fournis
Stockage de longueur variable avec une taille maximale de 2 Go de données

IMAGE
binaires
Autres types de données
CLOB Grands objets de caractère pouvant contenir jusqu'à 2 Go
BLOB Pour les gros objets binaires
XML Pour stocker des données XML
JSON Pour stocker des données JSON

SGBDR MySQL
Types de données de chaînes
Il est utilisé pour spécifier une chaîne de longueur variable pouvant contenir des
Varchar(size) chiffres, des lettres et des caractères spéciaux. Sa taille "size" maximale est
comprise entre 0 et 65535 caractères.
Il est utilisé pour spécifier une chaîne de longueur fixe pouvant contenir des
Char(size) chiffres, des lettres et des caractères spéciaux. Par défaut, il peut contenir 1
caractère. Sa taille maximale est comprise entre 0 et 255 caractères.
Il est aussi similaire que VARCHAR (), et la seule différence est qu'il stocke des
VARBINARY(size)
chaînes d'octets binaires. Le paramètre size spécifie la colonne maximum en octets
Il est utilisé pour stocker des chaînes d'octets binaires. La valeur par défaut est 1 et
Binary(size)
son paramètre de taille spécifie la longueur de la colonne en octets.
TINYTEXT Il contient une chaîne avec une valeur maximale de 255 caractères.
Il est utilisé pour stocker une chaîne d'une longueur maximale de 255 caractères,
TEXT(size)
similaire à CHAR().
LONGTEXT Il contient une chaîne avec une valeur maximale de 4 294 967 295 caractères.
Il contient une chaîne avec une valeur maximale de 16 777 215 caractères, ce qui
MEDIUMTEXT
est assez plus grand que VARCHAR()
Il est utilisé lorsqu'un objet chaîne n'a qu'une seule valeur, choisie parmi une liste
de valeurs possibles. Vous pouvez répertorier jusqu'à 65 535 valeurs dans la
ENUM(val1,val2,….)
liste ENUM. Si une valeur est insérée, elle ne figure pas dans une liste et la valeur
vide sera insérée. Les valeurs sont triées dans l'ordre au moment de la saisie.
Il est utilisé pour spécifier la chaîne pouvant contenir 0 ou plusieurs valeurs,

SET(val1,val2,……) choisies dans une liste de valeurs possibles. En même temps, 64 valeurs peuvent
être listées.
BLOB(size) Il est utilisé pour les gros objets binaires pouvant contenir jusqu'à 65 535 octets.
Types de données numériques
Utilisé pour un type de valeur de bit. La taille (size) est utilisée pour spécifier le nombre
BIT(size)
de bits. La plage est de 1-64. Par défaut, la valeur est 1.
Utilisé pour la valeur entière. La plage est comprise entre -2147483648-2147483647. Le

INT(size)
paramètre size spécifie la largeur d'affichage maximale de 255.
INTEGER(size) Il est similaire à INT(size).
Utilisé pour un nombre à virgule flottante. Le paramètre size spécifie le nombre total
FLOAT(size,d)
de chiffres. d est utilisé pour définir le nombre chiffres après le point décimal.
Utilisé pour un nombre à virgule flottante et double. Si la valeur de p est comprise

Float(p) entre 0 et 24, les données deviennent flottantes et si la valeur de p est comprise entre
25 et 53, les données deviennent doubles.
DOUBLE(size,d) Il est similaire à FLOAT(size, d).
Utilisé pour spécifier un nombre à virgule fixe. La taille (size) de valeur maximale peut
DECIMAL(size,d) contenir 65, et par défaut, sa valeur sera 10 et d peut contenir une valeur maximale de
30, et par défaut, la valeur est 0.
Utilisé pour spécifier des valeurs booléennes. 0 est considéré comme faux et les valeurs
BOOL
non nulles restantes comme vraies.
Types de données Date et Heure
Type de
Description
données
Utilisé pour spécifier le format de date. Dans MySQL, le format est AAAA-MM-JJ. La
DATE
plage va de «1000-01-01» à «9999-12-31».
Utilisé pour spécifier la combinaison de date et heure. Le format est AAAA-MM-JJ hh:
DATETIME
mm: ss. La plage va de «1000-01-01 00:00:00» à «9999-12-31 23:59:59».
Utilisé pour spécifier l'horodatage. Le format est AAAA-MM-JJ hh: mm: ss. La plage prise
TIMESTAMP
en charge est «1970-01-01 00:00:01» UTC à «2038-01-09 03:14:07» UTC.
Utilisé pour spécifier le format de l'heure. Le format est hh: mm: ss. La plage va de «-
TIME
838: 59: 59» à «838: 59: 59».
Utilisé pour spécifier l'année au format à quatre chiffres. La plage va de 1901 à 2155 et
YEAR
0000.
CREATION ET SUPPRESSION DE TABLE
 Création des tables - CREATE TABLE

La création d'une table de base implique de nommer la table et de définir ses
colonnes et le type de données de chaque colonne.
L'instruction CREATE TABLE permet de créer une nouvelle table.
Syntaxe :
1
CREATE TABLE nom_table(
2 column1 type_donnees [contraintes],
5 .....
6 columnN type_donnees [contraintes],
PRIMARY KEY( une ou plusieurs colonnes )
7 );
8
CREATE TABLE est le mot clé qui indique au système de base de données ce que
vous voulez faire. Dans ce cas, vous voulez créer une nouvelle table. Le nom unique
ou l'identificateur de la table suit l'instruction CREATE TABLE.
Ensuite, entre parenthèses, la liste définissant chaque colonne de la table et son
type de données.
Exemple 1 :
Le code suivant est un exemple, qui crée une table Employes avec un ID en tant
que clé primaire et NOT NULL sont les contraintes indiquant que ces champs ne
peuvent pas être NULL lors de la création d'enregistrements dans cette table.
1 CREATE TABLE Employes(

2 Id INT NOT NULL,
3 Nom VARCHAR (20) NOT NULL,
4 Age INT NOT NULL,
5 Salaire DECIMAL (18, 2),
6 PRIMARY KEY (Id)
);
7
 Suppression des tables - DROP TABLE
L'instruction DROP TABLE permet de supprimer une définition de table ainsi que
toutes les données, index, déclencheurs, contraintes et spécifications de permission
de cette table.
Attention ! Vous devez être très prudent lorsque vous utilisez cette commande car une fois
la table supprimée, toutes les informations disponibles dans cette table seront également
définitivement perdues.
Syntaxe :
1 DROP TABLE nom_table;
Exemple 2 :
Pour supprimer la table Employes, vous devez exécuter la requête suivante :
1 DROP TABLE Employes;

MODIFIER LA STRUCTURE D’UNE TABLE
La commande SQL ALTER TABLE permet d’ajouter, de supprimer ou de modifier

des colonnes dans une table existante. Vous devez également utiliser la
commande ALTER TABLE pour ajouter et supprimer diverses contraintes sur une
table existante.
 ALTER TABLE - ADD
Ajouter une colonnes
La syntaxe de base d'une commande ALTER TABLE pour ajouter une nouvelle
colonne dans une table existante est la suivante :
1 ALTER TABLE table_name
2 ADD (colonne1 type_donnees,
4 ...
colonneN type_donnees);
5
Exemple 1 :
La requête suivante ajoutera une colonne "adresse" à la table Employes

1 ALTER TABLE Employes ADD Adresse Varchar(100);
Ajouter une contrainte
ADD peut également être utilisé pour créer une contrainte sur les colonnes de la
table
Syntaxe :
ALTER TABLE nom_table

1
2 ADD CONSTRAINT nom_contrainte contrainte
Exemple 2 :
La requête suivante, ajoutera une contrainte CHECK à la colonne Age.

ALTER TABLE Employes
1
2 ADD CONSTRAINT ageContrainte CHECK(Age >= 18);
 ALTER TABLE - DROP

Ajouter une contrainte
DROP COLUMN est utilisé pour supprimer une colonne dans une table. Suppression
des colonnes indésirables de la table.
Syntaxe :

2 DROP COLUMN nom_colonne;
Exemple 3 :
pour supprimer la colonne Age de la table Employes, vous pouvez utiliser la requête
suivante :
1 ALTER TABLE Employes
2 DROP COLUMN Age;
Supprimer une contrainte
DROP CONSTRAINT peut également être utilisé pour supprimer une contrainte sur
les colonnes de la table
Syntaxe :

2 DROP CONSTRAINT nom_contrainte;
Exemple 4 :
Pour supprimer la contrainte ageContrainte sur la colonne Age de la

table Employes, vous pouvez utiliser la requête suivante :
2 DROP CONSTRAINT ageContrainte;
 ALTER TABLE - MODIFY
Elle est utilisée pour modifier les colonnes existantes dans une table. Plusieurs
colonnes peuvent également être modifiées à la fois.
Syntaxe :

2 MODIFY nom_colonne type_donnees;
Exemple 5 :
Supposons que nous voulions changer le type de données de la

colonne Age de int à Date. Vous pouvez le faire en utilisant la requête suivante :
2 MODIFY Age Date;
CONTRAINTES EN SQL
Les contraintes sont les règles appliquées aux colonnes de données d'une table.
Celles-ci sont utilisées pour limiter le type de données pouvant aller dans une table.
Cela garantit l'exactitude et la fiabilité des données de la base de données.
Les contraintes peuvent être au niveau de la colonne ou de la table. Les contraintes
de niveau de colonne ne sont appliquées qu'à une seule colonne, alors que les
contraintes de niveau de table s'appliquent à l'ensemble de la table.
Les contraintes les plus communes sont :
 NOT NULL
 DEFAULT
 UNIQUE
 CHECK
 PRIMARY KEY
 FOREIGN Key
 INDEX
 Contrainte NOT NULL
Par défaut, une colonne peut contenir des valeurs NULL. Si vous ne souhaitez pas
qu'une colonne ait une valeur NULL, vous devez définir une telle contrainte sur cette
colonne en spécifiant que NULL n'est plus autorisé pour cette colonne.
NULL n'est pas la même chose que pas de données, il représente plutôt des
données inconnues.
Exemple 1 :
Par exemple, la requête SQL suivante crée une nouvelle table appelée Employes et
ajoute quatre colonnes, dont trois sont Id, Nom et Age, nous spécifions pour ne pas
accepter les valeurs NULL.
2 Id INT NOT NULL,
4 Age INT NOT NULL,
6 PRIMARY KEY (Id)
);
7
Exemple 2 :
Si la table Employes a déjà été créée, pour ajouter une contrainte NOT NULL à la
colonne Salaire dans MySQL, vous devez écrire une requête comme suit :
ALTER TABLE Employes
1 MODIFY Salaire DECIMAL (18, 2) NOT NULL;
2
 Contrainte DEFAULT
La contrainte DEFAULT fournit une valeur par défaut à une colonne lorsque
l'instruction INSERT INTO ne fournit pas de valeur spécifique.
Exemple 3 :
Par exemple, le code SQL suivant crée la même table Employes, mais ici, la
colonne Salaire est définie sur 5000.00 par défaut.
2 Id INT NOT NULL,
4 Age INT NOT NULL,
5 Salaire DECIMAL (18, 2) DEFAULT 5000.00,
6 PRIMARY KEY (Id)
);
7
Exemple 4 :
Si la table Employes a déjà été créée, pour ajouter une contrainte DEFAULT à la
colonne Salaire dans MySQL, vous devez écrire une requête comme suit :
2 MODIFY Salaire DECIMAL (18, 2) DEFAULT 5000.00;
Pour supprimer une contrainte DEFAULT, utilisez la requête suivante :
1 ALTER TABLE Conges
2 ALTER COLUMN Salaire DROP DEFAULT;
 Contrainte UNIQUE
La contrainte UNIQUE empêche que deux enregistrements aient des valeurs
identiques dans une colonne.
Exemple 5 :
Par exemple, la requête SQL suivante crée la même table Employes, mais dans ce
cas, la colonne Nom est définie sur UNIQUE, de sorte que vous ne pouvez pas avoir
deux enregistrements portant le même Nom.

2 Id INT NOT NULL,
3 Nom VARCHAR (20) NOT NULL UNIQUE,
4 Age INT NOT NULL,
6 PRIMARY KEY (Id)
);
7
Exemple 6 :
Si la table Employes a déjà été créée, pour ajouter une contrainte UNIQUE à la
colonne Nom dans MySQL, vous devez écrire une requête comme suit :

2 MODIFY Nom VARCHAR(20) NOT NULL UNIQUE;
 Contrainte CHECK
La contrainte CHECK active une condition permettant de vérifier la valeur saisie dans
un enregistrement. Si la condition est évaluée à false, l'enregistrement viole la
contrainte et n'est pas entré dans la table.
Exemple 7 :
Par exemple, la requête SQL suivante crée la même table Employes, mais dans ce
cas, la colonne Age est définie sur CHECK, de sorte que vous ne pouvez pas avoir
un employe de moins de 18 ans.
2 Id INT NOT NULL,
4 Age INT NOT NULL CHECK (Age >= 18),
6 PRIMARY KEY (Id)
);
7
Exemple 8 :
Si la table Employes a déjà été créée, pour ajouter une contrainte CHECK à la
colonne Age dans MySQL, vous devez écrire une requête comme suit :
2 MODIFY Age INT NOT NULL CHECK (Age >= 18);
 Contrainte INDEX
L'INDEX est utilisé pour créer et récupérer des données de la base de données très
rapidement. Un index peut être créé en utilisant une seule colonne ou un groupe de
colonnes dans une table. Lors de la création de l'index, un ROWID est attribué à
chaque ligne avant le tri des données.
Les index appropriés sont bons pour les performances dans les bases de données
volumineuses, mais vous devez être prudent lors de la création d'un index. Une
sélection de champs dépend de ce que vous utilisez dans vos requêtes SQL.
Vous pouvez créer un index sur une ou plusieurs colonnes en utilisant la syntaxe
donnée ci-dessous.
1 CREATE INDEX nom_index
2 ON nom_table ( colonne1, colonne1, ...);
Pour créer un index sur la colonne Age, afin d'optimiser la recherche d'employés
pour un âge spécifique, vous pouvez utiliser la syntaxe suivante :
1 CREATE INDEX idx_age

2 ON Employes (Age);
Pour supprimer une contrainte INDEX, utilisez la syntaxe SQL suivante.
2 DROP INDEX idx_age;
 Contrainte PRIMARY KEY
Une clé primaire est un champ dans une table qui identifie de manière unique
chaque ligne/enregistrement dans une table de base de données. Les clés primaires
doivent contenir des valeurs uniques. Une colonne de clé primaire ne peut pas avoir
de valeur NULL.
Une table ne peut avoir qu'une seule clé primaire, qui peut consister en un ou
plusieurs champs. Lorsque plusieurs champs sont utilisés comme clé primaire, ils
sont appelés clé composite.
Si une table a une clé primaire définie sur un ou plusieurs champs, vous ne pouvez
pas avoir deux enregistrements ayant la même valeur pour pour ces champs.
Exemple 9 :
Voici la syntaxe pour définir l'attribut Id en tant que clé primaire dans une table
Employes.
2 Id INT NOT NULL,
4 Age INT NOT NULL,
6 PRIMARY KEY (Id)
);
7
Exemple 10 :
Pour créer une contrainte PRIMARY KEY sur la colonne "Id" alors que la table
Employes existe déjà, utilisez la syntaxe SQL suivante :
2 ADD PRIMARY KEY (ID);
Attention ! Si vous utilisez l'instruction ALTER TABLE pour ajouter une clé primaire, les
colonnes de clé primaire doivent déjà avoir été déclarées comme ne contenant pas de
valeurs NULL (lors de la création de la table).
Exemple 11 :
Pour définir une contrainte PRIMARY KEY sur plusieurs colonnes, utilisez la syntaxe
donnée ci-dessous.
2 Id INT NOT NULL,
4 Age INT NOT NULL,
6 PRIMARY KEY (Id, Nom)
);
7
Exemple 12 :
Pour créer une contrainte PRIMARY KEY sur les colonnes "Id" et "Nom" alors que la
table Employes existe déjà, utilisez la syntaxe suivante :
2 ADD PRIMARY KEY (Id, Nom);
Vous pouvez supprimer les contraintes de clé primaire de la table avec la syntaxe
donnée ci-dessous.
1 ALTER TABLE Employes DROP PRIMARY KEY ;
 Contrainte FOREIGN KEY

Une clé étrangère est une clé utilisée pour relier deux tables. Ceci est parfois appelé
aussi clé de référencement.
Une clé étrangère est une colonne ou une combinaison de colonnes dont les valeurs
correspondent à une clé primaire dans une autre table.
La relation entre 2 tables correspond à la clé primaire dans l'une des tables avec une
clé étrangère dans la seconde table.
Exemple 13 :
Considérez la structure des deux tableaux suivants.

2 Id INT NOT NULL,
4 Age INT NOT NULL,
6 PRIMARY KEY (Id, Nom)
);
7
1 CREATE TABLE Conges(

2 Id INT NOT NULL,
3 Date_debut DATE,
4 Date_fin DATE,
5 ID_EMP INT REFERENCES Employes(Id),
6 PRIMARY KEY (Id)
);
7
Ou
1 CREATE TABLE Conges(
2 Id INT NOT NULL,
3 Date_debut DATE NOT NULL,
4 Date_fin DATE NOT NULL,
5 ID_EMP INT,
6 PRIMARY KEY (Id),
7 FOREIGN KEY (ID_EMP) REFERENCES Employes(Id)
);
8
Exemple 14 :
Si la table Conges a déjà été créée et que la clé étrangère n'a pas encore été
définie, utilisez la syntaxe suivante pour spécifier une clé étrangère en modifiant une
table.
2 ADD FOREIGN KEY (ID_EMP) REFERENCES Employes(Id);
Pour supprimer une contrainte FOREIGN KEY, utilisez la syntaxe suivante :
2 DROP FOREIGN KEY;
 Suppression des contraintes
Toute contrainte que vous avez définie peut être supprimée à l'aide de la
commande ALTER TABLE avec l'option DROP CONSTRAINT.
Syntaxe :
1 ALTER TABLE Nom_table DROP CONSTRAINT nom_contrainte;

INSERTION ET MODIFICATION DES ENREGISTREMENTS – INSERET, UPDATE
ET DELETE
 Insertion des enregistrements - INSERT INTO

L'instruction INSERT INTO est utilisée pour ajouter de nouvelles lignes de données à
une table de la base de données.
Syntaxe :
Elle existe deux syntaxes de l'instruction INSERT INTO, présentées ci-dessous.

1 INSERT INTO nom_table (colonne1, colonne2, colonne3,...colonneN)
2 VALUES (valeur1, valeur2, value3,...valeurN);
Ici colonne1, colonne2, colonne3,...colonneN sont les noms des colonnes de la

table dans laquelle vous souhaitez insérer les données.
Il se peut que vous n’ayez pas besoin de spécifier le nom de la ou des colonnes
dans la requête SQL si vous ajoutez des valeurs pour toutes les colonnes de la table.
Mais assurez-vous que l'ordre des valeurs est dans le même ordre que celui des
colonnes du tableau.
1 INSERT INTO nom_table
2 VALUES (valeur1, valeur2, value3,...valeurN);
Exemple 1 :
cette instruction ajoutera un seul enregistrement à la table Employes

1 INSERT INTO Employes (Id, Nom, Age, Salaire)
2 VALUES(1, "Ismail", 25, 6000);
Comme nous remplissons toutes les colonnes, nous pouvons utiliser INSERT
INTO sans spécifier les colonnes.
1 INSERT INTO Employes VALUES(1, "Ismail", 25, 6000);
+----+--------+-----+---------+
| Id | Nom | Age | Salaire |
+----+--------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
+----+--------+-----+---------+
Pour insérer plusieurs enregistrements dans la table, utilisez la syntaxe suivante
1 INSERT INTO nom_table VALUES
2 (valeur1, valeur2, value3,...valeurN),
5 .....
(valeur1, valeur2, value3,...valeurN);
6
Exemple 2 :
1 INSERT INTO Employes VALUES

2 (2, "Mohamed", 30, 8000.40),
3 (3, "Fatima", 29, 6000);
+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
+----+---------+-----+---------+
 Modification des enregistrements - UPDATE

La requête UPDATE est utilisée pour modifier les enregistrements existants dans
une table. Vous pouvez utiliser la clause WHERE avec la requête UPDATE pour
mettre à jour les lignes sélectionnées, sinon toutes les lignes seraient affectées.
Syntaxe :
1 UPDATE nom_table
2 SET colonne1 = valeur1, colonne2 = valeur2...., colonneN = valeurN
3 [WHERE condition];
Vous pouvez combiner un nombre plusieurs conditions à l’aide des
opérateurs AND ou OR.
Exemple 3 :
Considérons la table Employes ayant les enregistrements suivants
+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
+----+---------+-----+---------+
La requête suivante mettra à jour le salaire d'un employé en ajoutant 900 DH à son
ancien salaire.
1 UPDATE Employes
2 SET Salaire=Salaire+900;
Maintenant, la table Employes aurait les enregistrements suivants :

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6900.00 |
| 2 | Mohamed | 30 | 8900.40 |
| 3 | Fatima | 29 | 6900.00 |
| 4 | Dounia | 31 | 9900.00 |
| 5 | Omar | 30 | 8400.00 |
+----+---------+-----+---------+
La requête suivante mettra à jour le salaire de chaque employé dont l'âge est
supérieur ou égal à 30 ans.
1 UPDATE Employes
2 SET Salaire=Salaire+500
3 WHERE age>=30;

+----+---------+-----+----------+
+----+---------+-----+----------+
| 1 | Ismail | 25 | 6900.00 |
| 2 | Mohamed | 30 | 9400.40 |
| 3 | Fatima | 29 | 6900.00 |
| 4 | Dounia | 31 | 10400.00 |
| 5 | Omar | 30 | 8900.00 |
+----+---------+-----+----------+
 Suppression des enregistrements - DELETE

La requête DELETE est utilisée pour supprimer les enregistrements existants d'une
table.
Vous pouvez utiliser la clause WHERE avec une requête DELETE pour supprimer
les lignes sélectionnées, sinon tous les enregistrements seraient supprimés.
Syntaxe :
1 DELETE FROM nom_table
2 [WHERE condition];
Exemple 4 :
La requête suivante supprime un employé dont l'Id est 4.

1 DELETE FROM Employes WHERE Id=4;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6900.00 |
| 2 | Mohamed | 30 | 9400.40 |
| 3 | Fatima | 29 | 6900.00 |
| 5 | Omar | 30 | 8900.00 |
+----+---------+-----+---------+
Si vous souhaitez supprimer tous les enregistrements de la table Employes, vous

n'avez pas besoin d'utiliser la clause WHERE.
1 DELETE FROM Employes;
Maintenant, la table Employes n’aurait aucun enregistrement.

EXTRACTION DES DONNEES
SELECT est l'instruction la plus couramment utilisée en SQL.

L'instruction SELECT en SQL permet d'extraire des données d'une base de
données. Nous pouvons récupérer la table entière ou selon certaines règles
spécifiées. Les données renvoyées sont stockées dans une table de résultats. Cette
table de résultats s'appelle également jeu de résultats.
Syntaxe :
1 SELECT colonne1, colonne2,..., colonneN FROM nom_table;
Ici, colonne1, colonne2,..., colonneN sont les champs d'une table dont vous voulez
récupérer les valeurs. Si vous voulez récupérer tous les champs, vous pouvez utiliser
la syntaxe suivante :
1 SELECT * FROM nom_table;
Exemples
La table échantillon - Employes
+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
+----+---------+-----+---------+
Exemple 1 :
La requête suivante est un exemple qui extrairait les champs Id, Nom et Salaire des
employés disponibles dans la table Employes :
1 SELECT Id, Nom, Salaire FROM Employes;
Cela produirait le résultat suivant :

+----+---------+---------+
| Id | Nom | Salaire |
+----+---------+---------+
| 1 | Ismail | 6000.00 |
| 2 | Mohamed | 8000.40 |
| 3 | Fatima | 6000.00 |
| 4 | Dounia | 9000.00 |
| 5 | Omar | 7500.00 |
+----+---------+---------+
Exemple 2 :
Si vous souhaitez récupérer tous les champs de la table Employes, vous devez
utiliser la requête suivante :
1 SELECT * FROM Employes;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
+----+---------+-----+---------+
Pour renommer une colonne spécifique dans le jeu de résultats, utilisez le mot
clé AS dans la requête.
Exemple 3 :
Pour renommer la colonne Nom avec "Nom d'employé" dans le jeu de résultats,
utilisez la requête suivante :
1 SELECT Id, Nom AS "Nom d'employé ", Salaire FROM Employes;

+----+-----------------+---------+
| Id | Nom d'employé | Salaire |
+----+-----------------+---------+
| 1 | Ismail | 6000.00 |
| 2 | Mohamed | 8000.40 |
| 3 | Fatima | 6000.00 |
| 4 | Dounia | 9000.00 |
| 5 | Omar | 7500.00 |
+----+-----------------+---------+
Vous pouvez également utiliser le mot clé AS pour attribuer un raccourci au nom de
la table et utiliser ce raccourci dans la requête. Ceci est très utile lorsque nous
traitons plusieurs tables.
Exemple 4 :
1 SELECT emp.Id, emp.Nom, Salaire FROM Employes AS emp;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
+----+---------+-----+---------+
Nous pouvons également utiliser des expressions dans l'instruction SELECT

Exemple 5 :
1 SELECT Id, Nom, (Salaire*1.5) AS "Nouveau Salaire" FROM Employes;

+----+---------+-----------------+
| Id | Nom | Nouveau Salaire |
+----+---------+-----------------+
| 1 | Ismail | 9000.000 |
| 2 | Mohamed | 12000.600 |
| 3 | Fatima | 9000.000 |
| 4 | Dounia | 13500.000 |
| 5 | Omar | 11250.000 |
+----+---------+-----------------+
FILTRER LES DONNEES - WHERE
La clause SQL WHERE est utilisée pour spécifier une condition lors de l'extraction
des données d'une seule table ou de plusieurs tables associées. Si la condition
donnée est satisfaite, elle renvoie uniquement une valeur spécifique de la table.
Vous devez utiliser la clause WHERE pour filtrer les enregistrements et extraire
uniquement les enregistrements nécessaires.
La clause WHERE est non seulement utilisée dans l'instruction SELECT, mais
également dans l'instruction UPDATE, DELETE, etc.
Pour suivre ce cours correctement, vous devez jeter un coup d'oeil sur les opérateurs
en SQL
Syntaxe :
1 SELECT colonne1, colonne2,..., colonneN

2 FROM nom_table
3 WHERE [condition]
Vous pouvez spécifier une condition à l'aide des opérateurs de comparaison ou
logiques.
Exemples
+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
+----+---------+-----+---------+
Exemple 1 :
La requête suivante est un exemple qui extrairait les champs Id, Nom et Salaire de
la table Employes, où le Salaire est supérieur à 7000.
1 SELECT Id, Nom, Salaire FROM Employes WHERE Salaire > 7000;

+----+---------+---------+
| Id | Nom | Salaire |
+----+---------+---------+
| 2 | Mohamed | 8000.40 |
| 4 | Dounia | 9000.00 |
| 5 | Omar | 7500.00 |
+----+---------+---------+
Exemple 2 :
La requête suivante est un exemple qui extrairait les champs Id et Nom de la

table Employes, où le l'Age de l'employé est entre 25 et 29.
1 SELECT Id, Nom FROM Employes WHERE age BETWEEN 25 AND 29;

+----+--------+
| Id | Nom |
+----+--------+
| 1 | Ismail |
| 3 | Fatima |
+----+--------+
Exemple 3 :
La requête suivante va afficher l'Id et le Salaire d'un employé, où le nom de

l'employé est "Omar"
1 SELECT Id, Salaire FROM Employes WHERE Nom="Omar";

+----+---------+
| Id | Salaire |
+----+---------+
| 5 | 7500.00 |
+----+---------+
Vous pouvez utiliser tous les opérateurs de comparaison ou logiques décrits

précédemment dans ce tutoriel.
AND et OR
Les opérateurs SQL AND et OR permettent de combiner plusieurs conditions pour
limiter les données dans une instruction SQL. Ces deux opérateurs sont appelés
opérateurs conjonctifs.
Ces opérateurs permettent d'effectuer plusieurs comparaisons avec différents
opérateurs dans la même instruction SQL.
L'opérateur AND
Cet opérateur affiche uniquement les enregistrements dans lesquels toutes les
conditions sont évaluées sur True.
Syntaxe :
1 SELECT colonne1, colonne1, ...
2 FROM nom_table
3 WHERE [condition1] AND [condition2]...AND [conditionN];
Exemple 4 :
Voici un exemple qui extrairait les champs Id et Nom de la table Employes,

où Salaire est supérieur à 7000 et l’âge compris entre 25 et 30 ans.
1 SELECT Id, Nom FROM Employes WHERE Salaire>7000 AND age BETWEEN 25 AND 30;

+----+---------+
| Id | Nom |
+----+---------+
| 2 | Mohamed |
| 5 | Omar |
+----+---------+
L'opérateur OR
Cet opérateur affiche les enregistrements pour lesquels au moins une condition est
évaluée à True.
Syntaxe :
1 SELECT colonne1, colonne2, ...
2 FROM nom_table
3 WHERE [condition1] OR [condition2]...OR [conditionN]

Exemple 5 :
La requête suivante, qui extrairait les champs Id et Nom de la table Employes, où

le Salaire est supérieur ou égal à 9000 OU l’âge est entre 25 et 29 ans.
1 SELECT Id, Nom FROM Employes WHERE Salaire>=9000 OR age BETWEEN 25 AND 29;

+----+--------+
| Id | Nom |
+----+--------+
| 1 | Ismail |
| 3 | Fatima |
| 4 | Dounia |
+----+--------+
 MODELE DE ERECHERCHE – LIKE
Parfois, nous pouvons exiger des nuplets de la base de données qui correspondent
à certains modèles. Par exemple, nous pouvons souhaiter extraire toutes les
colonnes où les n-uplets commencent par la lettre "y" ou par "b" et se terminent par
"a", ou même par des motifs de chaîne plus compliqués et restrictifs. C'est ici que la
lause LIKE vient nous sauver.
Souvent associée à la clause WHERE en SQL.
Deux types de caractères génériques sont utilisés pour filtrer les résultats:
 % : Utilisé pour faire correspondre zéro, un ou plusieurs caractères. (Longueur variable)
 _ : Utilisé pour correspondre exactement à un caractère. (Longueur fixe)
Voici les règles utilisées pour la correspondance de modèle avec la clause LIKE:
Modèle Description
"a%" Il fait correspondre les chaînes qui commencent par "a"
"%a" Il fait correspondre les chaînes qui se terminent par "a"
"a%t" Il fait correspondre les chaînes qui commencent par «a» et se terminent par «t».
"%abc%" Il fait correspondre les chaînes qui contiennent la sous-chaîne "abc" en n'importe quelle position.
"_abc%" Il fait correspondre les chaînes contenant la sous-chaîne "abc" en deuxième position.
"_a%" Il fait correspondre les chaînes contenant «a» à la deuxième position.

Modèle Description
Il fait correspondre les chaînes qui commencent par "a" et contiennent au moins 2 caractères
"a_%_%"
supplémentaires.
Exemples
+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
| 6 | Mostafa | 32 | 7000.00 |
+----+---------+-----+---------+
Exemple 1 :
La requête suivante va chercher tous les employés dont les noms commencent par
"Mo"
1 SELECT * FROM Employes WHERE Nom LIKE "Mo%";

+----+---------+-----+---------+
+----+---------+-----+---------+
| 2 | Mohamed | 30 | 8000.40 |
| 6 | Mostafa | 32 | 7000.00 |
+----+---------+-----+---------+
Exemple 2 :
1 SELECT * FROM Employes WHERE Nom LIKE "%a";

+----+---------+-----+---------+
+----+---------+-----+---------+
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 31 | 9000.00 |
| 6 | Mostafa | 32 | 7000.00 |
+----+---------+-----+---------+
Exemple 3 :
1 SELECT * FROM Employes WHERE Nom LIKE "%m%";

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 5 | Omar | 30 | 7500.00 |
| 6 | Mostafa | 32 | 7000.00 |
+----+---------+-----+---------+
Exemple 4 :
1 SELECT * FROM Employes WHERE Nom LIKE "%m_";

+----+--------+-----+---------+
+----+--------+-----+---------+
| 3 | Fatima | 29 | 6000.00 |
+----+--------+-----+---------+
TRIER LES DONNEES – ORDER BY
L’instruction ORDER BY dans SQL est utilisée pour trier les données extraites par
ordre croissant ou décroissant selon une ou plusieurs colonnes.
 Par défaut, ORDER BY trie les données par ordre croissant.
 Vous pouvez utiliser le mot-clé DESC pour trier les données par ordre décroissant et le
mot-clé ASC pour trier par ordre croissant.
Syntaxe :
1 SELECT liste-colonnes
2 FROM nom_table
3 [WHERE condition]
4 [ORDER BY colonne1, colonne2, .. ] [ASC | DESC];
Attention ! Vous pouvez utiliser plusieurs colonnes dans la clause ORDER BY. Assurez-
vous que les colonnes que vous utilisez pour trier ces enregistrements doivent figurer dans
la liste des colonnes (liste-colonnes).
Lorsque vous utilisez ORDER BY sur plusieurs colonnes, le tri commence par la
première colonne, si deux ou plusieurs enregistrements ont le même rang, alors le tri
passe à la colonne suivante, etc.
Exemples
+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 25 | 9000.00 |
| 5 | Omar | 30 | 7500.00 |
+----+---------+-----+---------+
Exemple 1 :
1 SELECT * FROM Employes ORDER BY Age;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 4 | Dounia | 25 | 9000.00 |
| 3 | Fatima | 29 | 6000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 5 | Omar | 30 | 7500.00 |
| 6 | Mostafa | 32 | 7000.00 |
+----+---------+-----+---------+
Exemple 2 :
1 SELECT * FROM Employes ORDER BY Age DESC;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 6 | Mostafa | 32 | 7000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 5 | Omar | 30 | 7500.00 |
| 3 | Fatima | 29 | 6000.00 |
| 1 | Ismail | 25 | 6000.00 |
| 4 | Dounia | 25 | 9000.00 |
+----+---------+-----+---------+
Exemple 3 :
1 SELECT * FROM Employes ORDER BY Age, Nom DESC;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 1 | Ismail | 25 | 6000.00 |
| 4 | Dounia | 25 | 9000.00 |
| 3 | Fatima | 29 | 6000.00 |
| 5 | Omar | 30 | 7500.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 6 | Mostafa | 32 | 7000.00 |
+----+---------+-----+---------+
Exemple 4 :
1 SELECT * FROM Employes ORDER BY Age DESC, Nom ASC;

+----+---------+-----+---------+
+----+---------+-----+---------+
| 6 | Mostafa | 32 | 7000.00 |
| 2 | Mohamed | 30 | 8000.40 |
| 5 | Omar | 30 | 7500.00 |
| 3 | Fatima | 29 | 6000.00 |
| 4 | Dounia | 25 | 9000.00 |
| 1 | Ismail | 25 | 6000.00 |
+----+---------+-----+---------+
LES JOINTURES EN SQL – JOIN.
La clause JOIN est utilisée pour récupérer les données de deux ou plusieurs tables,
qui sont jointes pour apparaître comme un seul ensemble de données. Elle est
utilisée pour combiner des colonnes de deux tables ou plus en utilisant des valeurs
communes aux deux tables.
Le mot-clé JOIN est utilisé dans les requêtes SQL pour joindre deux tables ou plus.
Les conditions minimales requises pour joindre la table sont (n-1), n étant le nombre
de tables. Une table peut également se joindre à elle-même, appelée SELF JOIN.
Voici les types de jointure que nous pouvons utiliser en SQL:
 CROSS
 INNER
 LEFT
 RIGHT
 SELF
Pendant ce cours, nous allons travailler sur ces deux tables
Table - Employes
+----+---------+-----+---------+------------+------+
| Id | Nom | Age | Salaire | Profession | Dep |
+----+---------+-----+---------+------------+------+
| 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 |
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL |
+----+---------+-----+---------+------------+------+
Table - Departement
+--------+--------------+
| Id_dep | Nom_dep |
+--------+--------------+
| 1 | Informatique |
| 2 | RH |
| 3 | Vente |
| 4 | Strategies |
+--------+--------------+
 CROSS JOIN
Ce type de JOIN renvoie le produit cartésien des lignes des tables de la jointure. Elle
renverra un jeu de résultats des enregistrements combinant chaque ligne de la
première table avec chaque ligne de la deuxième table.
Syntaxe :
2 FROM
3 table1 CROSS JOIN table2;
Exemple 1 :
1 SELECT * FROM Departement CROSS JOIN Employes;
Cette requête produira le jeu de résultats suivant :

+--------+--------------+----+---------+-----+---------+------------+------+
| Id_dep | Nom_dep | Id | Nom | Age | Salaire | Profession | Dep |
+--------+--------------+----+---------+-----+---------+------------+------+
| 1 | Informatique | 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 2 | RH | 1 | Ismail | 25 | 6000.00 | Assistant | 2|
| 3 | Vente | 1 | Ismail | 25 | 6000.00 | Assistant | 2|
| 4 | Strategies | 1 | Ismail | 25 | 6000.00 | Assistant | 2|
| 1 | Informatique | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 2 | RH | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 3 | Vente | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 4 | Strategies | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 1 | Informatique | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 2 | RH | 3 | Fatima | 29 | 6000.00 | Directeur | 3|
| 3 | Vente | 3 | Fatima | 29 | 6000.00 | Directeur | 3|
| 4 | Strategies | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 1 | Informatique | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 2 | RH | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 3 | Vente | 4 | Dounia | 30 | 7000.00 | Assistant | 4|
| 4 | Strategies | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 1 | Informatique | 5 | Omar | 29 | 9000.00 | Ingenieur | 1 |
| 2 | RH | 5 | Omar | 29 | 9000.00 | Ingenieur | 1|
| 3 | Vente | 5 | Omar | 29 | 9000.00 | Ingenieur | 1|
| 4 | Strategies | 5 | Omar | 29 | 9000.00 | Ingenieur | 1 |
| 1 | Informatique | 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL |
| 2 | RH | 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL |
| 3 | Vente | 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL |
| 4 | Strategies | 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL |
+--------+--------------+----+---------+-----+---------+------------+------+
Comme vous pouvez le constater, cette jointure renvoie le produit cartésien de tous
les enregistrements présents dans les deux tables.
 INNER JOIN
La jointure la plus importante et la plus utilisée est la jointure INNER. Elle est
également appelée jointure d'égalité.
INNER JOIN crée un jeu de résultats en combinant les valeurs de colonne de deux
tables (table1 et table2) en fonction du prédicat de jointure. La requête compare
chaque ligne de table1(A) avec chaque ligne de table2(B) pour rechercher toutes les
paires de lignes satisfaisant le prédicat de jointure. Lorsque le prédicat de jointure est
satisfait, les valeurs de colonne de chaque paire de lignes correspondante de A et
de B sont combinées dans une ligne de résultat.
Syntaxe 1 :
2 FROM
3 table1 INNER JOIN table2
4 ON table1.champ_commun = table1.champ_commun;
Syntaxe 2 :
La plupart des gens utilisent cette syntaxe à la place de la première syntaxe

2 FROM
3 table1, table2
4 WHERE table1.champ_commun = table1.champ_commun;
Exemple 2 :
1 SELECT * FROM Departement AS D INNER JOIN Employes AS E ON D.Id_dep=E.Dep;

+--------+--------------+----+---------+-----+---------+------------+------+
| 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 |
+--------+--------------+----+---------+-----+---------+------------+------+
 LEFT JOIN
LEFT JOIN renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de
correspondance dans la table de droite. Cela signifie que si la clause ON correspond
à 0 (zéro) enregistrements dans la table de droite; la jointure retournera toujours une
ligne dans le résultat, mais avec NULL dans chaque colonne de la table de droite.
Cela signifie qu'une jointure gauche renvoie toutes les valeurs de la table de gauche,
ainsi que les valeurs correspondantes de la table de droite ou NULL en cas
d'absence de prédicat de jointure correspondant.
Syntaxe:
2 FROM
3 table1 LEFT JOIN table2
Exemple 3 :
1 SELECT * FROM Employes AS E LEFT JOIN Departement as D ON D.Id_dep=E.Dep;

+----+---------+-----+---------+------------+------+--------+--------------+
| 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 |
+----+---------+-----+---------+------------+------+--------+--------------+
 RIGHT JOIN
RIGHT JOIN renvoie toutes les lignes de la table de droite, même s'il n'y a pas de
correspondance dans la table de gauche. Cela signifie que si la
clause ON correspond à 0 (zéro) enregistrements dans la table de gauche; la jointure
retournera toujours une ligne dans le résultat, mais avec NULL dans chaque colonne
de la table de gauche.
Syntaxe:
2 FROM
3 table1 RIGHT JOIN table2
Exemple 4 :
1 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 |
+------+---------+------+---------+------------+------+--------+--------------+
 SELF JOIN
SELF JOIN est utilisée pour joindre une table à elle-même comme si la table était
deux tables; renommer temporairement au moins une table dans l'instruction SQL.
Syntaxe:
2 FROM
3 table1 AS T1, table1 AS T2
4 WHERE T1.champ_commun = T2.champ_commun;
Ici, la clause WHERE peut être toute expression donnée en fonction de vos besoins.
Exemple 5 :
1 SELECT * FROM Employes AS T1, Employes AS T2 WHERE T1.Salaire>T2.Salaire;

+----+---------+-----+---------+------------+------+----+---------+-----+---------+------------+------+
| Id | Nom | Age | Salaire | Profession | Dep | Id | Nom | Age | Salaire | Profession | Dep |
+----+---------+-----+---------+------------+------+----+---------+-----+---------+------------+------+
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 | 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 | 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL | 1 | Ismail | 25 | 6000.00 | Assistant | 2 |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL | 2 | Mohamed | 30 | 8000.40 | Directeur | 1 |
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 4 | Dounia | 30 | 7000.00 | Assistant | 4 | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL | 3 | Fatima | 29 | 6000.00 | Directeur | 3 |
| 2 | Mohamed | 30 | 8000.40 | Directeur | 1 | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
| 7 | Mostafa | 29 | 9000.00 | Ingenieur | NULL | 4 | Dounia | 30 | 7000.00 | Assistant | 4 |
+----+---------+-----+---------+------------+------+----+---------+-----+---------+------------+------+
FONCTIONS D’AGREGATION EN SQL – SUM, COUNT, AVG, MIN ET MAX

La fonction d'agrégation SQL est utilisée pour effectuer les calculs sur plusieurs
lignes d'une seule colonne d'une table. Elle retourne une valeur unique.
Elle est également utilisée pour résumer les données.
La norme ISO définit cinq fonctions d'agrégation, à savoir:
 COUNT
 SUM
 AVG
 MIN
 MAX
Remarque ! Toutes les fonctions d'agrégation excluent par défaut les valeurs NULL avant
de travailler sur les données.
Table - Employes
+----+---------+-----+---------+------------+------+
+----+---------+-----+---------+------------+------+
| 5 | Omar | 29 | 9000.00 | Ingenieur | 1 |
+----+---------+-----+---------+------------+------+
 COUNT
La fonction COUNT est utilisée pour compter le nombre de lignes dans une table de
base de données. Il peut fonctionner sur les types de données numériques et non
numériques.
La fonction COUNT utilise COUNT(*) qui renvoie le nombre de toutes les lignes
d'une table spécifiée. COUNT(*) considère les doublons et Null.
Syntaxe :
1 COUNT(*)
2 // ou
3 COUNT( [ALL|DISTINCT] nom_colonne )
Exemple 1 :
La requête suivante comptera les enregistrements dans la table Employes

1 SELECT count(*) FROM Employes;

+----------+
| count(*) |
+----------+
| 6|
+----------+
Exemple 2 :
Compter les employés affectés à un département

1 SELECT count(Dep) FROM Employes;

+------------+
| count(Dep) |
+------------+
| 5|
+------------+
Exemple 3 :
Compter les différents âges de la table Employes, (sans doublons)

1 SELECT count(DISTINCT Age) FROM Employes;
+---------------------+
| count(DISTINCT Age) |
+---------------------+
| 3|
+---------------------+
 SUM
La fonction SUM renvoie la somme de toutes les valeurs de la colonne
spécifiée. SUM fonctionne uniquement sur les champs numériques.
Syntaxe :
1 SUM( [ALL|DISTINCT] nom_colonne )
Exemple 4 :
La requête suivante renvoie la somme des salaires

1 SELECT SUM(Salaire) FROM Employes;

+--------------+
| SUM(Salaire) |
+--------------+
| 43500.40 |
+--------------+
Exemple 5 :
La requête suivante renvoie la somme des âges sans compter les valeurs dupliquées
1 SELECT SUM(DISTINCT Age) FROM Employes;

+-------------------+
| SUM(DISTINCT Age) |
+-------------------+
| 84 |
+-------------------+
 AVG
La fonction AVG renvoie la moyenne des valeurs d'une colonne spécifiée. Tout
comme la fonction SUM, elle ne fonctionne que sur les types de données
numériques.
Syntaxe :
1 AVG( [ALL|DISTINCT] nom_colonne )
Exemple 6 :
La requête suivante renvoie le salaire moyen de la table Employes

1 SELECT AVG(Salaire) FROM Employes;

+--------------+
| AVG(Salaire) |
+--------------+
| 7250.066667 |
+--------------+
 MIN
La fonction MIN est utilisée pour déterminer la plus petite valeur de toutes les valeurs
sélectionnées d'une colonne.
Syntaxe :
1 MIN( [ALL|DISTINCT] nom_colonne )
Exemple 7 :
La requête suivante renvoie le salaire minimum de la table Employes

1 SELECT MIN(Salaire) FROM Employes;

+--------------+
| MIN(Salaire) |
+--------------+
| 6000.00 |
+--------------+
 MAX
Comme son nom l'indique, la fonction MAX est l'opposé de la fonction MIN. Elle
renvoie la plus grande valeur de toutes les valeurs sélectionnées d'une colonne.
Syntaxe :
1 MAX( [ALL|DISTINCT] nom_colonne )
Exemple 8 :
La requête suivante renvoie le salaire maximum de la table Employes

1 SELECT MAX(Salaire) FROM Employes;
+--------------+
| MAX(Salaire) |
+--------------+
| 9000.00 |
+--------------+
ORGANISER DES DONNEES IDENTIQUES EN GROUPES – GROUP BY ET

HAVING
La clause GROUP BY en SQL permet d’organiser des données identiques en

groupes à l’aide de certaines fonctions. C'est-à-dire si une colonne particulière a les
mêmes valeurs dans différentes lignes, elle organisera ces lignes dans un groupe.
 La clause GROUP BY est utilisée avec l'instruction SELECT.
 Dans la requête, la clause GROUP BY est placée après la clause WHERE.
 Dans la requête, la clause GROUP BY est placée avant la clause ORDER BY si elle est
utilisée.
Vous pouvez également utiliser certaines fonctions d'agrégation telles que COUNT,
SUM, MIN, MAX, AVG, etc. sur la colonne groupée.
Syntaxe :
1 SELECT colonne1, colonne2, ... colonneN,

2 fonction_agregation (nom_colonne)
3 FROM tables
4 [WHERE conditions]
GROUP BY colonne1, colonne2, ... colonneN;
5
colonne1, colonne2, ... colonneN - spécifie les colonnes(ou expressions) qui ne
sont pas encapsulées dans une fonction d'agrégation et doivent être incluses dans la
clause GROUP BY.
fonction_agregation (nom_colonne) - Nom de la fonction d'agrégation utilisée, par
exemple, SUM(), AVG ()... voir les différentes fonctions d'agrégation
WHERE conditions - C'est optionnel. Elle spécifie les conditions qui doivent être
remplies pour que les enregistrements soient sélectionnés.
Pendant ce cours, nous allons travailler sur ces deux tables
Table - Employes
+----+---------+-----+---------+------------+------+
+----+---------+-----+---------+------------+------+
| 5 | Omar | 30 | 9000.00 | Ingenieur | 1 |
+----+---------+-----+---------+------------+------+
Table - Departement
+--------+--------------+
+--------+--------------+
| 2 | RH |
| 3 | Vente |
| 4 | Strategies |
+--------+--------------+
Regroupement à l'aide d'une seule colonne

Regroupement à l'aide d'une seule colonne signifie placer toutes les lignes ayant la
même valeur que cette colonne particulière dans un groupe.
Pour mieux comprendre l'effet de la clause GROUP BY, exécutons une requête
simple qui renvoie toutes les entrées Age de la table Employes.
1 SELECT Age FROM Employes;

+-----+
| Age |
+-----+
| 25 |
| 30 |
| 29 |
| 30 |
| 30 |
| 29 |
+-----+
Supposons que nous voulions obtenir les valeurs uniques pour Age. Nous pouvons
utiliser une requête suivante
1 SELECT Age FROM Employes GROUP BY Age;

+-----+
| Age |
+-----+
| 25 |
| 29 |
| 30 |
+-----+
Notez que seuls trois résultats ont été renvoyés. C'est parce que nous n'avons que
trois âges différents. La clause GROUP BY a regroupée tous les employés de la
valeur Age="25" et n'a renvoyée qu'une seule ligne. La même chose avec les valeurs
"29" et "30".
Groupe 1 - Age = 25
+-----+
| Age |
+-----+
| 25 |
+-----+
Groupe 2 - Age=29
+-----+
| Age |
+-----+
| 29 |
| 29 |
+-----+
Groupe 3 - Age = 30
+-----+
| Age |
+-----+
| 30 |
| 30 |
| 30 |
+-----+
Vous pouvez maintenant compter le nombre d'employés de chaque groupe à l'aide

de la clause COUNT
1 SELECT Age, count(*) AS "Nombre d'employés" FROM Employes GROUP BY Age;

+-----+--------------------+
| Age | Nombre d'employés |
+-----+--------------------+
| 25 | 1|
| 29 | 2|
| 30 | 3|
+-----+--------------------+
Exemple 1 :
Compter le salaire moyen sur chaque groupe d'âge

1 SELECT Age, AVG(Salaire) AS "Salaire moyen" FROM Employes GROUP BY Age;

+-----+---------------+
| Age | Salaire moyen |
+-----+---------------+
| 25 | 6000.000000 |
| 29 | 6750.000000 |
| 30 | 8000.133333 |
+-----+---------------+
Exemple 2 :
Récupérez l'identifiant du département et le nombre d'employés dans chaque

département.
1 SELECT Dep, COUNT(Dep) AS "Nombre d'employés" FROM Employes GROUP BY Dep;

+------+--------------------+
| Dep | Nombre d'employés |
+------+--------------------+
| NULL | 0|
| 1| 2|
| 2| 1|
| 3| 1|
| 4| 1|
+------+--------------------+
Exemple 3 :
Récupérez le nom du département et le nombre d'employés dans chaque

département.
1 SELECT D.Nom_dep, COUNT(E.Dep) AS "Nombre d'employés"
2 FROM Employes AS E INNER JOIN Departement AS D
3 ON E.Dep=D.Id_dep
4 GROUP BY D.Nom_dep;

+--------------+--------------------+
| Nom_dep | Nombre d'employés |
+--------------+--------------------+
| Informatique | 2|
| RH | 1|
| Strategies | 1|
| Vente | 1|
+--------------+--------------------+
Regroupement sur plusieurs colonnes

Regroupement par plusieurs colonnes, par exemple, GROUP BY colonne1,
colonne2. Cela signifie placer toutes les lignes avec les mêmes valeurs des
colonnes colonne1 et colonne2 dans un groupe.
Exemple 4 :
Supposons maintenant que nous voulions regrouper tous les employés en fonction
de leur âge et de leur département.
1 SELECT Age, Dep, COUNT(*) FROM Employes GROUP BY Age, Dep;

+-----+------+----------+
| Age | Dep | COUNT(*) |
+-----+------+----------+
| 25 | 2 | 1|
| 29 | NULL | 1|
| 29 | 3 | 1|
| 30 | 1 | 2|
| 30 | 4 | 1|
+-----+------+----------+
Exemple 5 :
1 SELECT D.Nom_dep, E.Age , COUNT(E.Dep) AS "Nombre d'employés"

3 ON E.Dep=D.Id_dep
4 GROUP BY D.Nom_dep, E.Age;

+--------------+-----+--------------------+
| Nom_dep | Age | Nombre d'employés |
+--------------+-----+--------------------+
| Informatique | 30 | 2|
| RH | 25 | 1|
| Strategies | 30 | 1|
| Vente | 29 | 1|
+--------------+-----+--------------------+
Clause HAVING
Nous savons que la clause WHERE est utilisée pour imposer des conditions aux
colonnes, mais que se passe-t-il si nous voulons imposer des conditions aux
groupes?
C'est ici que la clause HAVING entre en vigueur. Nous pouvons utiliser la
clause HAVING pour poser des conditions afin de décider quel groupe fera partie de
l'ensemble des résultats finaux. De plus, nous ne pouvons pas utiliser les fonctions
d'agrégation telles que SUM(), COUNT(), etc. avec la clause WHERE. Nous devons
donc utiliser la clause HAVING si nous voulons utiliser l'une de ces fonctions dans
les conditions.
Syntaxe :
1 SELECT colonne1, colonne2, ... colonneN,

2 fonction_agregation (nom_colonne)
3 FROM tables
4 [WHERE conditions]
5 GROUP BY colonne1[, colonne2, ... colonneN]
HAVING condition ;
6
Exemple 6 :
La requête suivante récupère les noms de département et le salaire moyen de

chaque département
1 SELECT D.Nom_dep, AVG(E.Salaire) AS "Salaire moyen"
3 ON E.Dep=D.Id_dep
4 GROUP BY D.Nom_dep;
+--------------+---------------+
| Nom_dep | Salaire moyen |
+--------------+---------------+
| Informatique | 8500.200000 |
| RH | 6000.000000 |
| Strategies | 7000.000000 |
| Vente | 6000.000000 |
+--------------+---------------+
Supposons maintenant que nous ne voulions montrer que les départements dont le
salaire moyen est supérieur à 6000 ?
1 SELECT D.Nom_dep, AVG(E.Salaire) AS "Salaire moyen"
3 ON E.Dep=D.Id_dep
4 GROUP BY D.Nom_dep
HAVING AVG(E.Salaire) > 6000;

5

+--------------+---------------+
| Nom_dep | Salaire moyen |
+--------------+---------------+
| Informatique | 8500.200000 |
| Strategies | 7000.000000 |
+--------------+---------------+
LES SOUS –REQUETES EN SQL
Une sous-requête, également appelée requête imbriquée ou sous-sélection, est une

requête SELECT intégrée à la clause WHERE ou HAVING d'une autre requête SQL.
Les données renvoyées par la sous-requête sont utilisées par l'instruction externe de
la même manière qu'une valeur littérale serait utilisée.
Les sous-requêtes constituent un moyen simple et efficace de gérer les requêtes qui
dépendent des résultats d'une autre requête. Elles sont presque identiques aux
instructions SELECT normales, mais il existe peu de restrictions. Les plus
importantes sont énumérées ci-dessous:
 Une sous-requête doit toujours apparaître entre parenthèses.
 Une sous-requête doit renvoyer une seule colonne. Cela signifie que vous ne pouvez
pas utiliser SELECT * dans une sous-requête à moins que la table à laquelle vous faites
référence ne comporte qu'une seule colonne. Vous pouvez utiliser une sous-requête qui
renvoie plusieurs colonnes si le but est la comparaison de lignes.
 Vous ne pouvez utiliser que des sous-requêtes renvoyant plusieurs lignes avec des
opérateurs de valeurs multiples, tels que l'opérateur IN ou NOT IN.
 Une clause ORDER BY ne peut pas être utilisée dans une sous-requête, bien que la
requête principale puisse utiliser un ORDER BY. La clause GROUP BY peut être utilisée
pour exécuter la même fonction que ORDER BY dans une sous-requête.
 Une sous-requête ne peut pas être une UNION. Une seule instruction SELECT est
autorisée.
Les sous-requêtes sont le plus souvent utilisées avec l'instruction SELECT.
Toutefois, vous pouvez également les utiliser dans une instruction INSERT,
UPDATE ou DELETE ou dans une autre sous-requête.
Pendant ce cours, nous allons travailler sur ces 4 tables
Table - Departement
+--------+--------------+
+--------+--------------+
| 2 | RH |
| 3 | Vente |
| 4 | Strategies |
+--------+--------------+
Table - Employes
+----+---------+-----+---------+------------+------+
+----+---------+-----+---------+------------+------+
| 5 | Omar | 30 | 9000.00 | Ingenieur | 1 |
| 6 | Mostafa | 29 | 7500.00 | Ingenieur | 3 |
+----+---------+-----+---------+------------+------+
Table - Projet
+------+------------+-----------+------------------+
| Id_p | Titre | Cout | Date_realisation |
+------+------------+-----------+------------------+
| 1 | SIG Meknes | 200000.00 | 2019-01-25 |
| 2 | SI Vente | 130000.00 | 2019-03-12 |
| 3 | Blog RH | 30000.00 | 2018-05-03 |
+------+------------+-----------+------------------+
Table - Participer
+-----+------+
| Emp | Proj |
+-----+------+
| 1| 1|
| 2| 1|
| 2| 3|
| 3| 1|
| 6| 2|
| 6| 3|
+-----+------+
 Sous-requêtes avec l'instruction SELECT

Les sous-requêtes sont le plus souvent utilisées avec l'instruction SELECT. La
syntaxe de base est la suivante :
Syntaxe :
1 SELECT nom_colonne [, nom_colonne ]

2 FROM table1 [, table2 ]
3 WHERE nom_colonne OPERATOR
4 (SELECT nom_colonne [, nom_colonne ]
6 [WHERE])
Il existe principalement deux types de sous-requêtes :
 Sous-requêtes indépendantes
 Sous-requêtes corrélées
 Sous-requêtes indépendantes
Dans les sous-requêtes indépendantes, l'exécution de la requête commence de la
requête la plus interne vers la plus externe. L'exécution d'une requête interne est
indépendante de la requête externe, mais le résultat de la requête interne est utilisé
dans l'exécution de la requête externe. Divers opérateurs tels que IN, NOT IN, ANY,
ALL, etc. sont utilisés pour l'écriture de sous-requêtes indépendantes.
Exemple 1 :
Si nous voulons connaître les Ids des employés qui participent aux projets «Vente
SI» ou «Blog RH», nous pouvons l’écrire à l’aide d’une sous-requête indépendante
et d’un opérateur IN. A partir de la table Projet, nous pouvons trouver Id_p pour les
projet «SI Vente» ou «Blog RH» et nous pouvons utiliser ces Id_p pour trouver Ids
des employés à partir de la table Particper.
Nous pouvons le faire en deux étapes :
Etape 1 - Trouver Id_p pour les projet «SI Vente» ou «Blog RH»
1 SELECT Id_p FROM Projet WHERE Titre="Blog RH" OR Titre="Vente SI"
Etape 2 - utiliser les Id_p pour de la première etape pour trouver les Ids des employés à partir de la table
Particper
1 SELECT DISTINCT Emp FROM Participer
2 WHERE Proj IN (SELECT Id_p FROM Projet WHERE Titre="Blog RH" OR Titre="Vente SI");

+-----+
| Emp |
+-----+
| 2|
| 6|
+-----+
Exemple 1 :
Si nous voulons les noms de départements dans lesquels un employé a participé à

un projet
Etape 1 - Trouver Dep des employés ayant participés dans un projet
1 SELECT DISTINCT E.Dep FROM Employes AS E INNER JOIN Participer AS P ON E.Id=P.Emp;

+------+
| Dep |
+------+
| 2|
| 1|
| 3|
+------+
Etape 2 - Utiliser ces Ids pour trouver les noms des départements de la table Departement
SELECT Nom_dep FROM Departement

1
WHERE ID_dep IN (SELECT DISTINCT E.Dep FROM Employes AS E INNER JOIN Participer AS
2 P ON E.Id=P.Emp);
+--------------+
| Nom_dep |
+--------------+
| Informatique |
| RH |
| Vente |
+--------------+
Exemple 1 :
Pour trouver des employés qui ne participent à aucun projet
1 SELECT Nom FROM Employes
2 WHERE Id NOT IN (SELECT DISTINCT Emp FROM Participer);

+--------+
| Nom |
+--------+
| Dounia |
| Omar |
+--------+
 Sous-requêtes corrélées
Une sous-requête corrélée est une sous-requête dont le résultat est différent selon
les valeurs de la ligne de la requête externe pour laquelle la sous-requête est
exécutée. Cela rend nécessaire d'exécuter la sous-requête pour chaque ligne
extraite par la requête externe et ajoute au coût de performance de la requête.
Exemple 1 :
Trouver l'employé avec le plus grand salaire dans son département

1 SELECT Nom FROM Employes AS e1
2 WHERE e1.Salaire=(SELECT MAX(e2.Salaire) FROM Employes AS e2 WHERE e1.Dep=e2.Dep);

+---------+
| Nom |
+---------+
| Ismail |
| Dounia |
| Omar |
| Mostafa |
+---------+
Dans la requête ci-dessus, la sous-requête doit être exécutée pour chaque ligne de
la table Employes, car chaque employé peut appartenir à un service différent. Par
conséquent, comparer son salaire au salaire maximum de son service signifie qu'il
peut potentiellement être comparé à un nombre différent.
La requête doit exécuter la sous-requête pour chaque valeur distincte de Dep. Elle
peut également trouver un moyen de mettre en cache les résultats de ces sous-
requêtes et de les utiliser pour comparer les lignes d'employés suivantes avec le
même Dep. Certaines implémentations SQL peuvent effectuer cette optimisation,
d'autres non.
Si la sous-requête n'est pas corrélée, elle renverra logiquement le même résultat,
quelles que soient les valeurs de la ligne de la requête externe. L'optimiseur SQL
peut être conçu pour factoriser complètement la sous-requête, de sorte qu'elle n'ait à
exécuter qu'une seule fois, quel que soit le nombre de lignes de la requête externe
qui utilisent le résultat. C'est souvent une grande amélioration pour la performance.
Sous-requêtes vs jointures
Comparées aux jointures, les sous-requêtes sont simples à utiliser et à lire. Ils ne
sont pas aussi compliqués que les jointures. Par conséquent, les débutants en SQL
l'utilisent fréquemment.
Mais les sous-requêtes posent des problèmes de performances. L'utilisation d'une
jointure au lieu d'une sous-requête peut parfois vous donner un gain de
performances jusqu'à 500 fois. Si vous avez le choix, il est recommandé d'utiliser une
jointure plutôt qu'une sous-requête.
Les sous-requêtes ne doivent être utilisées comme solution de secours que lorsque
vous ne pouvez pas utiliser une opération JOIN pour atteindre les objectifs ci-dessus.
Sous-requêtes avec l'instruction INSERT
La sous-requête SQL peut également être utilisée avec l'instruction INSERT. Dans
l'instruction INSERT, les données renvoyées par la sous-requête sont utilisées pour
être insérées dans une autre table.
Dans la sous-requête, les données sélectionnées peuvent être modifiées avec
n’importe laquelle des fonctions de caractère et de date.
Syntaxe :
1 INSERT INTO nom_table [ (col1 [, col2 ]) ]

2 SELECT [ *|col1 [, col2 ]
4 [ WHERE VALUE OPERATOR ]
Exemple 1 :
Considérons une table Employes_SAUVEGARDE avec une structure similaire à la

table Employes. Maintenant, pour copier la table Employes dans la
table Employes_SAUVEGARDE, vous pouvez utiliser la syntaxe suivante.
1 INSERT INTO Employes_SAUVEGARDE
2 SELECT * FROM Employes
Sous-requêtes avec l'instruction UPDATE
La sous-requête peut être utilisée conjointement avec l'instruction UPDATE.
Lorsqu'une sous-requête est utilisée avec l'instruction UPDATE, une ou plusieurs
colonnes d'une table peuvent être mises à jour.
Syntaxe :
1 UPDATE table
2 SET nom_colonne = nouvelle_valeur
3 [ WHERE OPERATOR [ VALUE ]
4 (SELECT COLUMN_NAME
5 FROM TABLE_NAME)
[ WHERE) ]
6
Exemple 1 :
En supposant que nous ayons une table Employes_SAUVEGARDE disponible qui

est une sauvegarde de la table Employes. L'exemple suivant met à jour le salaire de
0,25 fois dans la table Employes pour tous les employés dont l'âge est supérieur ou
égal à 30.
1 UPDATE Employes
2 SET Salaire = Salaire * 0.25
3 WHERE Age IN (SELECT Age FROM Employes_SAUVEGARDE
4 WHERE Age >= 30);
Table - Employes
+----+---------+-----+---------+------------+------+
+----+---------+-----+---------+------------+------+
| 5 | Omar | 30 | 2250.00 | Ingenieur | 1 |
| 6 | Mostafa | 29 | 7500.00 | Ingenieur | 3 |
+----+---------+-----+---------+------------+------+
 Sous-requêtes avec l'instruction DELETE

La sous-requête peut être utilisée en conjonction avec l'instruction DELETE,
exactement comme toutes les instructions mentionnées ci-dessus.
Exemple 1 :
Supposons que nous ayons une table Employes_SAUVEGARDE disponible qui est
une sauvegarde de la table Employes. L'exemple donné supprime les
enregistrements de la table Employes pour tous les employés dont l'âge est inférieur
ou égal à 29.
?
1 DELETE FROM Employes
2 WHERE Age IN (SELECT Age FROM Employes_SAUVEGARDE
3 WHERE Age <= 29 );

Table - Employes
+----+---------+-----+---------+------------+------+
+----+---------+-----+---------+------------+------+
| 5 | Omar | 30 | 2250.00 | Ingenieur | 1 |
+----+---------+-----+---------+------------+------+
COMBINEZ LES RESULTATS DE DEUX OU PLUSIEURS INSTRUCTIONS
SELECT - UNION
La clause/opérateur SQL UNION est utilisée pour combiner les résultats de deux ou
plusieurs instructions SELECT sans renvoyer les lignes en double.
Pour utiliser cette clause UNION, chaque instruction SELECT doit avoir :
 Le même nombre de colonnes sélectionnées
 Le même type de données et
 Les avoir dans le même ordre
Mais ils n'ont pas besoin d'être dans la même longueur.
La clause UNION produit des valeurs distinctes dans le jeu de résultats. Pour extraire
les valeurs en double, UNION ALL doit être utilisée à la place de UNION.
Syntaxe - UNION
1 SELECT colonne1 [, colonne2 ]

3 [WHERE condition]
4
5 UNION
6
FROM table1 [, table2 ]
8
[WHERE condition]
9
Syntaxe - UNION ALL

3 [WHERE condition]
4
5 UNION ALL
6
FROM table1 [, table2 ]
8
[WHERE condition]
9
Ici, la condition donnée peut être toute expression donnée en fonction de vos
besoins.
Pendant ce cours, nous allons travailler sur ces 2 tables
Table - Employes
+----+---------+-----+---------+------------+------+
+----+---------+-----+---------+------------+------+
| 1 | Ismail | 25 | 6000.00 | Technicien | 2 |
| 3 | Fatima | 29 | 8000.00 | Assistant | 2 |
| 5 | Omar | 30 | 2250.00 | Ingenieur | 1 |
| 6 | Mostafa | 32 | 7500.00 | Formateur | 1 |
+----+---------+-----+---------+------------+------+
Table - Conges
+------+------------+------------+-------------------+-----+
| Id_c | Date_debut | Date_fin | Raison | Emp |
+------+------------+------------+-------------------+-----+
| 1 | 2019-02-01 | 2019-02-15 | Voyage | 1|
| 2 | 2019-05-20 | 2019-06-03 | Maladie d'enfant | 3 |
| 3 | 2019-09-01 | 2019-09-15 | Rentrée scolaire | 4 |
+------+------------+------------+-------------------+-----+
Remarque ! Les noms de colonne dans les deux instructions SELECT peuvent être
différents mais le type de données doit être identique. Et dans le résultat, le nom de la
colonne utilisée dans la première instruction SELECT apparaîtra.
Exemples
Exemple 1 :
Pour récupérer des identifiants distincts d'employés à partir des

tables Employee et Conges.
1 SELECT Id From Employes
2 UNION
3 SELECT Emp FROM Conges;
+----+
| Id |
+----+
| 1|
| 2|
| 3|
| 4|
| 5|
| 6|
+----+
Exemple 2 :
Pour récupérer des identifiants distincts d'employés de la table Employee et de la

table Conges, y compris les valeurs en double.
1 SELECT Id From Employes

2 UNION ALL
3 SELECT Emp FROM Conges;
+----+
| Id |
+----+
| 1|
| 2|
| 3|
| 4|
| 5|
| 6|
| 1|
| 3|
| 4|
+----+
Exemple 3 :
Pour récupérer Id et le Nom de la table Employes où Id est supérieur à 3, et Emp,

Raison de la table Conges où Emp est inférieur à 3, en incluant les valeurs en
double et en triant les données par Id.
1 SELECT Id, Nom From Employes WHERE Id > 3

2 UNION ALL
3 SELECT Emp, Raison FROM Conges WHERE Emp < 3
4 ORDER BY Id;
+----+---------+
| Id | Nom |
+----+---------+
| 1 | Voyage |
| 4 | Dounia |
| 5 | Omar |
| 6 | Mostafa |
+----+---------+
Exemple 4 :
Utilisez LEFT JOIN et RIGHT JOIN dans la clause UNION

1 SELECT E.Id, E.Nom FROM Employes as E LEFT JOIN Conges as C ON E.Id=C.Emp
2 UNION
3 SELECT E.Id, E.Nom FROM Employes as E RIGHT JOIN Conges as C ON E.Id=C.Emp;

+------+---------+
| Id | Nom |
+------+---------+
| 1 | Ismail |
| 3 | Fatima |
| 4 | Dounia |
| 2 | Mohamed |
| 5 | Omar |
| 6 | Mostafa |
+------+---------+
LES FONCTIONS SQL DE MANIPULATIONS DE DATE
En SQL, les dates sont compliquées pour les débutants, car lors de l'utilisation d'une
base de données, le format de la date dans le tableau doit être apparié avec la date
d'entrée pour pouvoir l'insérer.
Dans divers scénarios au lieu de la Date, DateTime(l'heure est également impliquée
avec la date) est utilisé.
Dans ce cours, nous allons parler de différentes fonctions de date par défaut dans
MySQLl.
La table échantillon - Conges
+------+------------+------------+-------------------+-----+
| Id_c | Date_debut | Date_fin | Raison | Emp |
+------+------------+------------+-------------------+-----+
| 1 | 2019-02-01 | 2019-02-15 | Voyage | 1|
| 2 | 2019-05-20 | 2019-06-03 | Maladie d'enfant | 3 |
| 3 | 2019-09-01 | 2019-09-15 | Rentrée scolaire | 4 |
| 4 | 2019-09-24 | 2019-09-29 | Voyage | 2|
| 5 | 2019-09-19 | 2019-09-24 | Soutenance | 5|
+------+------------+------------+-------------------+-----+
 NOW()
Renvoie la date et l'heure actuelles sous forme de valeur au format 'AAAA-MM-JJ
HH: MM: SS' ou YYYYMMDDHHMMSS, selon que la fonction est utilisée dans un
contexte de chaîne ou numérique. La valeur est exprimée dans le fuseau horaire
actuel.
Exemple :
1 SELECT NOW();
+---------------------+
| NOW() |
+---------------------+
| 2019-09-24 13:48:18 |
+---------------------+
 CURDATE()
Renvoie la date actuelle sous forme de valeur au format 'AAAA-MM-
JJ' ou AAAAMMMJJ, selon que la fonction est utilisée dans un contexte de chaîne
ou numérique.
Exemple :
1 SELECT CURDATE();
+------------+
| CURDATE() |
+------------+
| 2019-09-24 |
+------------+
 CURTIME()
Renvoie l'heure actuelle sous forme de valeur au format 'HH: MM: SS' ou HHMMSS,
selon que la fonction est utilisée dans un contexte de chaîne ou numérique. La
valeur est exprimée dans le fuseau horaire actuel.
Exemple :
1 SELECT CURTIME();
+-----------+
| CURTIME() |
+-----------+
| 13:59:00 |
+-----------+
 DATE(date)
Extrait la partie date de la date ou de l'expression DateTime.
Exemple 1 :
1 SELECT DATE('2019-09-24 13:59:03');
+-----------------------------+
| DATE('2019-09-24 13:59:03') |
+-----------------------------+
| 2019-09-24 |
+-----------------------------+
Exemple 2 :
?
1 SELECT DATE(Date_debut) FROM Conges;
+------------------+
| DATE(Date_debut) |
+------------------+
| 2019-02-01 |
| 2019-05-20 |
| 2019-09-01 |
| 2019-09-24 |
| 2019-09-19 |
+------------------+
 EXTRACT(unit FROM date)

Renvoie une seule partie d'une date/heure.
Plusieurs unités peuvent être envisagées, mais seules certaines sont utilisées, telles
que : MICROSECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH,
QUARTER, YEAR, etc.
Exemple :
1 SELECT EXTRACT(DAY FROM Date_debut) as "Jour", EXTRACT(MONTH FROM Date_debut) as "Mois",
2 EXTRACT(YEAR FROM Date_debut) as "Année"
3 FROM Conges;
+------+------+--------+
| Jour | Mois | Année |
+------+------+--------+
| 1 | 2 | 2019 |
| 20 | 5 | 2019 |
| 1 | 9 | 2019 |
| 24 | 9 | 2019 |
| 19 | 9 | 2019 |
+------+------+--------+
 DATE_ADD(date, INTERVAL expr type)

Ajoute un intervalle de temps spécifié à une date.
type peut être l'un des types suivants : MICROSECOND, SECOND, MINUTE,
HOUR, DAY, WEEK, MONTH, QUARTER, YEAR, etc.
Exemple 1 :
Ajouter un an à chaque Date_debut
1 SELECT DATE_ADD(Date_debut, INTERVAL 1 YEAR) FROM Conges;
+---------------------------------------+
| DATE_ADD(Date_debut, INTERVAL 1 YEAR) |
+---------------------------------------+
| 2020-02-01 |
| 2020-05-20 |
| 2020-09-01 |
| 2020-09-24 |
| 2020-09-19 |
+---------------------------------------+
Exemple 2 :
Ajouter 3 mois à chaque Date_debut

1 SELECT DATE_ADD(Date_debut, INTERVAL 3 MONTH) FROM Conges;
+----------------------------------------+
| DATE_ADD(Date_debut, INTERVAL 3 MONTH) |
+----------------------------------------+
| 2019-05-01 |
| 2019-08-20 |
| 2019-12-01 |
| 2019-12-24 |
| 2019-12-19 |
+----------------------------------------+
 DATE_SUB(date, INTERVAL expr type)

Soustrait un intervalle de temps spécifié à une date.
type peut être l'un des types suivants : MICROSECOND, SECOND, MINUTE,
HOUR, DAY, WEEK, MONTH, QUARTER, YEAR, etc.
Exemple :
Soustrait 3 mois de Date_Debut
1 SELECT DATE_SUB(Date_debut, INTERVAL 3 MONTH) FROM Conges;
+----------------------------------------+
| DATE_SUB(Date_debut, INTERVAL 3 MONTH) |
+----------------------------------------+
| 2018-11-01 |
| 2019-02-20 |
| 2019-06-01 |
| 2019-06-24 |
| 2019-06-19 |
+----------------------------------------+
 DATEDIFF(date1, date2);
Renvoie date1-date2 sous forme de valeur en jours d'une date à
l'autre. date1 et date2 sont des expressions de date ou de date et heure. Seules les
parties de date des valeurs sont utilisées dans le calcul.
Exemple :
La requête suivante indiquera le nombre de jours passés de Date_debut jusqu'à

maintenant
1 SELECT DATEDIFF(NOW(), Date_debut) AS "Nombre jours passés" FROM Conges;
+----------------------+
| Nombre jours passés |
+----------------------+
| 235 |
| 127 |
| 23 |
| 0|
| 5|
+----------------------+
 YEAR(date), MONTH(date) et DAY(date)

Utilisée pour extraire l'année, le mois et le jour respectivement
Exemple :
1 SELECT YEAR(Date_debut), MONTH(Date_debut), DAY(Date_debut) FROM Conges;

+------------------+-------------------+-----------------+
| YEAR(Date_debut) | MONTH(Date_debut) | DAY(Date_debut) |
+------------------+-------------------+-----------------+
| 2019 | 2| 1|
| 2019 | 5| 20 |
| 2019 | 9| 1|
| 2019 | 9| 24 |
| 2019 | 9| 19 |
+------------------+-------------------+-----------------+

Langage SQL

Transféré par

Droits d'auteur :

Formats disponibles

Langage SQL

Transféré par

Informations du document

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

Langage SQL

Transféré par

Droits d'auteur :

Formats disponibles

LANGAGE SQL

LDD - Langage de définition de données

ALTER Modifie un objet de base de données existant, tel qu'une table.

SELECT Récupère certains enregistrements d'une ou de plusieurs tables.

INSERT Crée un enregistrement.

UPDATE Modifie les enregistrements.

DELETE Supprime les enregistrements.

LCD - Langage de contrôle de données

GRANT Donne un privilège à l'utilisateur.

REVOKE Reprend les privilèges accordés par l'utilisateur.

Un système de gestion de base de données relationnelle (SGBDR) est un système

 Concepts de base de SGBDR

 Qu'est-ce qu'un tuple ?

 Contraintes d'intégrité relationnelle

 Instruction CREATE TABLE

 Instruction CREATE INDEX

 Instruction DROP INDEX

 Instruction ALTER TABLE

 Instruction ALTER TABLE (rename)

 Instruction INSERT INTO

 Instruction CREATE DATABASE

 Instruction DROP DATABASE

Un opérateur est un mot réservé ou un caractère utilisé principalement dans la

+ (Addition) Ajoute des valeurs de chaque côté de l'opérateur.

- (Soustraction) Soustrait l'opérande droit de l'opérande gauche.

* (Multiplication) Multiplie les valeurs de chaque côté de l'opérateur.

/ (Division) Divise l'opérande gauche par l'opérande droit.

Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande

Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande

Vérifie si la valeur de l'opérande de gauche est supérieure ou égale à la valeur de

Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de

Vérifie si la valeur de l'opérande gauche n'est pas inférieure à la valeur de

Vérifie si la valeur de l'opérande de gauche n'est pas supérieure à la valeur de

L'opérateur BETWEEN permet de rechercher des valeurs comprises dans un ensemble de

 Création d'une base de données

1 CREATE DATABASE nomBDonnees;

Le nom de la base de données doit toujours être unique dans le SGBDR.

Si vous souhaitez créer une nouvelle base de données "devInfo",

1 CREATE DATABASE devInfo;

Assurez-vous de disposer du privilège administrateur avant de créer une base de

 Supprimer une base de données

1 DROP DATABASE nomBDonnees;

Si vous souhaitez supprimer une base de données existante "devInfo",

DROP DATABASE devInfo;

Sélectionner une base de données

Si vous souhaitez utiliser la base de données "devInfo", vous pouvez exécuter la

Types de données SQL

Types de données numériques

smallint -32,768 32,767

int -2,147,483,648 2,147,483,647

bigint -9,223,372,036,854,775,808 9,223,372,036,854,775,807

decimal -10^38 +1 10^38 -1

numeric -10^38 +1 10^38 -1

float -1.79E + 308 1.79E + 308

real -3.40E + 38 3.40E + 38

Types de données Date et Heure

DATE Stocke la date dans le format YYYY-MM-DD

TIME Stocke l'heure dans le format HH:MI:SS

DATETIME Stocke les informations de date et heure au format YYYY-MM-DD HH:MI:SS

Stocke le nombre de secondes écoulées depuis l'époque Unix (Horodatage) (‘1970-01-