SQL

D DIACK
 Définition du langage SQL
SQL (Structured Query Language) est un langage de programmation utilisé pour gérer
et manipuler les bases de données relationnelles. Il permet aux utilisateurs de créer,
modifier, interroger et supprimer des données stockées dans ces bases de données.
SQL est standardisé, ce qui signifie qu'il existe des règles et des commandes
spécifiques qui sont largement adoptées dans divers systèmes de gestion de bases de
données (SGBD) comme MySQL, PostgreSQL, SQL Server, et Oracle.
 Définition de base de données relationnelles

Une base de données relationnelle est un type de base

de données qui organise les données en un ensemble de
tables reliées entre elles par des relations. Chaque table,
également appelée relation, est composée de lignes et de
colonnes. Les colonnes représentent les attributs des
données (ou champs), tandis que les lignes (ou
enregistrements) représentent des instances de ces
données.
Catégories de commandes SQL

Les commandes SQL sont regroupées en quatre catégories

principales en fonction de leur fonctionnalité. Ils sont les suivants:
Langage de définition de données (DDL)
Ces commandes SQL sont utilisées pour créer,
modifier et supprimer la structure des objets de
base de données. Les commandes sont :
● CREATE, ALTER, DROP, RENAME et
TRUNCATE.
Langage de manipulation de données (DML)
Ces commandes SQL sont utilisées pour stocker,
récupérer, modifier et supprimer des données. Ces
commandes sont :
● SELECT, INSERT, UPDATE et DELETE.
 Langage de contrôle des transactions (TCL)

Ces commandes SQL sont utilisées pour gérer les

changements affectant les données. Ces commandes
sont :
● COMMIT, ROLLBACK et SAVEPOINT.
 Langage de contrôle des données (DCL)

Ces commandes SQL sont utilisées pour assurer la

sécurité des objets de la base de données. Ces
commandes sont :
● GRANT et REVOKE.
Premières requêtes SQL : Create, Drop et Show
Créer et supprimer une base de données (create,
drop, show)
Créer une base de données : CREATE DATABASE

• La commande SQL pour la création de base est CREATE

DATABASE avec le nom de la base(ici : tuto). Voici sa
syntaxe :

• CREATE DATABASE tuto

Suppression de base de données : DROP
DATABASE

De la même façon, on peut supprimer une base de données

en utilisant la commande DROP DATABASE comme suit :

DROP DATABASE tuto;

Voir la liste des bases de données : SHOW
DATABASES

Et pour voir la liste des bases de données existantes, on

utilise la commande SHOW DATABASES. Sa syntaxe est
très simple sauf qu'il ne faut pas oublier le "S" de
DATABASES

SHOW DATABASES;
 Syntaxe SQL de création d'une table : CREATE TABLE
Toujours dans la définition de données (LDD), le mot-clé CREATE TABLE suivi de son nom nous permet
de définir une table.

La syntaxe SQL de création d'une table est la suivante :

CREATE TABLE Nom_table (colonne1 Type_champ1, colonne2 Type_champ2, colonne3 Type_champ3);

A la place de Nom_table on met le nom de la table et les colonne1, colonne2, etc. correspondent aux
désignations des champs. Autrement dit, il s'agit des libellés des colonnes.

Généralement, le nom attribué à la table doit (sur la plupart des SGBD) commencer par une lettre, et le
nombre de colonnes ne doit pas dépasser 25
Voici un exemple de création d'une table avec les type de champs
sur Mysql :

CREATE TABLE adherents

( num_adherent int,
Nom_adherent
varchar(30),
prenom_adherent
varchar(30), note
decimal(7,0));
 Types de données
Les types de données dans les bases

Dans la syntaxe proposée sur la création d'une table ci-dessus, les type_champ1, type_champ2, etc
désignent le type de données que va contenir le champ en question.

