INFORMATIQUE APPLIQUÉE
3- LE LANGAGE SQL
Pr. Mohamed DAOUDI
Année universitaire 2024/2025
PRÉSENTATION
SQL (pour langage de requêtes structuré) est un langage déclaratif destiné à la manipulation de bases de
données au sein des SGBD et plus particulièrement des SGBDR.
SQL est un langage déclaratif, il n'est donc pas a proprement parlé un langage de programmation, mais plutôt
une interface standard pour accéder aux bases de données.
SQL est un langage de définition de données (LDD, ou en anglais DDL Data Definition Language), un langage
de manipulation de données (LMD, ou en anglais DML, Data Manipulation Language), et un langage de
contrôle de données (LCD, ou en anglais DCL, Data Control Language), pour les bases de données
relationnelles.
▪ Le Langage de Définition de Données pour créer et supprimer des objets dans la base de données (tables,
contraintes d'intégrité, vues, etc.).
Exemple de commandes : CREATE DROP ALTER
▪ Le Langage de Contrôle de Données pour gérer les droits sur les objets de la base (création des utilisateurs
et affectation de leurs droits).
Exemple de commandes : GRANT REVOKE
▪ Le Langage de Manipulation de Données pour la recherche, l'insertion, la mise à jour et la suppression de
données. Le LMD est basé sur les opérateurs relationnels, auxquels sont ajoutés des fonctions de calcul
d'agrégats et des instructions pour réaliser les opérations d'insertion, mise à jour et suppression.
Exemple de commandes : INSERT UPDATE DELETE SELECT
▪ Le Langage de Contrôle de Transaction pour la gestion des transactions (validation ou annulation de
modifications de données dans la BD)
Exemple de commandes : C O M M I T ROLLBACK
CRÉER UNE NOUVELLE BASE ET SON JEU DE DONNÉES
La création d’une base de données en SQL est possible en ligne de commande. Même si les systèmes de
gestion de base de données (SGBD) sont souvent utilisés pour créer une base, il convient de connaître la
commande à utiliser, qui est très simple.
Pour créer une base de données qui sera appelé “ma_base” il suffit d’utiliser la requête suivante :
CREATE DATABASE ma_base
L’option IF NOT EXISTS permet juste de ne pas retourner d’erreur si une base du même nom existe déjà.
La base de données ne sera pas écrasée.
CREATE DATABASE IF NOT EXISTS ma_base
Chaque base de données a un jeu de caractères de base de données et un classement de base de
données. Les instructions CREATE DATABASE et ALTER DATABASE ont des clauses facultatives pour
spécifier le jeu de caractères et le classement de la base de données:
CREATE DATABASE `nom_base` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
CRÉER UNE NOUVELLE TABLE
La commande CREATE TABLE permet de créer une table en SQL. Un tableau est une entité qui est contenu
dans une base de données pour stocker des données ordonnées dans des colonnes. La création d’une table
sert à définir les colonnes et le type de données qui seront contenus dans chacun des colonne (entier,
chaîne de caractères, date, valeur binaire … ) . La syntaxe générale pour créer une table est la suivante :
CREATE TABLE nom_de_la_table
( colonne1 type_donnees,
colonne2 type_donnees,
colonne3 type_donnees,
colonne4 type_donnees )
Dans cette requête, 4 colonnes ont été définies. Le mot-clé “type_donnees” sera à remplacer par un mot-clé
pour définir le type de données (INT, DATE, TEXT … ) . Pour chaque colonne, il est également possible de
définir des options telles que (liste non-exhaustive):
▪ NOT NULL : empêche d’enregistrer une valeur nulle pour une colonne.
▪ DEFAULT : attribuer une valeur par défaut si aucune donnée n’est indiquée pour cette colonne lors de
l’ajout d’une ligne dans la table.
▪ PRIMARY KEY : indiquer si cette colonne est considérée comme clé primaire pour un index.
PRIMARY KEY & AUTO_INCREMENT
Dans le langage SQL la “PRIMARY KEY”, autrement la clé primaire, permet d’identifier chaque
enregistrement dans une table de base de données. Chaque enregistrement de cette clé primaire doit être
UNIQUE et ne doit pas contenir de valeur NULL.
La commande AUTO_INCREMENT est utilisée dans le langage SQL afin de spécifier qu’une colonne
numérique avec une clé primaire (PRIMARY KEY) sera incrémentée automatiquement à chaque ajout
d’enregistrement dans celle-ci.
La requête SQL ci-dessous est un exemple concret d’usage de cette auto-incrémentation et la clé primaire :
CREATE TABLE `nom_de la_table` (
id INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
[...]
);
Par défaut, l’auto-increment débute à la valeur “1” et s’incrémentera de un pour chaque nouvel
enregistrement.
LE FOREIGN KEY
La CLÉ ÉTRANGÈRE (FOREIGN KEY ) est une clé utilisée pour lier deux tables.
Une CLÉ ÉTRANGÈRE est un champ (ou une collection de champs) dans une table qui fait référence à la
CLÉ PRIMAIRE dans une autre table.
La table contenant la clé étrangère est appelée table enfant et la table contenant la clé candidate est
appelée table référencée.
Exemple:
CREATE TABLE factures(
IDFacture int NOT NULL,
NumFacture int NOT NULL,
IDPersonne int,
PRIMARY KEY (IDFacture ),
FOREIGN KEY (IDPersonne) REFERENCES Personne(IDPersonne )
);
L'INSTRUCTION INSERT INTO
L'instruction INSERT INTO est utilisée pour insérer de nouveaux enregistrements dans une table.
Il est possible d'écrire l'instruction INSERT INTO de deux manières.
La première méthode spécifie à la fois les noms des colonnes et les valeurs à insérer:
INSERT INTO table_name (column1, column2, column3, ...) VALUES (value1, value2, value3, ...);
Si vous ajoutez des valeurs pour toutes les colonnes de la table, vous n'avez pas besoin de spécifier les
noms de colonne dans la requête SQL. Cependant, assurez-vous que l'ordre des valeurs est dans le même
ordre que les colonnes du tableau. La syntaxe INSERT INTO serait la suivante:
INSERT INTO table_name VALUES (value1, value2, value3, ...);
LA CLAUSE SELECT
L’utilisation la plus courante de SQL consiste à lire des données issues de la base de données. Cela
s’effectue grâce à la commande SELECT, qui retourne des enregistrements dans un tableau de résultat.
Cette commande peut sélectionner une ou plusieurs colonnes d’une table.
L’utilisation basique de cette commande s’effectue de la maniè<re suivante:
SELECT nom_du_champ1,nom_du_champ2,…. FROM nom_du_tableau
Cette requête SQL va sélectionner (SELECT) le champ “nom_du_champ1”, le champ “nom_du_champ2”,
..etc provenant (FROM) du tableau appelé “nom_du_tableau”.
Il est possible de retourner automatiquement toutes les colonnes d’un tableau sans avoir à connaître le
nom de toutes les colonnes. Au lieu de lister toutes les colonnes, il faut simplement utiliser le caractère “ * ”
(étoile). C’est un joker qui permet de sélectionner toutes les colonnes. Il s’utilise de la manière suivante:
SELECT * FROM nom_du_tableau
SELECT DISTINCT
L'instruction SELECT DISTINCT est utilisée pour renvoyer uniquement des valeurs distinctes (différentes).
À l'intérieur d'un tableau, une colonne contient souvent de nombreuses valeurs en double; et parfois vous
voulez seulement lister les différentes valeurs (distinctes).
Exemple :
SELECT DISTINCT column1, column2, ... FROM table_name;
LA CLAUSE LIMIT
La clause LIMIT est à utiliser dans une requête SQL pour spécifier le nombre maximum de résultats que
l’ont souhaite obtenir. Cette clause est souvent associée à un OFFSET, c’est-à-dire effectuer un décalage
sur le jeu de résultat. Ces 2 clauses permettent par exemple d’effectuer des systèmes de pagination .
La syntaxe commune aux principaux systèmes de gestion de bases de données est la suivante :
SELECT * FROM table LIMIT 10
Cette requête permet de récupérer seulement les 10 premiers résultats d’une table.
Limit et Offset avec MySQL
La syntaxe avec MySQL est légèrement différente :
SELECT * FROM table LIMIT 5, 10;
Cette requête retourne les enregistrements 6 à 15 d’une table. Le premier nombre est l’OFFSET tandis que
le suivant est la limite.
LA CLAUSE WHERE
La commande WHERE dans une requête SQL permet d’extraire les lignes d’une base de données qui
respectent une condition. Cela permet d’obtenir uniquement les informations désirées.
La commande WHERE s’utilise en complément à une requête utilisant SELECT. La façon la plus simple de
l’utiliser est la suivante:
SELECT nom_colonnes FROM nom_table WHERE condition
SQL AND & OR
Une requête SQL peut être restreinte à l’aide de la condition WHERE. Les opérateurs logiques AND et OR
peuvent être utilisées au sein de la commande WHERE pour combiner des conditions.
Les opérateurs sont à ajoutés dans la condition WHERE. Ils peuvent être combinés à l’infini pour filtrer les
données comme souhaités.
L’opérateur AND permet de s’assurer que la condition1 ET la condition2 sont vrai :
SELECT nom_colonnes FROM nom_table WHERE condition1 AND condition2
L’opérateur OR vérifie quant à lui que la condition1 OU la condition2 est vrai :
SELECT nom_colonnes FROM nom_table WHERE condition1 OR condition2
Ces opérateurs peuvent être combinés à l’infini et mélangés. L’exemple ci-dessous filtre les résultats de la
table “nom_table” si condition1 ET condition2 OU condition3 est vrai :
SELECT nom_colonnes FROM nom_table WHERE condition1 AND (condition2 OR condition3)
LES OPÉRATEURS DE COMPARAISON & LES COMPARAISONS À NULL
Il existe plusieurs opérateurs de comparaisons. La liste ci-jointe présente quelques uns des opérateurs les
plus couramment utilisés.
Opérateur Description
= Égale
<> Pas égale
!= Pas égale
> Supérieur à
< Inférieur à
>= Supérieur ou égale à
<= Inférieur ou égale à
IN Liste de plusieurs valeurs possibles
BETWEEN Valeur comprise dans un intervalle donnée (utile pour les nombres ou dates)
LIKE Recherche en spécifiant le début, milieu ou fin d'un mot.
IS NULL Valeur est nulle
IS NOT NULL Valeur n'est pas nulle
LA CLAUSE BETWEEN... AND
L’opérateur BETWEEN est utilisé dans une requête SQL pour sélectionner un intervalle de données dans
une requête utilisant WHERE. L’intervalle peut être constitué de chaînes de caractères, de nombres ou de
dates. Par exemple, récupérer uniquement les enregistrements entre 2 dates définies.
L’utilisation de la commande BETWEEN s’effectue de la manière suivante :
SELECT * FROM table WHERE nom_colonne BETWEEN 'valeur1' AND 'valeur2‘
La requête ci-dessus retournera toutes les lignes dont la valeur de la colonne “nom_colonne” sera
comprise entre valeur1 et valeur2.
LA CLAUSE IN (...)
L’opérateur logique IN dans SQL s’utilise avec la commande WHERE pour vérifier si une colonne est
égale à une des valeurs comprises dans set de valeurs déterminés. C’est une méthode simple pour
vérifier si une colonne est égale à une valeur OU une autre valeur OU une autre valeur et ainsi de suite.
Pour chercher toutes les lignes où la colonne “nom_colonne” est égale à ‘valeur 1’ OU ‘valeur 2’ ou ‘valeur
3’, il est possible d’utiliser la syntaxe suivante:
SELECT nom_colonne FROM table WHERE nom_colonne IN ( valeur1, valeur2, valeur3, ... )
Cette syntaxe peut être associée à l’opérateur NOT pour recherche toutes les lignes qui ne sont pas
égales à l’une des valeurs stipulées.
Pour chercher toutes les lignes où la colonne “nom_colonne” est différent à ‘valeur 1’ ET ‘valeur 2’ ET
‘valeur 3’, il est possible d’utiliser la syntaxe suivante:
SELECT nom_colonne FROM table WHERE nom_colonne NOT IN ( valeur1, valeur2, valeur3, ... )
L'OPÉRATEUR DE COMPARAISON LIKE
L’opérateur LIKE est utilisé dans la clause WHERE des requêtes SQL. C e mot-clé permet d’effectuer une recherche
sur un modèle particulier. Il est par exemple possible de rechercher les enregistrements dont la valeur d’une
colonne commence par telle ou telle lettre. Les modèles de recherches sont multiples.
La syntaxe à utiliser pour utiliser l’opérateur LIKE est la suivante :
SELECT * FROM table WHERE colonne LIKE modele
Dans cet exemple le “modèle” n’a pas été défini, mais il ressemble très généralement à l’un des exemples suivants:
▪ LIKE ‘%a’ : le caractère “ % ” est un caractère joker qui remplace tous les autres caractères. Ainsi, ce modèle permet de
rechercher toutes les chaines de caractère qui se termine par un “a”.
▪ LIKE ‘a%’ : ce modèle permet de rechercher toutes les lignes de “colonne” qui commence par un “a”.
▪ LIKE ‘%a%’ : ce modèle est utilisé pour rechercher tous les enregistrements qui utilisent le caractère “a”.
▪ LIKE ‘pa%on’ : ce modèle permet de rechercher les chaines qui commence par “pa” et qui se terminent par “on”.
▪ LIKE ‘ a _c ’ : peu utilisé, le caractère “ _ ” (underscore) peut être remplacé par n’importe quel caractère, mais un seul
caractère uniquement (alors que le symbole pourcentage “ % ” peut être remplacé par un nombre incalculable
de caractères .
LES ALIAS DE COLONNES
Dans le langage SQL il est possible d’utiliser des alias pour renommer temporairement une colonne ou une
table dans une requête. Cette astuce est particulièrement utile pour faciliter la lecture des requêtes.
Alias sur une colonne
Permet de renommer le nom d’une colonne dans les résultats d’une requête SQL. C’est pratique pour avoir un
nom facilement identifiable dans une application qui doit ensuite exploiter les résultats d’une recherche.
La syntaxe pour renommer une colonne de colonne1 à c1 est la suivante:
SELECT colonne1 AS c1, colonne2 FROM `table`
ou SELECT colonne1 c1, colonne2 FROM `table`
Alias sur une table
Permet d’attribuer un autre nom à une table dans une requête SQL. Cela peut aider à avoir des noms plus
courts, plus simple et plus facilement compréhensible. Ceci est particulièrement vrai lorsqu’il y a des jointures.
La syntaxe pour renommer une table dans une requête est la suivante:
SELECT * FROM `nom_table` AS t1
Ou SELECT * FROM `nom_table` t1
LA CLAUSE ORDER BY
La commande ORDER BY permet de trier les lignes dans un résultat d’une requête SQL. Il est possible de
trier les données sur une ou plusieurs colonnes, par ordre ascendant ou descendant.
Une requête où l’on souhaite filtrer l’ordre des résultats utilise la commande ORDER BY de la sorte :
SELECT colonne1, colonne2 FROM table ORDER BY colonne1
Par défaut les résultats sont classés par ordre ascendant, toutefois il est possible d’inverser l’ordre en
utilisant le suffixe DESC après le nom de la colonne. Par ailleurs, il est possible de trier sur plusieurs
colonnes en les séparant par une virgule. Une requête plus élaborée ressemblerait à cela :
SELECT colonne1, colonne2, colonne3
FROM table
ORDER BY colonne1 DESC, colonne2 ASC
LES F ON CT ION S D'AGRÉGATION
Les fonctions d’agrégation dans le langage SQL permettent d’effectuer des opérations statistiques sur un
ensemble d’enregistrement. Étant donné que ces fonctions s’appliquent à plusieurs lignes en même temps,
elles permettent des opérations qui servent à récupérer l’enregistrement le plus petit, le plus grand ou bien
encore de déterminer la valeur moyenne sur plusieurs enregistrements.
LES F ON CT ION S D'AGRÉGATION
Les fonctions d’agrégation sont des fonctions idéales pour effectuer quelques statistiques de bases
sur des tables. Les principales fonctions sont les suivantes :
▪ AVG() pour calculer la moyenne sur un ensemble d’enregistrement
▪ COUNT() pour compter le nombre d’enregistrement sur une table ou une colonne distincte
▪ MAX() pour récupérer la valeur maximum d’une colonne sur un ensemble de ligne. Cela
s’applique à la fois pour des données numériques ou alphanumérique
▪ MIN() pour récupérer la valeur minimum de la même manière que MAX()
▪ SUM() pour calculer la somme sur un ensemble d’enregistrement
LA CLAUSE GROUP BY
La commande GROUP BY est utilisée en SQL pour grouper plusieurs résultats et utiliser une fonction de
totaux sur un groupe de résultat. Sur une table qui contient toutes les ventes d’un magasin, il est par
exemple possible de liste regrouper les ventes par clients identiques et d’obtenir le coût total des achats
pour chaque client.
Syntaxe d’utilisation de GROUP BY
De façon générale, la commande GROUP BY s’utilise de la façon suivante
SELECT colonne1, fonction(colonne2)
FROM table
GROUP BY colonne1
A noter : cette commande doit toujours s’utiliser après la commande WHERE et avant la commande HAVING.
LA CLAUSE HAVING
La condition HAVING en SQL est presque similaire à WHERE à la seule différence que HAVING permet de filtrer
en utilisant des fonctions telles que SUM(), COUNT(), AVG(), MIN() ou MAX().
L’utilisation de HAVING s’utilise de la manière suivante :
SELECT colonne1, SUM(colonne2)
FROM nom_table
GROUP BY colonne1
HAVING fonction(colonne2) operateur valeur
Cela permet donc de SÉLECTIONNER les colonnes de la table “nom_table” en GROUPANT les lignes qui ont des
valeurs identiques sur la colonne “colonne1” et que la condition de HAVING soit respectée.
Important : HAVING est très souvent utilisé en même temps que GROUP BY bien que ce ne soit pas obligatoire.
LES JOINTURES E N SQL
Les jointures en SQL permettent d’associer plusieurs tables dans une même requête. Cela
permet d’exploiter la puissance des bases de données relationnelles pour obtenir des résultats
qui combinent les données de plusieurs tables de manière efficace.
En général, les jointures consistent à associer des lignes de 2 tables en associant l’égalité des
valeurs d’une colonne d’une première table par rapport à la valeur d’une colonne d’une seconde
table.
EMPLOYEE
idEmp nomEmp IdDep DEPARTEMNT
1 Rachid … 3 IdDep NomDep
2 Kamal … 1 1 Achats
3 Amal … 1 2 Ventes
4 Nadia … . 3 3 Marketing
SQL INNER JOIN
Dans le langage SQL la commande INNER JOIN, aussi appelée EQUIJOIN, est un type de jointures très
communes pour lier plusieurs tables entre-elles. Cette commande retourne les enregistrements lorsqu’il y a
au moins une ligne dans chaque colonne qui correspond à la condition.
Syntaxe
Pour utiliser ce type de jointure il convient d’utiliser une requête SQL avec cette syntaxe :
SELECT *
FROM table1
INNER JOIN table2 ON table1.id = table2.fk_id
La syntaxe ci-dessus stipule qu’il faut sélectionner les enregistrements des tables table1 et table2 lorsque les
données de la colonne“id” de table1 est égal aux données de la colonne fk_id de table2.
SQL CROSS JOIN
Dans le langage SQL, la commande CROSS JOIN est un type de jointure sur 2 tables SQL qui
permet de retourner le produit cartésien. Autrement dit, cela permet de retourner chaque ligne
d’une table avec chaque ligne d’une autre table. Ainsi effectuer le produit cartésien d’une table
A qui contient 30 résultats avec une table B de 40 résultats va produire 1200 résultats (30 x 40 =
1200). En général la commande CROSS JOIN est combinée avec la commande WHERE pour filtrer
les résultats qui respectent certaines conditions.
Syntaxe
Pour effectuer une jointure avec CROSS JOIN, il convient d’effectuer une requête SQL respectant
la syntaxe suivante:
SELECT * FROM table1
CROSS JOIN table2
C e t t e s y n t a x e permet d’associer tous les résultats de table1 avec chacun des résultats de table2.
SQL LEFT JOIN
Dans le langage SQL, la commande LEFT JOIN (aussi appelée LEFT OUTER JOIN) est un type de jointure entre
2 tables. Cela permet de lister tous les résultats de la table de gauche (left = gauche) même s’il n’y a pas de
correspondance dans la deuxième table.
Syntaxe:
Pour lister les enregistrements de table1, même s’il n’y a pas de correspondance avec table2, il
convient d’effectuer une requête SQL utilisant la syntaxe suivante.
SELECT * FROM table1
LEFT JOIN table2 ON table1.id = table2.fk_id
Cette requête est particulièrement intéressante pour récupérer les informations de table1 tout en récupérant
les données associées, même s’il n’y a pas de correspondance avec table2. A savoir, s’il n’y a pas de
correspondance les colonnes de table2 vaudront toutes NULL.
SQL RIGHT JOIN
En SQL, la commande RIGHT JOIN (ou RIGHT OUTER JOIN) est un type de jointure entre 2 tables qui permet
de retourner tous les enregistrements de la table de droite (right = droite) même s’il n’y a pas de
correspondance avec la table de gauche. S’il y a un enregistrement de la table de droite qui ne trouve pas de
correspondance dans la table de gauche, alors les colonnes de la table de gauche auront NULL pour valeur.
Syntaxe
L’utilisation de cette commande SQL s’effectue de la façon suivante:
SELECT *
FROM table1
RIGHT JOIN table2 ON table1.id = table2.fk_id
Cette syntaxe stipule qu’il faut lister toutes les lignes du tableau table2 (tableau de droite) et afficher les
données associées du tableau table1 s’il y a une correspondance entre ID de table1 et FK_ID de table2. S’il
n’y a pas de correspondance, l’enregistrement de table2 sera affiché et les colonnes de table1 vaudront
toutes NULL.
SQL FULL JOIN
Dans le langage SQL, la commande FULL JOIN (ou FULL OUTER JOIN) permet de faire une jointure entre 2
tables. L’utilisation de cette commande permet de combiner les résultats des 2 tables, les associer entre eux
grâce à une condition et remplir avec des valeurs NULL si la condition n’est pas respectée.
Syntaxe
Pour retourner les enregistrements de table1 et table2, il convient d’utiliser une requête SQL avec une
syntaxe telle que celle-ci:
SELECT *
FROM table1
FULL JOIN table2 ON table1.id = table2.fk_id
La condition présentée ici consiste à lier les tables sur un identifiant, mais la condition peut être définie sur
d’autres champs.
SQL SELF JOIN
En SQL, un SELF JOIN correspond à une jointure d’une table avec elle-même. C e type de requête n’est pas si
commun mais très pratique dans le cas où une table lie des informations avec des enregistrements de la
même table.
Syntaxe
Pour effectuer un SELF JOIN, la syntaxe de la requête SQL est la suivante:
SELECT t1.nom_colonne1, t1.nom_colonne2, t2.nom_colonne1, t2.nom_colonne2
FROM table as t1
LEFT OUTER JOIN table as t2 ON t2.fk_id = t1.id
Ici la jointure est effectuée avec un LEFT JOIN, mais il est aussi possible de l’effectuer avec d’autres types de
jointures.
SQL NATURAL JOIN
Dans le langage SQL, la commande NATURAL JOIN permet de faire une jointure naturelle entre 2 tables. Cette
jointure s’effectue à la condition qu’il y a des colonnes du même nom et de même type dans les 2 tables. Le
résultat d’une jointure naturelle est la création d’un tableau avec autant de lignes qu’il y a de paires
correspondant à l’association des colonnes de même nom.
Syntaxe
La jointure naturelle de 2 tables peut s’effectuer facilement, comme le montre la requête SQL suivante :
SELECT *
FROM table1
NATURAL JOIN table2
L’avantage d’un NATURAL JOIN c’est qu’il n’y a pas besoin d’utiliser la clause ON.
SQL UNION
La commande UNION de SQL permet de mettre bout-à-bout les résultats de plusieurs requêtes utilisant elles-
même la commande SELECT. C’est donc une commande qui permet de concaténer les résultats de 2
requêtes ou plus. Pour l’utiliser il est nécessaire que chacune des requêtes à concaténer retournes le même
nombre de colonnes, avec les mêmes types de données et dans le même ordre.
A savoir : par défaut, les enregistrements exactement identiques ne seront pas répétés dans les résultats. Pour
effectuer une union dans laquelle même les lignes dupliquées sont affichées il faut plutôt utiliser la
commande UNION ALL.
Syntaxe
La syntaxe pour unir les résultats de 2 tableaux sans afficher les doublons est la suivante:
SELECT * FROM table1
UNION
SELECT * FROM table2
LES SOUS-REQUÊTES
Dans le langage SQL une sous-requête (aussi appelé “requête imbriquée” ou “requête en cascade”) consiste
à exécuter une requête à l’intérieur d’une autre requête. Une requête imbriquée est souvent utilisée au sein
d’une clause WHERE ou de HAVING pou remplacer une ou plusieurs constantes.
Il y a plusieurs façons d’utiliser les sous-requêtes. De cette façon il y a plusieurs syntaxes envisageables pour
utiliser des requêtes dans des requêtes.
Requête imbriquée qui retourne un seul résultat
L’exemple ci-dessous est un exemple typique d’une sous-requête qui retourne un seul résultat à la requête
principale.
SELECT * FROM `table`
WHERE `nom_colonne`= (
SELECT `valeur`
FROM `table2`
LIMIT 1
)
Cet exemple montre une requête interne (celle sur “table2”) qui renvoi une seule valeur. La requête externe
quant à elle, va chercher les résultats de “table” et filtre les résultats à partir de la valeur retournée par la
requête interne.
A noter : il est possible d’utiliser n’importe quel opérateur d’égalité tel que = , > , < , > = , < = ou <>.
LES SOUS-REQUÊTES
Requête imbriquée qui retourne une colonne
Une requête imbriquée peut également retournée une colonne entière. Dès lors, la requête externe peut
utiliser la commande IN pour filtrer les lignes qui possèdent une des valeurs retournées par la requête
interne. L’exemple ci-dessous met en évidence un tel cas de figure:
SELECT *
FROM `table`
WHERE `nom_colonne` IN (
SELECT `colonne`
FROM `table2`
WHERE `cle_etrangere` = 20
)
