Comment créer une sous-requête dans MySQL ?

Dans MySQL, une sous-requête fait référence à l'imbrication d'une instruction de requête dans une autre instruction de requête. Elle peut être implémentée avec la clause WHERE dans les instructions SELECT, UPDATE et DELETE. Le format de syntaxe de la clause WHERE est : "WHERE. (une autre instruction de requête)".

(Tutoriel recommandé : Tutoriel vidéo MySQL)

La sous-requête est une comparaison dans MySQL couramment En utilisant des méthodes de requête, les requêtes multi-tables peuvent être implémentées via des sous-requêtes. La sous-requête fait référence à l'imbrication d'une instruction de requête dans une autre instruction de requête. Les sous-requêtes peuvent être utilisées dans les instructions SELECT, UPDATE et DELETE et peuvent être imbriquées à plusieurs niveaux. Dans le développement réel, les sous-requêtes apparaissent souvent dans la clause WHERE. Le format syntaxique de la sous-requête

dans WHERE est le suivant :

WHERE <表达式> <操作符> (子查询语句)

Parmi eux, l'opérateur peut être un opérateur de comparaison et des mots-clés tels que IN, NOT IN, EXISTS, NOT EXISTS, etc.

1) IN | NOT IN

Lorsque l'expression est égale à une valeur dans l'ensemble de résultats renvoyé par la sous-requête, TRUE est renvoyé, sinon FALSE est renvoyé ; si vous utilisez le mot-clé NOT, la valeur de retour est exactement le contraire.

2) EXISTS | NOT EXISTS

est utilisé pour déterminer si l'ensemble de résultats de la sous-requête est vide. Si l'ensemble de résultats de la sous-requête n'est pas vide, retournez. TRUE, sinon renvoie FALSE si le mot-clé NOT est utilisé, la valeur renvoyée est exactement le contraire.

Exemple 1

Utilisez une sous-requête pour interroger les noms des étudiants suivant des cours Java dans la table tb_students_info et la table tb_course. L'instruction SQL et les résultats d'exécution sont les suivants.

mysql> SELECT name FROM tb_students_info 
    -> WHERE course_id IN (SELECT id FROM tb_course WHERE course_name = 'Java');
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.01 sec)

Il s'avère que les seules personnes qui suivent le cours Java sont Dany et Henry. Le processus de requête ci-dessus peut également être divisé en deux étapes suivantes pour obtenir le même effet.

1) Exécutez d'abord la requête interne séparément pour connaître l'identifiant du cours Java dans la table tb_course. L'instruction SQL et les résultats d'exécution sont les suivants.

mysql> SELECT id FROM tb_course 
    -> WHERE course_name = 'Java';
+----+
| id |
+----+
|  1 |
+----+
1 row in set (0.00 sec)

Vous pouvez voir que la valeur du champ id qui remplit les conditions est 1.

2) Exécutez ensuite la requête externe pour interroger les noms des étudiants dont course_id est égal à 1 dans la table tb_students_info. Les instructions SQL et les résultats d'exécution sont les suivants.

mysql> SELECT name FROM tb_students_info 
    -> WHERE course_id IN (1);
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.00 sec)

Conventionnellement, la requête SELECT externe est appelée requête parent, et la requête intégrée entre parenthèses est appelée sous-requête (les sous-requêtes doivent être placées entre parenthèses). Lorsque MySQL traite l'instruction SELECT dans l'exemple ci-dessus, le flux d'exécution est le suivant : exécutez d'abord la sous-requête, puis exécutez la requête parent.

Exemple 2

Semblable à l'exemple 1, utilisez le mot clé NOT IN dans l'instruction SELECT pour interroger les noms des étudiants qui n'ont pas suivi de cours Java. et les résultats d'exécution sont les suivants.