En gros, cela sert à envoyer au système le type de données afin qu'il alloue l'espace mémoire associé,
selon la taille des données. Le système ne va pas allouer le même espace pour une chaîne de
caractères que pour un nombre entier.

Voici une liste de type de données qui n'est pas exhaustive, vous trouverez notamment les types integer,
date et time mais aussi varchar, text et number en passant par timestamp et float.
 Type de données
hjjj
Type Description

NUMBER(n,[d]) Nombre de n chiffres [d (optionnel) après la virgule]

SMALLINT Entier signé de 16 bits

INTEGER Entier signé de 32 bits

FLOAT Nombre à virgule flottante

DATE Date format jj/mm/aa

TIME Heure

TIMESTAMP Date et Heure

CHAR(l) Chaîne de caractères de longueur fixe l (l<16383)

VARCHAR(n) Chaîne de caractères de n caractères maximum (n<16383)

Intégrité des données et clé primaire (unique, constraint, primary key)
 Contraintes d'intégrité et base de données
Une expression de contraintes d'intégrité permet de fixer des règles auparavant sur la modification d'une table. Autrement dit, elle
aide à s'assurer que les données saisies lors d'un lancement de requêtes utilisateur sont conformes aux données attendues.

Par exemple, une réponse doit être oui ou non, alors que l'utilisateur a saisi une autre réponse.

Nommer une contrainte d'intégrité

La clause CONSTRAINT suivi du nom de la contrainte permet de donner un nom à la contrainte. Ce nom s'affiche alors en cas de
non respect de la règle d'intégrité définie.

L'attribue d'un nom à l'aide la clause CONSTRAINT est alors avantageux sachant que le système peut le faire à notre place si
nous n'avons rien fixé au départ. Dans ce cas, il y a des fortes chances que le nom arbitraire attribué par le système ne soit
pas compréhensible en cas d'erreur et on ne saura pas facilement de quelle contrainte il s'agit.

Éviter les champs vides dans une table : NOT NULL

Il se peut qu'on ait des champs qui doivent vraiment contenir des valeurs. Dans ce cas on a deux solutions :
 • Soit forcer carrément la saisie d'un champ c'est-à-dire spécifier qu'un champ doit être saisi
• Soit attribuer une valeur par défaut au champ pour garantir que le champ ne sera pas vide Pour la première solution, le
mot clé NOT NULL permet de préciser que la saisie de ce champ est obligatoire

Requête SQL

