172.17.0.1 : Page créée avec « {{MySQL}} == SELECT == La syntaxe de sélection est la suivante (chaque clause fera l'objet d'un paragraphe explicatif ensuite) : SELECT * FROM nom_table WHERE condition GROUP BY champ1, champ2 HAVING groupe condition ORDER BY champ LIMIT limite, taille; === Liste de champs === Il faut spécifier les données à récupérer avec `SELECT` : SELECT D... »

2024-01-08T15:01:36Z

Page créée avec « <noinclude>{{MySQL}}</noinclude> == SELECT == La syntaxe de sélection est la suivante (chaque clause fera l'objet d'un paragraphe explicatif ensuite) : <syntaxhighlight lang=sql> SELECT * FROM nom_table WHERE condition GROUP BY champ1, champ2 HAVING groupe condition ORDER BY champ LIMIT limite, taille; </syntaxhighlight> === Liste de champs === Il faut spécifier les données à récupérer avec <code>SELECT</code> : <syntaxhighlight lang=sql> SELECT D... »

Nouvelle page

<noinclude>{{MySQL}}</noinclude>

== SELECT ==
La syntaxe de sélection est la suivante (chaque clause fera l'objet d'un paragraphe explicatif ensuite) :
<syntaxhighlight lang=sql>
SELECT *
FROM nom_table
WHERE condition
GROUP BY champ1, champ2
HAVING groupe condition
ORDER BY champ
LIMIT limite, taille;
</syntaxhighlight>

=== Liste de champs ===
Il faut spécifier les données à récupérer avec <code>SELECT</code> :
<syntaxhighlight lang=sql>
SELECT DATABASE(); -- renvoie le nom de la base courante
SELECT CURRENT_USER(); -- l'utilisateur courant
SELECT 1+1; -- 2
</syntaxhighlight>

L'étoile permet d'obtenir tous les champs d'une table :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page`;
</syntaxhighlight>
Mais il est plutôt conseillé de nommer chaque champ (projection) pour accélérer la requête.

=== Noms des tables ===
Pour récupérer les champs d'une table ou d'une vue, il faut la placer dans la clause <code>FROM</code> :
<syntaxhighlight lang=sql>
USE wiki1;
SELECT page_id FROM `wiki1_page`; -- renvoie les valeurs du champ "page_id" de la table "wiki1_page".

SELECT `wiki1`.`wiki1_page`.`page_id`; -- idem
</syntaxhighlight>

Autres exemples :
<syntaxhighlight lang=sql>
SELECT MAX(page_id) FROM `wiki1_page`; -- le nombre le plus élevé
SELECT page_id*2 FROM `wiki1_page`; -- le double de chaque identifiant
</syntaxhighlight>

=== WHERE ===
Cette clause permet de filtrer les enregistrements. Prenons pas exemple celui ou ceux dont le champ identifiant est égal à 42 :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` WHERE `page_id`=42;
</syntaxhighlight>

Ou bien ceux qui ne sont pas nuls :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` WHERE page_id IS NOT NULL;
</syntaxhighlight>