mysql> SELECT name FROM tb_students_info 
    -> WHERE course_id NOT IN (SELECT id FROM tb_course WHERE course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
9 rows in set (0.01 sec)

On peut voir que les résultats courants sont exactement à l'opposé de l'exemple 1. Les étudiants autres que Dany et Henry ne suivent pas de cours Java.

Exemple 3

Utilisez l'opérateur = pour interroger les noms de tous les étudiants qui étudient les cours Python dans la table tb_course et la table tb_students_info. L'instruction SQL et les résultats d'exécution sont les suivants. suit.

mysql> SELECT name FROM tb_students_info
    -> WHERE course_id = (SELECT id FROM tb_course WHERE course_name = 'Python');
+------+
| name |
+------+
| Jane |
+------+
1 row in set (0.00 sec)

Les résultats montrent que la seule étudiante qui suit le cours Python est Jane.

Exemple 4

Utilisez l'opérateur <> pour interroger les noms, les instructions SQL et les résultats d'exécution des étudiants qui n'ont pas suivi de cours Python dans la table tb_course et tb_students_info comme suit.

mysql> SELECT name FROM tb_students_info
    -> WHERE course_id <> (SELECT id FROM tb_course WHERE course_name = &#39;Python&#39;);
+--------+
| name   |
+--------+
| Dany   |
| Green  |
| Henry  |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
10 rows in set (0.00 sec)

On peut voir que le résultat courant est exactement le contraire de l'exemple 3. Les étudiants autres que Jane n'apprennent pas de cours Python.

Exemple 5

Requérez s'il existe un cours avec id=1 dans la table tb_course S'il existe, interrogez les enregistrements dans la table tb_students_info. et les résultats d'exécution sont les suivants.

mysql> SELECT * FROM tb_students_info
    -> WHERE EXISTS(SELECT course_name FROM tb_course WHERE id=1);
+----+--------+------+------+--------+-----------+
| id | name   | age  | sex  | height | course_id |
+----+--------+------+------+--------+-----------+
|  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | Jim    |   24 | 女   |    175 |         2 |
|  6 | John   |   21 | 女   |    172 |         4 |
|  7 | Lily   |   22 | 男   |    165 |         4 |
|  8 | Susan  |   23 | 男   |    170 |         5 |
|  9 | Thomas |   22 | 女   |    178 |         5 |
| 10 | Tom    |   23 | 女   |    165 |         5 |
| 11 | LiMing |   22 | 男   |    180 |         7 |
+----+--------+------+------+--------+-----------+
11 rows in set (0.01 sec)

Comme le montrent les résultats, il existe un enregistrement avec id=1 dans la table tb_course, donc l'expression EXISTS renvoie TRUE. Après avoir reçu TRUE, l'instruction de requête externe interroge la table tb_students_info et renvoie tout. enregistrements.

Le mot-clé EXISTS peut être utilisé avec d'autres conditions de requête. L'expression conditionnelle et le mot-clé EXISTS sont connectés avec AND et OR.

Exemple 6

Requérez s'il existe un cours avec id=1 dans la table tb_course S'il existe, interrogez les enregistrements dont le champ âge est supérieur à 24 pouces. la table tb_students_info. Instruction SQL Et les résultats en cours d'exécution sont les suivants.

mysql> SELECT * FROM tb_students_info
    -> WHERE age>24 AND EXISTS(SELECT course_name FROM tb_course WHERE id=1);
+----+------+------+------+--------+-----------+
| id | name | age  | sex  | height | course_id |
+----+------+------+------+--------+-----------+
|  1 | Dany |   25 | 男   |    160 |         1 |
+----+------+------+------+--------+-----------+
1 row in set (0.01 sec)

Les résultats montrent qu'un enregistrement a été interrogé à partir de la table tb_students_info et que la valeur du champ d'âge de cet enregistrement est 25. L'instruction de requête interne récupère les enregistrements de la table tb_course et renvoie TRUE. L'instruction de requête externe démarre la requête. Selon les conditions de requête, interrogez les enregistrements dont l'âge est supérieur à 24 ans dans la table tb_students_info.

Étendue

La fonctionnalité des sous-requêtes peut également être réalisée via des jointures de tables, mais les sous-requêtes facilitent la lecture et l'écriture des instructions SQL.

De manière générale, les jointures de table (jointures internes et jointures externes, etc.) peuvent être remplacées par des sous-requêtes, mais l'inverse n'est pas nécessairement vrai. Certaines sous-requêtes ne peuvent pas être remplacées par des jointures de table. Les sous-requêtes sont plus flexibles, plus pratiques et de forme plus diversifiée, et conviennent comme conditions de filtrage pour les requêtes, tandis que les jointures de tables sont plus adaptées à l'affichage des données dans des tables connectées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!