CREATE TABLE adherents (

num_adherent int(5) NOT NULL,

nom_adherent varchar(5) NOT

NULL,

Prenom_adherent varchar(30)

NOT NULL;

Dans cet exemple, tous les champs de la table etudiant doivent être saisis. En optant pour la seconde solution, on fait appel à
la clause DEFAULT pour définir une valeur par défaut lorsque ce champ n'est pas saisi.
Faire des tests sur les valeurs
Unicité d'une valeur : UNIQUE
Pour tester l'unicité d'une valeur saisie pour un champ, on utilise la clause UNIQUE. En utilisant cette clause, on peut s'assurer que
toutes les valeurs d'une colonne d'une table seront alors différentes (par exemple, toutes les adresses email seront différentes)
Condition sur un champ : CHECK
Il est aussi possible de faire un test sur un champ à l'aide de la clause CHECK().
On lui attribue comme paramètre une condition logique entre les parenthèses.

Voyons cela plus clairement à l'aide d'un exemple.

Requête SQL
CREATE TABLE adherents

( num_adherent int NOT NULL ,

Nom_adherent varchar( 30) NOT NULL ,

prenom_adherent varchar( 30 ) NOT NULL ,

note int NOT NULL , CHECK (note <20);

Enregistrement et Clé primaire
Chaque ligne d'une table correspond à un enregistrement. Un des objectifs principaux d'une base de données est
d'éviter la redondance de données. Il ne doit pas y avoir de répétitions dans une base de données. Sinon on a ce
que l'on appelle des doublons. Un doublon est deux enregistrements (ou plus) identiques.

Voici un exemple : :

Exemple de table avec doublon

Prenom Nom

Gorgui Ndiaye

Gorgui Ndiaye

pour prendre garde à cela, on utilise une clé primaire qui sert d'identifiant unique pour chaque ligne. S'il y a
vraiment deux Gorgui qui viennent de Diourbel, on peut les différencier avec un autre champ qui sert alors de clé
primaire.
 Exemple de table avec identifiant

Num_adherent Prenom_adherent Nom_adherent

1 Gorgui Ndiaye

2 Gorgui Ndiaye

Le mot clé primary key permet de définir un champ qui

servira de clé primaire. Par exemple, dans la table etudiant, le
champ id_etudiant est une clé primaire qui sert d'identifiant unique
pour un étudiant. Autrement dit, deux étudiants différents ne
peuvent avoir le même numéro.
Requête SQL

CREATE TABLE adherents

( num_adherent int NOT NULL ,

Nom_adherent varchar( 30) NOT

NULL ,

prenom_adherent varchar( 30 ) NOT

NULL ,

note int NOT NULL , CHECK (

note <20),
PRIMARY KEY ( num_adherent));
On peut aussi facilement faire l'ajout d'une clé primaire en modifiant la
structure de la table. Autrement dit, si la table a été déjà créée, on peut
ajouter la clé primaire en utilisant après la commande ALTER TABLE ;

ALTER TABLE adherents ADD PRIMARY KEY(num_adherents) ;

On peut donc choisir un champ de la table pour définir la clé primaire.

Toutefois le choix doit être fait de manière très rigoureuse selon le
contexte. Par exemple, le prénom, ou la date de naissance ne peut pas
être choisi comme clé primaire puisque deux personnes différentes
peuvent avoir le même prénom, ou la même date de naissance et ceci
contredirait l'unicité de la clé primaire.
Modification d’une table (alter, add, modify et drop)
Modification d'une table en SQL avec ALTER

La clause ALTER nous permet de modifier certains éléments au niveau de la structure d'une table, notamment au
niveau des champs. Grâce à cette commande, on peut ajouter, modifier et supprimer un champ.

Ajout d'un champ dans une table : ALTER + ADD

Pour ajouter un champ à une table, on utilise la clause ALTER avec la clause ADD. La syntaxe est la suivante :
ALTER TABLE Nom_de_la_table ADD Nom_de_la_colonne Type_de_donnees;

Exemple : alter table adherents add email varchar (30) unique;

Modification d'un champ en SQL : ALTER + MODIFY

La clause ALTER associée à la clause MODIFY nous permet de modifier le type de données d'un champ comme
suit :
ALTER TABLE Nom_de_la_table

MODIFY Nom_de_la_colonne Type_de_donnees

Suppression d'un champ en SQL : ALTER + DROP
Toujours avec la clause ALTER mais en le couplant cette fois ci avec la clause DROP
COLUMN, on peut supprimer une colonne. Associée à la clause DROP COLUMN, la clause
ALTER permet de supprimer des colonnes. Voici la syntaxe :

ALTER TABLE Nom_de_la_table

DROP COLUMN Nom_de_la_colonne

A Noter :

Dans certains cas, la suppression d'une colonne est impossible (si elle fait l'objet d'une
contrainte d'intégrité, clé primaire par exemple, ou colonnes faisant partie d'une vue ou d'un
index.)
Renommer et effacer une table (rename, comment, drop)
Renommer une table : RENAME

Comme pour les fichiers dans un répertoire, il est également possible de renommer une table. Il suffit
d'employer la commande SQL RENAME comme suit :

RENAME TABLE Ancien_Nom TO Nouveau_Nom

Ajouter des commentaires à une table avec SQL : COMMENT

Il peut aussi être avantageux parfois de commenter une table. C'est la clause COMMENT qui permet cette
opération en leur ajoutant des descriptions ou des notes. La syntaxe de cette clause est :
alter table Nom_table
COMMENT = 'Commentaires';

On peut aussi commenter une colonne :

ALTER TABLE Nom_table

MODIFY Nom_colonne TYPE_COLONNE COMMENT 'Commentaires';
Suppression d'une table en SQL : DROP
Grâce à la clause DROP, on peut faire le ménage dans la base de données. Elle nous permet de
supprimer les tables qui ne servent plus.

Voici sa syntaxe :

DROP TABLE Nom_table

Avec la clause DROP, la table disparait entièrement. Pour supprimer uniquement les données tout
en conservant la structure de la table on utilise la commande TRUNCATE à la place.

Pour vider une table, son utilisation est simple :

TRUNCATE TABLE Nom_table

Insertion d’un enregistrement (insert)
Insertion de données en SQL avec INSERT
La commande INSERT permet d’insérer des données dans une table. Sachant
la syntaxe est la suivante :
INSERT INTO nom_table (colonne1, colonne2, colonne3, ...)
VALUES (valeur1, valeur2, valeur3, ...);

Exemple:

INSERT INTO adherents ( nom_adherant, prenom_adherant, note) VALUES (

‘Diouf', ‘Abdou', 17) ;
Si l'on veut insérer plusieurs lignes à la fois, il est possible de faire
comme ceci au lieu de répéter INSERT sur plusieurs lignes :
INSERT INTO `etudiant` (nom_adherant, prenom_adherant, note)
VALUES
( ‘Diouf', ‘Abdou', 17) ,
( ‘Diouf', ‘Abdou', 17) ,
( ‘Diouf', ‘Abdou', 17) ,
( ‘Diouf', ‘Abdou', 17) ,
( ‘Diouf', ‘Abdou', 17) ,
( ‘Diouf', ‘Abdou', 17) ,
(( ‘Diouf', ‘Abdou', 17),
( ‘Diouf', ‘Abdou', 17),
( ‘Diouf', ‘Abdou', 17) ;
Sélection, projection et doublon (select, distinct, count)
La commande SQL SELECT
Sélection
La commande en SQLpour
principale : SELECT
la manipulation de données est la clause SELECT. Cette dernière
nous permet d'interroger la base pour qu'elle nous retourne un résultat. On peut lui soumettre
certaines conditions à partir de différents critères que l'on définit nous-mêmes. Cela est possible
grâce à plusieurs options de la commande SELECT.

Afin de comprendre rapidement, voyons tout de suite un exemple simple de sélection de données :

Requête SQL

SELECT * FROM adherents;

Cette requête sélectionne toutes les données se trouvant dans la table "etudiant".
Il est possible également de limiter le nombre de résultats en utilisant le mot clé LIMIT.

Requête SQL

SELECT * FROM adherents LIMIT 3;

Toujours avec le mot clé LIMIT, on peut avoir une vue du style page par page du résultat. Il suffit de
préciser une deuxième valeur dans la clause LIMIT. Voici comment on fait pour afficher les 3 résultats à
partir de la 5ème ligne.

Requête SQL

SELECT * FROM adherents LIMIT 5, 3;

Le symbole * dans les requêtes : SELECT * FROM adherents veut dire qu'il faut inclure tous les champs.

Mais il est aussi possible de n'inclure que quelques colonnes seulement (prenom_adherant, nom_adherant,
note). Il suffit de lister les colonnes et de séparer par des virgules.
Exemple:
Requête SQL

SELECT prenom_adherant, nom_adherant, note FROM adherents;

Résultat
Gérer les doublons : DISTINCT
L'option DISTINCT permet d'éliminer les doublons c'est-à-dire de ne pas les prendre en compte pendant la sélection. Tandis que
l'option ALL permet de tout prendre en compte.
Avec doublons (ALL) Sans doublons (DISTINCT)
Voici un exemple de sélection en incluant tous les En utilisant distinct à la place de la clause ALL on
doublons élimine les doublons
Requête : Requête
SELECT ALL note FROM adherents ; SELECT DISTINCT domicile FROM etudiant;
1 1
10 10
10 4
4 8

4 5

8 2
5
2
1
2
Nombre de lignes de résultats : COUNT
La clause COUNT nous donne le nombre de résultats. Par exemple, essayons de compter le nombre
d'étudiants dans la table etudiant et mettons le nombre obtenu dans une colonne que l'on nommera
"nbetudiant"

Requête SQL

SELECT COUNT( * ) AS nbadherents FROM

adherents ;

nbadherents
Résultat :
13

Au total, la table "adherents" contient donc 13 résultats. Ces différents critères ne sont
pas valables que pour la sélection. Mais on les utilise aussi pour la modification et
suppression de ligne.
 Conditions (where, between, joker)

Conditions et restriction en SQL

Utilisation simple de WHERE dans une requête

On peut utiliser WHERE de façon très simple . Pour faire une restriction sur les valeurs manquantes, en
utilisant WHERE dans le même exemple .

On peut donc avoir une requête de la forme :

SELECT * FROM adherents WHERE note IS NULL;

Ceci nous donne la liste des étudiants dont la moyenne n'est pas renseignée. A l'inverse, avec le prédicat
IS NOT NULL, la requête nous renvoie la liste des étudiants pour lesquels on a renseigné la moyenne.

SELECT * FROM adherents WHERE note IS NOT NULL;

On peut émettre une condition exprimée avec les comparateurs arithmétiques suivants :

○ = : Égal à
○ != : Différent de (souvent aussi écrit <>)
○ > : Supérieur à
○ < : Inférieur à
○ >= : Supérieur ou égal à
○ <= : Inférieur ou égal à
○ <> : Différent de (équivalent à !=)
○ !> : Non supérieur à (rarement utilisé, dépend du SGBD)
○ !< : Non inférieur à (rarement utilisé, dépend du SGBD)

On peut alors ne sélectionner qu'un certain nombre de lignes qui ont les valeurs
indiquées.
On peut alors ne sélectionner qu'un certain nombre de lignes qui ont les valeurs indiquées.

Ainsi, pour avoir juste la liste des étudiants ayant la moyenne supérieure à 10 on utilisera
cette requête :

SELECT * FROM adherents WHERE note >=10;

Resultat d’une requete sql avec where
 Plusieurs conditions : AND, OR et NOT
A l'aide des opérateurs logiques (AND, OR, NOT), on peut associer plusieurs conditions.

Sachant que AND veut dire ET, OR veut dire OU et NOT veut dire NON.

Si l'on veut par exemple avoir la liste des adherents qui ont eu une moyenne supérieure ou égale à
6 et inférieure ou égale à 10, voici la requête correspondante.

Requête SQL :

SELECT * FROM adherents WHERE note >=10 AND note <=12

 Restriction sur un intervalle : BETWEEN
Traduite sous forme d'intervalle, la condition ci-dessus devient plus simple.

Ceci est possible avec le prédicat BETWEEN qui permet de vérifier qu'une valeur se trouve dans un intervalle. Voyons
comment cela est simple dans l'exemple ci-dessous :

SELECT * FROM adherents WHERE note BETWEEN 6 AND 13;

A côté, il y a aussi un autre prédicat : IN qui est pareil sauf qu'il permet de spécifier une liste de valeurs à la place de
l'intervalle.

Comparaison de chaîne avec % et _

Jusqu' à présent nous avons manipulé des chiffres, mais de la même façon, on peut aussi opérer sur des chaînes de
caractères. Des caractères appelés jokers seront utilisés afin de spécifier le critère. Les caractères en question sont :

○ Le caractère % : Remplace une séquence de caractères (peut être nulle)

○ Le caractère _ : Remplace une caractère
Pour avoir la liste des adherants dont le nom commence par un f on a :
Exemple :
Requête SQL

SELECT * FROM adherents WHERE nom_adherant LIKE("f%");

Résultat

Résultat d'une requête SQL avec WHERE et LIKE

On peut aussi combiner les jokers, et on obtient par exemple la liste des
adherents qui ont un "U” en deuxième position dans leur nom (nDiaye,
nDao)