{{attention|Il est impossible d'utiliser le résultat d'une fonction calculée dans le <code>SELECT</code> dans le <code>WHERE</code>, car ce résultat n'est trouvé qu'à la fin de l'exécution, donc <code>WHERE</code> ne peut pas s'en servir au moment prévu.

Pour ce faire il convient d'utiliser <code>HAVING</code> (voir-ensuite)}}

=== GROUP BY ===
Quand plusieurs enregistrements sont identiques dans le résultat, qu'ils ont les mêmes valeurs dans leurs champs sélectionnés, ils peuvent être groupés en une seule ligne.

Par exemple, en regroupant les enregistrements de la table utilisateurs sur le champ de date d'inscription au wiki, on peut obtenir pour chacune le nombre d'édition maximum, minimum et leurs moyennes :
<syntaxhighlight lang=sql>
SELECT user_registration, MAX(user_editcount), MIN(user_editcount), AVG(user_editcount)
FROM wiki1_user
GROUP BY `user_registration`;
</syntaxhighlight>

Idem mais classé par nom et prénom d'utilisateur :
<syntaxhighlight lang=sql>
SELECT user_registration, user_real_name, MAX(user_editcount), MIN(user_editcount), AVG(user_editcount)
FROM wiki1_user
GROUP BY `user_registration`, `user_real_name`;
</syntaxhighlight>

Cette instruction permet donc de réaliser des transpositions lignes en colonnes. Par exemple pour afficher les utilisateurs connus comme ayant le même e-mail :
<syntaxhighlight lang=sql>
SELECT user_email,
MAX(CASE WHEN user_id = 1 THEN user_name ELSE NULL END) AS User1,
MAX(CASE WHEN user_id = 2 THEN user_name ELSE NULL END) AS User2,
MAX(CASE WHEN user_id = 3 THEN user_name ELSE NULL END) AS User3
FROM wiki1_user
GROUP BY `user_email`;
</syntaxhighlight>

{{attention|Si on place le MAX dans le CASE la transposition ne s'effectue pas.}}

Voir aussi <code>GROUP_CONCAT()</code> pour transposer les colonnes en lignes.

==== WITH ROLLUP ====
Ajouter cette clause à un GROUP BY permet d'ajouter le résultat d'une super-agrégation reprenant l'ensemble des résultats<ref>https://dev.mysql.com/doc/refman/5.7/en/group-by-modifiers.html</ref>.

=== HAVING ===
<code>HAVING</code> déclare un filtre valable uniquement pour les enregistrements de la clause <code>GROUP BY</code>, ce qui le distingue de <code>WHERE</code> qui lui opère avant <code>GROUP BY</code>.

<code>HAVING</code> n'est pas optimisé et ne peut pas utiliser les index.

Voici un exemple d'erreur d'optimisation classique : l'ordonnancement des opérations ne filtre le gros des résultats (valeur ''admin'') qu'à la fin de la requête (utilisant plus de mémoire, donc plus de temps qu'avec un <code>WHERE</code>) :
<syntaxhighlight lang=sql>
SELECT MAX(user_editcount), MIN(user_editcount), AVG(user_editcount)
FROM wiki1_user
GROUP BY user_real_name
HAVING user_real_name = 'admin';
</syntaxhighlight>

Par contre, cet exemple ne peut pas être optimisé car le <code>HAVING</code> utilise le résultat du <code>MAX()</code> calculé après le <code>GROUP BY</code> :
<syntaxhighlight lang=sql>
SELECT MAX(user_editcount), MIN(user_editcount), AVG(user_editcount)
FROM wiki1_user
GROUP BY user_real_name
HAVING MAX(user_editcount) > 500;
</syntaxhighlight>

=== ORDER BY ===
Il est possible de classer les résultat, par ordre croissant ou décroissant, des nombres ou des lettres.
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY `page_id`;
</syntaxhighlight>
Par défaut, l'ordre est <code>ASCENDING</code> (croissant). Pour le décroissant il faut donc préciser <code>DESCENDING</code> :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY `page_id` ASC; -- ASC est facultatif
SELECT * FROM `wiki1_page` ORDER BY `page_id` DESC; -- ordre inversé
</syntaxhighlight>
Les valeurs NULL sont considérées comme inférieures aux autres.

Il est également possible de nommer la colonne à classer par son numéro :
<syntaxhighlight lang=sql>
SELECT `page_title`, `page_id` FROM `wiki1_page` ORDER BY 1; -- nom
SELECT `page_title`, `page_id` FROM `wiki1_page` ORDER BY 2; -- id
SELECT `page_title`, `page_id` FROM `wiki1_page` ORDER BY 1 DESC;
</syntaxhighlight>

Les expressions SQL sont autorisées :
<syntaxhighlight lang=sql>
SELECT `page_title` FROM `wiki1_page` ORDER BY REVERSE(`page_title`)
</syntaxhighlight>

La fonction <code>RAND()</code> classe de façon aléatoire :
<syntaxhighlight lang=sql>
SELECT `page_title` FROM `wiki1_page` ORDER BY RAND()
</syntaxhighlight>

Quand un <code>GROUP BY</code> est spécifié, les résultats sont classés selon les champs qui y sont nommés, sauf avant un <code>ORDER BY</code>. Donc l'ordre décroissant peut aussi être précisé depuis le <code>GROUP BY</code> :
<syntaxhighlight lang=sql>
SELECT user_registration, user_real_name, MAX(user_editcount)
FROM wiki1_user
GROUP BY `user_registration` ASC, `user_real_name` DESC;
</syntaxhighlight>
Pour éviter ce classement automatique du <code>GROUP BY</code>, utiliser <code>ORDER BY NULL</code> :
<syntaxhighlight lang=sql>
SELECT user_registration, user_real_name, MAX(user_editcount)
FROM wiki1_user
GROUP BY `user_registration`, `user_real_name` ORDER BY NULL;
</syntaxhighlight>

=== LIMIT ===
Le nombre maximum d'enregistrements dans le résultat est facultatif, on l'indique avec le mot <code>LIMIT</code> :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 10;
</syntaxhighlight>
Ce résultat retourne donc entre 0 et 10 lignes.

Généralement cela s'emploie après un <code>ORDER BY</code> pour avoir les maximums et minimums, mais voici un exemple pour en avoir trois au hasard :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY rand() LIMIT 3;
</syntaxhighlight>

Il est possible de définir une plage d’enregistrements, sachant que le premier est le numéro zéro :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 10;
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 0, 10; -- synonyme
</syntaxhighlight>
On peut donc paginer les requêtes dont les résultats peuvent saturer le serveur :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 0, 10; -- première page
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 10, 10; -- seconde page
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 20, 10; -- troisième page
</syntaxhighlight>
La seconde commande est équivalente à celle-ci :
<syntaxhighlight lang=sql>
SELECT * FROM `wiki1_page` ORDER BY page_id LIMIT 10 OFFSET 10
</syntaxhighlight>

Une astuce consiste à déboguer la syntaxe de sa requête rapidement en lui demandant un résultat vide, et observer ainsi s'il y a des messages d'erreur sans attendre :
<syntaxhighlight lang=sql>
SELECT ... LIMIT 0
</syntaxhighlight>

;Conseils d'optimisation :
* <code>SQL_CALC_FOUND_ROWS</code> peut accélérer les requêtes<ref>http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/</ref><ref>http://dev.mysql.com/doc/refman/5.0/en/information-functions.html</ref>.
* <code>LIMIT</code> est particulièrement pratique dans des <code>SELECT</code> avec <code>ORDER BY</code>, <code>DISTINCT</code> et <code>GROUP BY</code>, car leurs calculs n'impliquent pas toutes les lignes.
* Si la requête est résolue par le serveur en copiant les résultats dans une table temporaire, <code>LIMIT</code> aide MySQL à calculer combien de mémoire est requise par la table.

=== DISTINCT ===
Le mot <code>DISTINCT</code> peut être utilisé pour supprimer les doublons des lignes du résultat :
<syntaxhighlight lang=sql>
SELECT DISTINCT * FROM `wiki1_page` -- aucun doublon
SELECT DISTINCTROW * FROM `wiki1_page` -- synonyme
SELECT ALL * FROM `wiki1_page` -- doublons (comportement par défaut)
</syntaxhighlight>
Cela permet par exemple de récupérer la liste de toutes les valeurs différentes d'un champ :
<syntaxhighlight lang=sql>
SELECT DISTINCT `user_real_name` FROM `wiki1_page` ORDER BY `user_real_name`
</syntaxhighlight>
On peut également en sortir les différentes combinaisons de valeurs :
<syntaxhighlight lang=sql>
SELECT DISTINCT `user_real_name`, `user_editcount` FROM `wiki1_page` ORDER BY `user_real_name`
</syntaxhighlight>

{{remarque|si une clé primaire ou un index unique fait partie de la sélection, le <code>DISTINCT</code> devient inutile. C'est également le cas avec <code>GROUP BY</code>.}}

{{attention|La fonction <code>COUNT()</code> a un comportement différent du <code>GROUP BY</code> :
* <code>SELECT COUNT(*) FROM maTable GROUP BY monChamp)</code> : renvoie une ligne pour chaque valeur du champ, avec le nombre d'occurrences dans la table de chacune.
* <code>SELECT COUNT(monChamp) FROM maTable GROUP BY monChamp)</code> : idem mais sans compter les NULL (ils apparaissent avec un total à 0).
* <code>SELECT COUNT(DISTINCT monChamp) FROM maTable</code> : le nombre de valeurs différentes du champ (c'est-à-dire le nombre de lignes des requêtes précédentes).
* <code>SELECT DISTINCT COUNT(*) FROM maTable</code> : le nombre de lignes dans la table.
* <code>SELECT DISTINCT COUNT(monChamp) FROM maTable</code> : le nombre de lignes dans la table sans compter celles où monChamp est NULL.
}}

===IN and NOT IN===
Équivalent du signe <code>=</code>, qui ne nécessite pas d'être répété quand il concerne plusieurs valeurs :
<syntaxhighlight lang=sql>
SELECT page_id
FROM wiki1_page
WHERE page_namespace IN (0, 1);

-- Liste des pages qui ont des propriétés plus celles qui n'ont aucun hyperlien
SELECT page_id
FROM wiki1_page as p, wiki1_user as u WHERE p.page_id = u.user_id
UNION
SELECT page_id
FROM wiki1_page WHERE page_id NOT IN (SELECT pp_page FROM wiki1_page_props);
</syntaxhighlight>

{{attention|Pour améliorer les performances du <code>NOT IN (1, 2)</code>, il est généralement préférable d'utiliser <code>NOT EXISTS (select 1, 2)</code><ref>https://stackoverflow.com/questions/173041/not-in-vs-not-exists</ref>.}}

=== EXISTS ===
Fonction disponible depuis MySQL 4.
<syntaxhighlight lang=sql>
-- N'affiche la première sélection que si la seconde n'est pas nulle
SELECT page_title
FROM wiki1_page
WHERE EXISTS (SELECT * FROM wiki1_page_props WHERE pp_propname = 'noindex');
</syntaxhighlight>

=== ALL ===
<syntaxhighlight lang=sql>
-- Ne renvoie que les pages dont le numéro est le seul de la seconde sélection
SELECT page_title
FROM wiki1_page
WHERE page_id = ALL (SELECT pp_page FROM wiki1_page_props WHERE pp_propname = 'defaultsort');
</syntaxhighlight>

=== UNION et UNION All===
Compatible MySQL 4 et plus. L'union de sélections nécessite qu'elles aient le même nombre de colonnes.

La requête suivante renvoie tous les enregistrements de deux tables :
<syntaxhighlight lang=sql>
SELECT page_title FROM wiki1_page
UNION ALL
SELECT user_name FROM wiki1_user;
</syntaxhighlight>

<code>UNION</code> est équivalent à <code>UNION DISTINCT</code>, ce qui le distingue de <code>UNION ALL</code> qui ne filtre pas les doublons.
<syntaxhighlight lang=sql>
SELECT page_id FROM wiki1_page
UNION
SELECT page_id FROM wiki1_page;
-- égal
(SELECT page_id FROM wiki1_page)
UNION DISTINCT
(SELECT page_id FROM wiki1_page)
ORDER BY page_id;
</syntaxhighlight>

== JOIN ==
[[Image:SQL Joins.svg|class=transparent]]

Les relations entre les tables permettent de joindre intelligemment leurs résultats. La jointure naturelle est la plus rapide sur la plupart des plateformes SQL.

L'exemple suivant compare les nombres en anglais et en hindi.
<syntaxhighlight lang=sql>
CREATE TABLE english (Tag int, Inenglish varchar(255));
CREATE TABLE hindi (Tag int, Inhindi varchar(255));

INSERT INTO english (Tag, Inenglish) VALUES (1, 'One');
INSERT INTO english (Tag, Inenglish) VALUES (2, 'Two');
INSERT INTO english (Tag, Inenglish) VALUES (3, 'Three');

INSERT INTO hindi (Tag, Inhindi) VALUES (2, 'Do');
INSERT INTO hindi (Tag, Inhindi) VALUES (3, 'Teen');
INSERT INTO hindi (Tag, Inhindi) VALUES (4, 'Char');
</syntaxhighlight>

<table>
<tr><td> </td><td>select * from english</td><td> </td><td>select * from hindi</td></tr>
<tr><td>Tag</td><td>Inenglish </td><td> Tag </td><td>Inhindi </td></tr>
<tr><td>1 </td> <td>One </td> <td> 2 </td> <td> Do </td></tr>
<tr><td>2 </td> <td>Two </td> <td> 3 </td> <td> Teen </td></tr>
<tr><td> 3 </td> <td> Three </td><td> 4 </td> <td> Char </td></tr>
</table>

=== INNER JOIN ===
<syntaxhighlight lang=sql>
SELECT hindi.Tag, english.Inenglish, hindi.Inhindi
FROM english, hindi
WHERE english.Tag = hindi.Tag
-- égal
SELECT hindi.Tag, english.Inenglish, hindi.Inhindi
FROM english INNER JOIN hindi ON english.Tag = hindi.Tag
</syntaxhighlight>

<table>
<tr><td>Tag </td> <td>Inenglish</td> <td>Inhindi </td></tr>
<tr> <td> 2 </td> <td> Two </td> <td> Do </td> </tr>
<tr> <td> 3 </td> <td> Three </td> <td> Teen </td> </tr>
</table>

{{remarque|Le comportement d'un <code>JOIN</code> seul est <code>INNER JOIN</code>, qui est aussi synonyme de <code>CROSS JOIN</code><ref>https://dev.mysql.com/doc/refman/5.7/en/join.html</ref> ({{wt|jointure cartésienne}}).}}

La jointure cartésienne décrit le cas où chaque ligne d'une table est jointe à toutes celles d'une autre.
<syntaxhighlight lang=sql>
SELECT * FROM english, hindi
-- égal
SELECT * FROM english CROSS JOIN hindi
</syntaxhighlight>
3*3 = 9 lignes :
<table>
<tr><td>Tag</td><td>Inenglish</td><td>Tag </td> <td>Inhindi </td></tr>
<tr><td>1 </td> <td>One </td> <td>2 </td> <td> Do </td></tr>
<tr><td> 2 </td> <td>Two </td> <td>2 </td> <td> Do </td> </tr>
<tr> <td>3 </td> <td> Three </td> <td> 2 </td> <td> Do </td></tr>
<tr> <td> 1 </td> <td> One </td> <td> 3 </td> <td> Teen </td> </tr>
<tr> <td> 2 </td> <td> Two </td> <td> 3 </td> <td> Teen </td> </tr>
<tr> <td> 3 </td> <td> Three </td> <td> 3 </td> <td> Teen </td> </tr>
<tr> <td> 1 </td> <td> One </td> <td> 4 </td> <td> Char </td> </tr>
<tr> <td> 2 </td> <td> Two </td> <td> 4 </td> <td> Char </td> </tr>
<tr> <td> 3 </td> <td> Three </td> <td> 4 </td> <td> Char </td> </tr>
</table>

=== NATURAL JOIN ===
La {{wt|jointure naturelle}} équivaut à <code>INNER JOIN</code> sur toutes les colonnes communes des deux tables.

=== USING ===
Le mot <code>USING</code> est compatible MySQL 4, mais change avec MySQL 5. La requête suivante est équivalente à celles <code>INNER JOIN</code> ci-dessus :
<syntaxhighlight lang=sql>
SELECT hindi.tag, hindi.Inhindi, english.Inenglish
FROM hindi NATURAL JOIN english
USING (Tag)
</syntaxhighlight>

=== OUTER JOIN ===
<syntaxhighlight lang=sql>
SELECT hindi.Tag, english.Inenglish, hindi.Inhindi
FROM english OUTER JOIN hindi ON english.Tag = hindi.Tag
</syntaxhighlight>

<table>
<tr><td> Tag </td> <td> Inenglish </td> <td>Tag </td> <td>Inhindi</td></tr>
<tr> <td>1 </td><td> One </td><td> </td><td>  </td></tr>
<tr> <td>2 </td><td> Two </td> <td> 2 </td> <td>Do </td> </tr>
<tr> <td>3 </td><td> Three </td> <td> 3 </td> <td> Teen </td> </tr>
<tr> <td> </td> <td> </td> <td> 4 </td> <td> Char </td> </tr>
</table>

=== LEFT JOIN / LEFT OUTER JOIN ===
<syntaxhighlight lang=sql>
SELECT field1, field2 FROM table1 LEFT JOIN table2 ON field1=field2

SELECT e.Inenglish as English, e.Tag, h.Inhindi as Hindi
FROM english AS e
LEFT JOIN hindi AS h ON e.Tag=h.Tag
WHERE h.Inhindi IS NULL
</syntaxhighlight>

English tag Hindi
One 1 ''NULL''

{{remarque|Naturellement comme pour le <code>inner join</code>, s'il y a plusieurs lignes non NULL à droite, on les retrouve toutes en résultat.}}

=== RIGHT OUTER JOIN ===
<syntaxhighlight lang=sql>
SELECT e.Inenglish AS English, h.tag, h.Inhindi AS Hindi
FROM english AS e RIGHT JOIN hindi AS h
ON e.Tag=h.Tag
WHERE e.Inenglish IS NULL
</syntaxhighlight>

English tag Hindi
''NULL'' 4 Char

* S'assurer que le type des clés de jointes est le même dans les deux tables.
* Les mots clés <code>LEFT</code> et <code>RIGHT</code> ne sont pas absolus, ils opèrent selon le contexte : en intervertissant les tables le résultat sera identique.
* La jointure par défaut est <code>INNER JOIN</code> (pas <code>OUTER</code>).

=== FULL OUTER JOIN ===
MySQL et MariaDB n'ont pas de jointure <code>FULL OUTER JOIN</code>. Voici comment l'émuler :
<syntaxhighlight lang=sql>
(SELECT a.*, b*
FROM tab1 a LEFT JOIN tab2 b
ON a.id = b.id)
UNION
(SELECT a.*, b*
FROM tab1 a RIGHT JOIN tab2 b
ON a.id = b.id)
</syntaxhighlight>

=== Jointures multiples ===
Il est possible de joindre plus de deux tables :
<syntaxhighlight lang=sql>
SELECT ... FROM a JOIN (b JOIN c on b.id=c.id) ON a.id=b.id
</syntaxhighlight>

Exemple :
<syntaxhighlight lang=sql>
mysql> SELECT group_type.type_id, group_type.nom, COUNT(people_job.job_id) AS count
FROM group_type
JOIN (groups JOIN people_job ON groups.group_id = people_job.group_id)
ON group_type.type_id = groups.type
GROUP BY type_id ORDER BY type_id
+---------+--------------------------------------+-------+
| type_id | nom | count |
+---------+--------------------------------------+-------+
| 1 | Official GNU software | 148 |
| 2 | non-GNU software and documentation | 268 |
| 3 | www.gnu.org portion | 4 |
| 6 | www.gnu.org translation team | 5 |
+---------+--------------------------------------+-------+
4 rows in set (0.02 sec)
</syntaxhighlight>

== Sous requêtes ==
Compatible MySQL 4.1 et plus.

* Les {{wt|sous-requête}}s SQL permettent aux résultats d'une requête d'être utilisés par une autre.
* Elles apparaissent toujours comme une partie de clause <code>WHERE</code> ou <code>HAVING</code>.
* Seul un champ peut être dans la sous-requête <code>SELECT</code>.
* Les <code>ORDER BY</code> ne sont donc pas autorisés (inutiles sur une seule colonne).

Par exemple, la "table" ''RepOffice = OfficeNbr from Offices'', liste les bureaux où le quota de vente excède la somme des quotas des vendeurs individuels :
<syntaxhighlight lang=sql>
SELECT ville FROM Offices WHERE Target > ???
</syntaxhighlight>
??? est la somme des quotas des vendeurs.
<syntaxhighlight lang=sql>
SELECT SUM(Quota)
FROM SalesReps
WHERE RepOffice = OfficeNbr
</syntaxhighlight>

En combinant ces deux requêtes, les points d'interrogations disparaissent :
<syntaxhighlight lang=sql>
SELECT ville FROM Offices
WHERE Target > (SELECT SUM(Quota) FROM SalesReps
WHERE RepOffice = OfficeNbr)
</syntaxhighlight>

Par exemple, tous les clients avec des commandes ou limites de crédits > 50000 €. En utilisant le mot <code>DISTINCT</code> pour ne lister les clients qu'une seule fois :
<syntaxhighlight lang=mysql>
SELECT DISTINCT CustNbr
FROM Customers, Orders
WHERE CustNbr = Cust AND (CreditLimit > 50000 OR Amt > 50000);
</syntaxhighlight>

{{remarque|il y a donc trois types de filtre.
* <code>ON</code> : filtre les lignes d'une seule table.
* <code>WHERE</code> : filtre les lignes de toutes les tables.
* <code>HAVING</code> : filtre les lignes de toutes les tables après regroupements.
}}

{{attention|1=Les sous-requêtes ne peuvent pas faire référence à un élément de la requête qui les contient. Si c'est nécessaire, il faut les transformer en jointures : ... <code>JOIN (SELECT...) q ON q.id = ...</code>}}

{{remarque|Dans MySQL 8.0 et MariaDB 10.2.1, le mot <code>WITH</code> permet de se référer aux sous-requêtes récurrentes, récursives ou pas<ref>https://mariadb.com/kb/en/with/</ref>.}}

Exemple :
<syntaxhighlight lang=mysql>
WITH
sub_request1 AS (SELECT field1, field2 FROM table1),
sub_request2 AS (SELECT field2, field3 FROM table2)
SELECT field1, field3
FROM sub_request1 INNER JOIN sub_request2
WHERE sub_request1.field1 = sub_request2.field1;
</syntaxhighlight>

==References==
{{Références}}
* [http://dev.mysql.com/doc Official MySQL documentation]

Mysql - Historique des versions