27 Exercices Sur Les Requêtes SQL Corrigé: Requêtes imbriquées
La meilleure façon d’apprendre quelque chose est de pratiquer des exercices. Nous avons préparer ces exercices corrigés pour les personnes (débutantes ou intermédiaires) qui sont familières avec SQL. Nous espérons que ces exercices vous aideront à améliorer vos compétences en SQL. Les exercices corrigés suivantes sont actuellement disponibles, nous travaillons dur pour ajouter plus d’exercices. Bon apprentissage!
Vous pouvez lire notre tutoriel SQL avant de résoudre les exercices suivants.
Exercices Sur Les Requêtes SQL Corrigé : Requêtes imbriquées
1. A partir des tables suivantes, écrivez une requête SQL pour trouver toutes les commandes passées par le fournisseur ‘Fauna Gaillard’. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes
WHERE fournisseur_id =
(SELECT fournisseur_id
FROM fournisseurs
WHERE nom_fr = 'Fauna Gaillard');
Sortie de la requête :
2. A partir des tables suivantes, écrivez une requête SQL pour trouver toutes les commandes générées par les fournisseurs basés à Paris. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes
WHERE fournisseur_id IN
(SELECT fournisseur_id
FROM fournisseurs
WHERE ville = 'Paris');
Sortie de la requête :
3. A partir de la table suivante, écrivez une requête SQL pour trouver toutes les commandes générées par les fournisseurs qui peuvent travailler pour les clients dont l’identifiant est 1005. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes
WHERE fournisseur_id =
(SELECT DISTINCT fournisseur_id
FROM commandes
WHERE client_id = 1005);
Sortie de la requête :
4. A partir de la table suivante, écrivez une requête SQL pour trouver les valeurs de commande supérieures à la valeur de commande moyenne du 22 décembre 2024. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes
WHERE montant_achat >
(SELECT AVG(montant_achat)
FROM commandes
WHERE date_cmd = '2024-12-22');
Sortie de la requête :
5. A partir de la table suivante, écrivez une requête SQL pour trouver toutes les commandes générées dans la ville de Paris. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes
WHERE fournisseur_id IN
(SELECT fournisseur_id
FROM fournisseurs
WHERE ville = 'Toulouse');
Sortie de la requête :
6. A partir des tables suivantes, écrivez une requête SQL pour compter le nombre de clients ayant un age supérieures à la moyenne dans la ville de Paris. Retournez l’age et le nombre.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
SELECT age, COUNT(*)
FROM clients
GROUP BY age
HAVING age >
(SELECT AVG(age)
FROM clients
WHERE ville = 'Paris');
Sortie de la requête :
+-----+----------+ | age | COUNT(*) | +-----+----------+ | 53 | 1 | | 65 | 1 | +-----+----------+
7. A partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs qui ont gagné la commission maximale. Retournez cmd_id, montant_achat, date_cmd et fournisseur_id.
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT cmd_id, montant_achat, date_cmd, fournisseur_id
FROM commandes
WHERE fournisseur_id IN (
SELECT fournisseur_id
FROM fournisseurs
WHERE commission = (
SELECT MAX(commission)
FROM fournisseurs
)
);
8. A partir des tables suivantes, écrivez une requête SQL pour trouver les clients qui ont passé des commandes le 05 janvier 2024. Retournez cmd_id, montant_achat, date_cmd, client_id, fournisseur_id et nom_cl.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT cm.*, cl.nom_cl FROM commandes cm, clients cl WHERE cl.client_id = cm.client_id AND cm.date_cmd = '2024-01-05';
Sortie de la requête :
9. À partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs qui ont eu plus d’un client. Retournez l’identifiant et le nom du fournisseur.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
SELECT fournisseur_id, nom_fr
FROM fournisseurs f
WHERE 1 <
(SELECT COUNT(*)
FROM clients
WHERE fournisseur_id = f.fournisseur_id);
Sortie de la requête :
+----------------+----------------+ | fournisseur_id | nom_fr | +----------------+----------------+ | 6001 | Arnaud Beaulac | +----------------+----------------+
10. A partir des tables suivantes, écrivez une requête SQL pour trouver les commandes qui sont plus élevées que le montant moyen des commandes. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes c1
WHERE montant_achat >
(SELECT AVG(montant_achat) FROM commandes c2
WHERE c2.client_id = c1.client_id);
Sortie de la requête :
11. A partir des tables suivantes, écrivez une requête SQL pour trouver les commandes qui sont égales ou supérieures au montant moyen des commandes. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM commandes c1
WHERE montant_achat >=
(SELECT AVG(montant_achat) FROM commandes c2
WHERE c2.client_id = c1.client_id);
Sortie de la requête :
12. Ecrivez une requête pour trouver les sommes des montants de la table des commandes, groupées par date, et éliminez toutes les dates où la somme n'est pas supérieure d'au moins 50,00 au montant maximum pour cette date.
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT date_cmd, SUM(montant_achat)
FROM commandes c1
GROUP BY date_cmd
HAVING SUM(montant_achat) >
(SELECT 50.00 + MAX(montant_achat)
FROM commandes c2
WHERE c1.date_cmd = c2.date_cmd);
13. Écrivez une requête pour extraire toutes les données de la table des clients si et seulement si un ou plusieurs des clients de la table des clients se trouvent à Paris.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
SELECT client_id, nom_cl, ville
FROM clients
WHERE EXISTS
(SELECT *
FROM clients
WHERE ville = 'Paris');
Sortie de la requête :
14. À partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs qui sont en relation avec plusieurs clients. Elle renvoie l'identifiant du fournisseur, son nom, sa ville et sa commission.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
SELECT *
FROM fournisseurs
WHERE fournisseur_id IN (
SELECT DISTINCT fournisseur_id
FROM clients c1
WHERE EXISTS (
SELECT *
FROM clients c2
WHERE c2.fournisseur_id = c1.fournisseur_id
AND c2.nom_cl <> c1.nom_cl
)
);
Sortie de la requête :
+----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | +----------------+----------------+-------------+------------+
15. À partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs qui sont en relation avec un seul client. Elle renvoie l'identifiant du fournisseur, son nom, sa ville et sa commission.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
SELECT *
FROM fournisseurs
WHERE fournisseur_id IN (
SELECT DISTINCT fournisseur_id
FROM clients c1
WHERE NOT EXISTS (
SELECT *
FROM clients c2
WHERE c2.fournisseur_id = c1.fournisseur_id
AND c2.nom_cl <> c1.nom_cl
)
);
Sortie de la requête :
+----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6002 | Fauna Gaillard | Paris | 0.5 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
16. À partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs qui travaillent avec les clients ayant plus d'une commande. Elle renvoie l'identifiant du fournisseur, son nom, sa ville et sa commission.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT *
FROM fournisseurs f
WHERE EXISTS
(SELECT * FROM clients c
WHERE f.fournisseur_id = c.fournisseur_id
AND 1 <
(SELECT COUNT(*)
FROM commandes
WHERE commandes.client_id = c.client_id)
);
Sortie de la requête :
+----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6002 | Fauna Gaillard | Paris | 0.5 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
17. À partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs qui sont en relation avec les clients qui habitent dans la même ville. Elle renvoie l'identifiant du fournisseur, son nom, sa ville et sa commission.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
SELECT *
FROM fournisseurs
WHERE ville = ANY
(SELECT ville
FROM clients);
Sortie de la requête :
+----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
18. À partir des tables suivantes, écrivez une requête SQL pour trouver les fournisseurs dont le lieu de résidence correspond à n'importe quelle ville où vivent des clients. Retournez l'identifiant du fournisseur, son nom, sa ville et sa commission.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
SELECT *
FROM fournisseurs
WHERE ville IN
(SELECT ville
FROM clients);
Sortie de la requête :
+----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
19. À partir des tables suivantes, écrivez une requête SQL pour trouver tous les fournisseurs dont les noms apparaissent dans l'ordre alphabétique inférieur au nom du client. Retourne l'identifiant du fournisseur, le nom, la ville, la commission.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
SELECT * FROM fournisseurs f WHERE EXISTS (SELECT * FROM clients c WHERE f.nom_fr < c.nom_cl);
Sortie de la requête :
+----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
20. A partir du table suivante, écrivez une requête SQL pour trouver toutes les commandes dont le montant dépasse au moins l'une des commandes passées le 05 janvier 2024. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT * FROM commandes WHERE montant_achat > ANY (SELECT montant_achat FROM commandes WHERE date_cmd = '2024-01-05');
Sortie de la requête :
+--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | +--------+----------------+-------------+-----------+----------------+
21. A partir des tables suivantes, écrivez une requête SQL pour trouver les commandes dont le montant est inférieur au montant de la commande d'un client résidant à Montpellier. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT * FROM commandes WHERE montant_achat < ANY (SELECT montant_achat FROM commandes cm, clients cl WHERE cm.client_id = cl.client_id AND cl.ville = 'Montpellier');
Sortie de la requête :
+--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | +--------+----------------+-------------+-----------+----------------+
22. A partir des tables suivantes, écrivez une requête SQL pour trouver les commandes dont le montant est inférieur au montant maximum de la commande d'un client résidant à Montpellier. Retournez cmd_id, montant_achat, date_cmd, client_id et fournisseur_id.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT * FROM commandes WHERE montant_achat < ANY (SELECT MAX(montant_achat) FROM commandes cm, clients cl WHERE cm.client_id = cl.client_id AND cl.ville = 'Montpellier');
Sortie de la requête :
+--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | +--------+----------------+-------------+-----------+----------------+
23. À partir du table suivante, écrivez une requête SQL pour trouver les clients dont l'age est supérieure à celles des habitants de la ville de Marseille. Retournez l'identifiant du client, le nom du client, la ville, l'age et l'identifiant du fournisseur.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
SELECT * FROM clients WHERE age > ALL (SELECT age FROM clients WHERE ville = 'Marseille');
Sortie de la requête :
+-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
24. À partir des tables suivantes, écrivez une requête SQL pour calculer le montant total des commandes générées par un fournisseur. Les fournisseurs doivent être originaires des villes où résident les clients. Retournez le nom du fournisseur, la ville et le montant total de la commande.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
Table: fournisseurs +----------------+----------------+-------------+------------+ | fournisseur_id | nom_fr | ville | commission | +----------------+----------------+-------------+------------+ | 6001 | Arnaud Beaulac | Toulouse | 0.2 | | 6002 | Fauna Gaillard | Paris | 0.5 | | 6005 | Barry Cantin | Nice | 0.9 | | 6006 | Royce Guimond | Strasbourg | 0.6 | | 6007 | Fusberta Faure | Marseille | 0.8 | | 6003 | Ernest Petit | Montpellier | 0.1 | +----------------+----------------+-------------+------------+
Table: commandes +--------+----------------+-------------+-----------+----------------+ | cmd_id | montant_achat | date_cmd | client_id | fournisseur_id | +--------+----------------+-------------+-----------+----------------+ | 8001 | 125.02 | 2024-10-06 | 1005 | 6002 | | 8002 | 60.38 | 2024-02-22 | 1005 | 6002 | | 8003 | 95.65 | 2024-05-11 | 1002 | 6001 | | 8004 | 59.32 | 2024-12-22 | 1006 | 6003 | | 8005 | 74.33 | 2024-11-30 | 1006 | 6003 | | 8006 | 188.22 | 2024-01-05 | 1003 | 6001 | +--------+----------------+-------------+-----------+----------------+
SELECT f.nom_fr, f.ville, myreq1.prix_total FROM fournisseurs f, (SELECT fournisseur_id, SUM(commandes.montant_achat) AS prix_total FROM commandes GROUP BY fournisseur_id) myreq1 WHERE myreq1.fournisseur_id = f.fournisseur_id AND f.ville IN (SELECT DISTINCT ville FROM fournisseurs);
Sortie de la requête :
+----------------+-------------+------------+ | nom_fr | ville | prix_total | +----------------+-------------+------------+ | Arnaud Beaulac | Toulouse | 283.87 | | Fauna Gaillard | Paris | 185.4 | | Ernest Petit | Montpellier | 133.65 | +----------------+-------------+------------+
25. À partir des tables suivantes, écrivez une requête SQL pour trouver les clients dont l'age ne sont pas les mêmes que ceux qui vivent à Paris. Retournez l'identifiant du client, le nom du client, la ville, l'age et l'identifiant du fournisseur.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
SELECT * FROM clients WHERE age <> ALL (SELECT age FROM clients WHERE ville='Paris' AND NOT age IS NULL);
Sortie de la requête :
+-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
26. À partir des tables suivantes, écrivez une requête SQL pour trouver les clients dont l'age est différente de ceux qui vivent à Paris. Retournez l'identifiant du client, le nom du client, la ville, l'age et l'identifiant du fournisseur.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
SELECT * FROM clients WHERE age NOT IN (SELECT age FROM clients WHERE ville='Paris');
Sortie de la requête :
+-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
27. À partir des tables suivantes, écrivez une requête SQL pour trouver tous les clients dont l'age est différente de celles d'un client qui habite dans la ville de Lyon. Retournez l'identifiant du client, le nom du client, la ville, l'age et l'identifiant du fournisseur.
Table: clients +-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1002 | Lois Collins | Lyon | 30 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
SELECT * FROM clients WHERE NOT age = ANY (SELECT age FROM clients WHERE ville='Lyon');
Sortie de la requête :
+-----------+----------------+-------------+--------+----------------+ | client_id | nom_cl | ville | age | fournisseur_id | +-----------+----------------+-------------+--------+----------------+ | 1001 | Alex Barbara | Paris | 25 | 6001 | | 1005 | Karen Farley | Nice | 44 | 6002 | | 1006 | Kevin Thompson | Paris | 65 | 6003 | | 1007 | Scott Henry | Marseille | 32 | 6006 | | 1003 | Ellen McMullen | Montpellier | 53 | 6001 | +-----------+----------------+-------------+--------+----------------+
- 30 Exercices Sur Les Requêtes SQL Corrigé: Récupération des données
- 12 Exercices Sur Les Requêtes SQL Corrigé: Opérateurs relationnels
- 23 Exercices Sur Les Requêtes SQL Corrigé: Opérateurs spéciaux et jokers (wildcards)
- 23 Exercices Sur Les Requêtes SQL Corrigé: Fonctions d’agrégation
- 10 Exercices Sur Les Requêtes SQL Corrigé: Requête sur plusieurs tables
- 13 Exercices Sur Les Requêtes SQL Corrigé: Jointure
- 27 Exercices Sur Les Requêtes SQL Corrigé: Requêtes imbriquées
- 6 Exercices Sur Les Requêtes SQL Corrigé: UNION
- 13 Exercices Sur Les Requêtes SQL Corrigé: Les vues