SELECT * FROM adherents WHERE nom_adherant LIKE("_D%");

Modifier un enregistrement (update)
 Modification d'un d'enregistrement en SQL : UPDATE
Nous ne l'avons pas encore signalé, mais il existe la commande UPDATE ...
SET pour la mise à jour d'une ligne dans une table de votre base de données.
L'utilisation d'UPDATE dans une requête SQL est assez simple comme vous
allez le voir.

Elle repose sur l'utilisation du mot clef UPDATE et de SET.

Exemple d'une requête UPDATE

Prenons la table suivante :
Table Adherents
Par exemple pour mettre à jour la deuxième ligne de la table
adherents, en changeant la note en 10 de l’adherents portant le
num_adherant 2, voici la requête correspondante :

UPDATE adherents SET note = '10' WHERE num_adherant =2 ;

Supprimer un enregistrement (delete)
S'il est possible de modifier un enregistrement d'une table de base de données avec la
commande UPDATE, il est aussi possible d'en supprimer un avec DELETE. Ce type de
requête SQL est très simple comme nous allons le voir.

Exemple d'une requête DELETE

Par supprimer la deuxième ligne de la table adherents où l’adherent porte le

num_adherant 2, voici la requête correspondante :

DELETE FROM adherents

WHERE num_adherant=2 ;
Calcul SQL : Moyenne et somme (avg, sum, max, min)
 Fonction de calcul en SQL
Il est possible d'utiliser de nombreuses fonctions dans vos requêtes afin de faire des calcules simples ou complexes entre une
ou plusieurs colonnes.

Calcul sur une colonne

On peut aussi effectuer différents calculs sur une colonne ou sur un regroupement. Nous verrons dans ce cours ce qu'est un
regroupement.

Calcul de Moyenne : AVG

Par exemple, procédons au calcul de la moyenne des notes des adherents à partir de notre table adherent. Pour cela, on utilise la
clause AVG sur la colonne note.

Requête : SELECT AVG( note ) AS moyennenote FROM adherents ;

Résultat

moyenneclasse

14.7692
On peut aussi calculer la somme des valeurs d'une colonne à l'aide de SUM

Requête :

SELECT SUM( note) AS totalnote FROM adherents ;

Résultat

totalnote

192

Maximum et Minimum : MAX et MIN

Pour connaître la meilleure note obtenue, on peut sélectionner la valeur maximum de la colonne note

Requête : SELECT MAX( note ) AS max FROM adherents

Resultat max

19
De la même façon, on peut avoir le minimum, il faut juste mettre MIN au lieu de MAX.

Requête :

SELECT MIN( note ) AS min FROM adherents

min

10
Tri (order by asc, desc)
 Trier les résultats d'une requête avec ORDER BY
ORDER BY ASC et DESC
Toujours sur l'exemple des adherents, nous pouvons faire des tris sur la note des
adherents à l'aide du mot clé ORDER BY.

L'option ASC ou DESC permet d'indiquer l'ordre des tris. ASC correspond alors
à un tri croissant et DESC à un tri décroissant.
Nous allons sélectionner les prénoms et les notes en classant le résultat de la
note par ordre décroissant.

Requête SQL :

SELECT prenom, note FROM adherents ORDER BY note ASC ;

Prenons par exemple cette table :

prenom moyenne

Gorgui 17

Thierno 11

Issa 17

Samba Laobé 19

Ousmane 14

Khadim 19

Cheikh 10

Boubacar 18

Mansour 16

Pape Oumar 13
Résultat d'une requête SQL avec ORDER BY ASC

prenom moyenne

Cheikh 10

Thierno 11

Pape Oumar 13

Ousmane 14

Mansour 16

Gorgui 17

Issa 17

Boubacar 18

Samba Laobé 19

Khadim 19
 SOUS REQUÊTES

● Consiste à exécuter une requête à l’intérieur d’une autre requête

● Souvent utilisée au sein d’une clause WHERE ou de HAVING pour remplacer une
ou plusieurs constante
 SOUS REQUÊTES

Exemple :
● Supposons que nous voulions trouver les films dont le tarif de location est
supérieur au taux de location moyen
● Nous pouvons le faire en deux étapes:
a. Rechercher le tarif de location moyen à l’aide de l’instruction SELECT et de la
fonction moyenne (AVG)
b. Utiliser le résultat de première requête dans le deuxième instruction Select pour
trouver les films que vous souhaitez.
 Sous requêtes
• Syntaxe : Les deux étapes Première étape

• -- sélectionner la moyenne des notes des adherents

• select avg(note) from adherents;

• Deuxième étape :
• /* sélectionner les prénoms et les noms des adhérents qui ont des notes supérieur à la
moyenne des notes*/

select prenom_adherant, nom_adherant from

adherents
where note > 3.90;
 Sous requêtes
• Au lieu de faire le deux étapes que nous venons d’énumérer ci-dessus,
nous allons faire une sous-requête :

● Pour construire une sous-requête, nous plaçons la seconde requête

entre parenthèses et nous l’utilisons dans le clause WHERE en tant
qu’expression
● Syntaxe :
select film_id, title, rental_rate from film
where rental_rate > (select avg(rental_rate) from film);
Jointure
Jointure et produit cartésien
Contrairement aux opérations ensemblistes, la jointure peut s'exécuter sur deux tables n'ayant pas la
même structure. Elle permet de sélectionner des données dans deux tables en même temps. Il
s'agit d'un produit cartésien de deux tables. Les clauses utilisées sont les mêmes que celle étudiées
précédemment.

Toutefois, comme il s'agit ici de plusieurs tables, il s'avère nécessaire de préciser le nom des tables d'où
provient chaque champ. Chaque fois que l'on indique un champ on met alors le nom de la table devant
le nom du champ et un point sépare les deux comme suit : table1.champ1

Il existe plusieurs types de Jointure qui sont :

● INNER JOIN
● LEFT JOIN
● RIGHT JOIN
● FULL JOIN
 Types de Jointure :

Qu'est-ce qu'un INNER JOIN ?

● Un INNER JOIN ne retourne que les lignes qui ont une correspondance dans
les deux tables.
● Si une ligne dans l’une des tables n’a pas de correspondance dans l’autre, elle ne
sera pas incluse dans le résultat.
● En SQL, JOIN tout court est un raccourci pour dir INNER JOIN.
Types de Jointure :
 Exemple :
Sélectionner dans la base de données gestion_ecole que nous avons créer:
matricule, prenom, nom, de la table eleves et nom_classe niveau de la table
classes.
Requête :

Select
eleves.matricule,
eleves.prenom,
eleves.nom,
classes.nom_classe,
classes.niveau
From eleves
Inner Join classes on eleves.code_classe=classes.code_classe;
Nous pouvons toujours sur cette même requête de jointure ajouter une condition
“WHERE”

Exemple : sélectionner les éleves avec leur matricule, leur prenom, leur nom, leur classe et
leur niveau de la table eleves en jointure avec la table classe ensuite posons la condition
avec “WHERE” pour afficher seulement les éléves qui ont des prénom commençant par T.
Requête :
Select

eleves.matricule,

eleves.prenom,

eleves.nom,

classes.nom_classe,

classes.niveau

From eleves

Inner Join classes on eleves.code_classe=classes.code_classe

where prenom like ("T%");