TOC

Une introduction aux requêtes dans MySQL

introduction

Les bases de données constituent un élément clé de nombreux sites Web et applications et sont au cœur de la manière dont les données sont stockées et échangées sur Internet. L’un des aspects les plus importants de la gestion de base de données est la pratique consistant à extraire des données d’une base de données, que ce soit de manière ponctuelle ou en tant que partie d’un processus codé dans une application. Il existe plusieurs façons de récupérer des informations d’une base de données, mais l’une des méthodes les plus couramment utilisées consiste à soumettre queries via la ligne de commande.

Dans les systèmes de gestion de base de données relationnelle, une query est une commande utilisée pour extraire des données d’une table. Dans le langage SQL (Structured Query Language), les requêtes sont presque toujours effectuées à l’aide de l’instruction + SELECT +.

Dans ce guide, nous aborderons la syntaxe de base des requêtes SQL ainsi que certaines des fonctions et des opérateurs les plus couramment employés. Nous allons également nous entraîner à faire des requêtes SQL en utilisant des exemples de données dans une base de données MySQL.

MySQL est un système de gestion de base de données relationnelle à source ouverte. L’une des bases de données SQL les plus largement déployées, MySQL donne la priorité à la rapidité, à la fiabilité et à la convivialité. Il est généralement conforme à la norme ANSI SQL, bien que dans certains cas, MySQL effectue des opérations différemment de la norme reconnue.

Conditions préalables

En général, les commandes et les concepts présentés dans ce guide peuvent être utilisés sur tout système d’exploitation basé sur Linux exécutant tout logiciel de base de données SQL. Cependant, il a été spécialement conçu pour un serveur Ubuntu 18.04 exécutant MySQL. Pour cela, vous aurez besoin des éléments suivants:

Avec cette configuration en place, nous pouvons commencer le tutoriel.

Création d’une base de données exemple

Avant de pouvoir commencer à faire des requêtes en SQL, nous allons d’abord créer une base de données et quelques tables, puis remplir ces tables avec des exemples de données. Cela vous permettra d’acquérir une expérience pratique lorsque vous commencerez à poser des questions ultérieurement.

Pour le modèle de base de données que nous allons utiliser tout au long de ce guide, imaginez le scénario suivant:

_Vous et plusieurs de vos amis célèbrent votre anniversaire l’un avec l’autre. À chaque occasion, les membres du groupe se rendent au bowling local pour participer à un tournoi amical, puis chacun se rend à votre lieu de préparation du repas préféré de l’anniversaire.

Maintenant que cette tradition dure depuis un certain temps, vous avez décidé de commencer à suivre les enregistrements de ces tournois. En outre, pour faciliter la planification des dîners, vous décidez de créer un enregistrement des anniversaires de vos amis et de leurs entrées, plats et desserts préférés. Plutôt que de conserver ces informations dans un grand livre physique, vous décidez d’exercer vos compétences en base de données en les enregistrant dans une base de données MySQL.

Pour commencer, ouvrez une invite MySQL en tant qu’utilisateur * root * MySQL:

sudo mysql

Ensuite, créez la base de données en lançant:

CREATE DATABASE `birthdays`;

Puis sélectionnez cette base de données en tapant:

USE birthdays;

Ensuite, créez deux tables dans cette base de données. Nous utiliserons la première table pour suivre les enregistrements de vos amis au bowling. La commande suivante va créer une table appelée + tourneys + avec des colonnes pour le + nom + de chacun de vos amis, le nombre de tournois qu’ils ont gagnés (+ victoires +), leur score absolu + meilleur + , et quelle taille chaussure de bowling ils portent (+ taille +):

CREATE TABLE tourneys (
name varchar(30),
wins real,
best real,
size real
);

Une fois que vous avez exécuté la commande + CREATE TABLE et que vous l’avez renseigné avec des en-têtes de colonne, vous recevrez le résultat suivant:

OutputQuery OK, 0 rows affected (0.00 sec)

Remplissez le tableau + tourneys + avec des exemples de données:

INSERT INTO tourneys (name, wins, best, size)
VALUES ('Dolly', '7', '245', '8.5'),
('Etta', '4', '283', '9'),
('Irma', '9', '266', '7'),
('Barbara', '2', '197', '7.5'),
('Gladys', '13', '273', '8');

Vous recevrez une sortie comme celle-ci:

OutputQuery OK, 5 rows affected (0.01 sec)
Records: 5  Duplicates: 0  Warnings: 0

Ensuite, créez une autre table dans la même base de données que nous utiliserons pour stocker des informations sur les repas d’anniversaire préférés de vos amis. La commande suivante crée une table nommée + dinners + avec des colonnes pour le + nom + de chacun de vos amis, leur + date de naissance +, leur favori + entree +, leur plat préféré '+ côté + et leur favori + dessert + `:

CREATE TABLE dinners (
name varchar(30),
birthdate date,
entree varchar(30),
side varchar(30),
dessert varchar(30)
);

De même pour cette table, vous recevrez un retour confirmant que la commande a été exécutée avec succès:

OutputQuery OK, 0 rows affected (0.01 sec)

Remplissez ce tableau avec des exemples de données également:

INSERT INTO dinners (name, birthdate, entree, side, dessert)
VALUES ('Dolly', '1946-01-19', 'steak', 'salad', 'cake'),
('Etta', '1938-01-25', 'chicken', 'fries', 'ice cream'),
('Irma', '1941-02-18', 'tofu', 'fries', 'cake'),
('Barbara', '1948-12-25', 'tofu', 'salad', 'ice cream'),
('Gladys', '1944-05-28', 'steak', 'fries', 'ice cream');
OutputQuery OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

Une fois cette commande terminée, vous avez fini de configurer votre base de données. Ensuite, nous allons passer en revue la structure de commande de base des requêtes + SELECT +.

Comprendre les instructions SELECT

Comme mentionné dans l’introduction, les requêtes SQL commencent presque toujours par l’instruction + SELECT +. + SELECT + est utilisé dans les requêtes pour spécifier les colonnes d’une table à renvoyer dans le jeu de résultats. De plus, les requêtes incluent presque toujours + FROM +, utilisé pour spécifier la table interrogée par l’instruction.

Généralement, les requêtes SQL suivent cette syntaxe:

SELECT  FROM  WHERE ;

À titre d’exemple, l’instruction suivante renverra l’intégralité de la colonne + name + de la table + dinners +:

SELECT name FROM dinners;
Output+---------+
| name    |
+---------+
| Dolly   |
| Etta    |
| Irma    |
| Barbara |
| Gladys  |
+---------+
5 rows in set (0.00 sec)

Vous pouvez sélectionner plusieurs colonnes de la même table en séparant leurs noms par une virgule, comme ceci:

SELECT name, birthdate FROM dinners;
Output+---------+------------+
| name    | birthdate  |
+---------+------------+
| Dolly   | 1946-01-19 |
| Etta    | 1938-01-25 |
| Irma    | 1941-02-18 |
| Barbara | 1948-12-25 |
| Gladys  | 1944-05-28 |
+---------+------------+
5 rows in set (0.00 sec)

Au lieu de nommer une colonne spécifique ou un ensemble de colonnes, vous pouvez suivre l’opérateur + SELECT + avec un astérisque (+ * +) qui sert d’espace réservé représentant toutes les colonnes d’une table. La commande suivante renvoie chaque colonne de la table + tourneys +:

SELECT * FROM tourneys;
Output+---------+------+------+------+
| name    | wins | best | size |
+---------+------+------+------+
| Dolly   |    7 |  245 |  8.5 |
| Etta    |    4 |  283 |    9 |
| Irma    |    9 |  266 |    7 |
| Barbara |    2 |  197 |  7.5 |
| Gladys  |   13 |  273 |    8 |
+---------+------+------+------+
5 rows in set (0.00 sec)

+ WHERE + est utilisé dans les requêtes pour filtrer les enregistrements qui répondent à une condition spécifiée, et toutes les lignes qui ne répondent pas à cette condition sont éliminées du résultat. Une clause + WHERE + suit généralement cette syntaxe:

. . . WHERE

L’opérateur de comparaison dans une clause + WHERE + définit comment la colonne spécifiée doit être comparée à la valeur. Voici quelques opérateurs de comparaison SQL courants:

Operator What it does

=

tests for equality

!=

tests for inequality

<

tests for less-than

>

tests for greater-than

<=

tests for less-than or equal-to

>=

tests for greater-than or equal-to

BETWEEN

tests whether a value lies within a given range

IN

tests whether a row’s value is contained in a set of specified values

EXISTS

tests whether rows exist, given the specified conditions

LIKE

tests whether a value matches a specified string

IS NULL

tests for NULL values

IS NOT NULL

tests for all values other than NULL

Par exemple, si vous voulez trouver la pointure d’Irma, vous pouvez utiliser la requête suivante:

SELECT size FROM tourneys WHERE name = 'Irma';
Output+------+
| size |
+------+
|    7 |
+------+
1 row in set (0.00 sec)

SQL autorise l’utilisation de caractères génériques, particulièrement utiles dans les clauses + WHERE +. Les signes de pourcentage (+% +) représentent zéro ou plusieurs caractères inconnus et les traits de soulignement (+ _ +) représentent un seul caractère inconnu. Celles-ci sont utiles si vous essayez de trouver une entrée spécifique dans une table, mais ne savez pas exactement quelle est cette entrée. Par exemple, supposons que vous ayez oublié l’entrée préférée de quelques-uns de vos amis, mais vous êtes certain que cette entrée commence par un «t». Vous pouvez trouver son nom en lançant la requête suivante:

SELECT entree FROM dinners WHERE entree LIKE 't%';
Output+--------+
| entree |
+--------+
| tofu   |
| tofu   |
+--------+
2 rows in set (0.00 sec)

Sur la base des résultats ci-dessus, nous voyons que l’entrée que nous avons oubliée est + tofu +.

Il peut arriver que vous travailliez avec des bases de données contenant des colonnes ou des tables avec des noms relativement longs ou difficiles à lire. Dans ces cas, vous pouvez rendre ces noms plus lisibles en créant un alias avec le mot clé + AS +. Les alias créés avec + AS + sont temporaires et n’existent que pour la durée de la requête pour laquelle ils ont été créés:

SELECT name AS n, birthdate AS b, dessert AS d FROM dinners;
Output+---------+------------+-----------+
| n       | b          | d         |
+---------+------------+-----------+
| Dolly   | 1946-01-19 | cake      |
| Etta    | 1938-01-25 | ice cream |
| Irma    | 1941-02-18 | cake      |
| Barbara | 1948-12-25 | ice cream |
| Gladys  | 1944-05-28 | ice cream |
+---------+------------+-----------+
5 rows in set (0.00 sec)

Ici, nous avons dit à SQL d’afficher la colonne + nom + sous la forme + n +, la colonne + date de naissance + sous la forme '+ b + et la colonne + dessert + sous la forme' + d +.

Les exemples que nous avons cités jusqu’à présent incluent certains des mots clés et clauses les plus fréquemment utilisés dans les requêtes SQL. Celles-ci sont utiles pour les requêtes de base, mais ne le sont pas si vous essayez d’effectuer un calcul ou de dériver une valeur scalar (une valeur unique, par opposition à un ensemble de valeurs différentes) en fonction de vos données. C’est ici que les fonctions d’agrégat entrent en jeu.

Fonctions d’agrégat

Souvent, lorsque vous travaillez avec des données, vous ne voulez pas nécessairement voir les données elles-mêmes. Vous voulez plutôt des informations sur les données. La syntaxe SQL inclut un certain nombre de fonctions qui vous permettent d’interpréter ou d’exécuter des calculs sur vos données en émettant simplement une requête + SELECT +. Celles-ci sont appelées fonctions d’agrégation.

La fonction + COUNT + compte et renvoie le nombre de lignes correspondant à certains critères. Par exemple, si vous souhaitez savoir combien de vos amis préfèrent le tofu pour leur entrée d’anniversaire, vous pouvez lancer la requête suivante:

SELECT COUNT(entree) FROM dinners WHERE entree = 'tofu';
Output+---------------+
| COUNT(entree) |
+---------------+
|             2 |
+---------------+
1 row in set (0.00 sec)

La fonction + AVG + renvoie la valeur moyenne (moyenne) d’une colonne. En utilisant notre exemple de tableau, vous pouvez trouver le meilleur score moyen parmi vos amis avec cette requête:

SELECT AVG(best) FROM tourneys;
Output+-----------+
| AVG(best) |
+-----------+
|     252.8 |
+-----------+
1 row in set (0.00 sec)

+ SUM + est utilisé pour trouver la somme totale d’une colonne donnée. Par exemple, si vous souhaitez voir le nombre de jeux que vous et vos amis avez joués au fil des ans, vous pouvez lancer la requête suivante:

SELECT SUM(wins) FROM tourneys;
Output+-----------+
| SUM(wins) |
+-----------+
|        35 |
+-----------+
1 row in set (0.00 sec)

Notez que les fonctions + AVG + et + SUM + ne fonctionneront correctement que si elles sont utilisées avec des données numériques. Si vous essayez de les utiliser sur des données non numériques, il en résultera soit une erreur, soit simplement «+ 0 +», selon le SGBDR que vous utilisez:

SELECT SUM(entree) FROM dinners;
Output+-------------+
| SUM(entree) |
+-------------+
|           0 |
+-------------+
1 row in set, 5 warnings (0.00 sec)

+ MIN + est utilisé pour trouver la plus petite valeur dans une colonne spécifiée. Vous pouvez utiliser cette requête pour voir quel est le pire record de bowling global à ce jour (en termes de nombre de victoires):

SELECT MIN(wins) FROM tourneys;
Output+-----------+
| MIN(wins) |
+-----------+
|         2 |
+-----------+
1 row in set (0.00 sec)

De même, + MAX + est utilisé pour trouver la plus grande valeur numérique dans une colonne donnée. La requête suivante montrera le meilleur record de bowling global:

SELECT MAX(wins) FROM tourneys;
Output+-----------+
| MAX(wins) |
+-----------+
|        13 |
+-----------+
1 row in set (0.00 sec)

Contrairement à + ​​SUM et` + AVG`, les fonctions + MIN et` + MAX` peuvent être utilisées pour les types de données numériques et alphabétiques. Lorsqu’elle est exécutée sur une colonne contenant des valeurs de chaîne, la fonction + MIN + affiche la première valeur par ordre alphabétique:

SELECT MIN(name) FROM dinners;
Output+-----------+
| MIN(name) |
+-----------+
| Barbara   |
+-----------+
1 row in set (0.00 sec)

De même, lorsqu’elle est exécutée sur une colonne contenant des valeurs de chaîne, la fonction + MAX + affiche la dernière valeur par ordre alphabétique:

SELECT MAX(name) FROM dinners;
Output+-----------+
| MAX(name) |
+-----------+
| Irma      |
+-----------+
1 row in set (0.00 sec)

Les fonctions d’agrégat ont de nombreuses utilisations autres que celles décrites dans cette section. Elles sont particulièrement utiles lorsqu’elles sont utilisées avec la clause + GROUP BY +, qui est décrite dans la section suivante, ainsi que plusieurs autres clauses de requête qui affectent la manière dont les ensembles de résultats sont triés.

Manipulation des sorties de requête

Outre les clauses + FROM et` + WHERE`, il existe plusieurs autres clauses permettant de manipuler les résultats d’une requête + SELECT +. Dans cette section, nous allons expliquer et fournir des exemples pour certaines des clauses de requête les plus couramment utilisées.

L’une des clauses de requête les plus fréquemment utilisées, à l’exception de + FROM et` + WHERE`, est la clause + GROUP BY. Il est généralement utilisé lorsque vous exécutez une fonction d’agrégation sur une colonne, mais en relation avec la correspondance de valeurs dans une autre.

Par exemple, supposons que vous vouliez savoir combien de vos amis préfèrent chacune des trois entrées que vous faites. Vous pouvez trouver cette information avec la requête suivante:

SELECT COUNT(name), entree FROM dinners GROUP BY entree;
Output+-------------+---------+
| COUNT(name) | entree  |
+-------------+---------+
|           1 | chicken |
|           2 | steak   |
|           2 | tofu    |
+-------------+---------+
3 rows in set (0.00 sec)

La clause + ORDER BY est utilisée pour trier les résultats de la requête. Par défaut, les valeurs numériques sont triées par ordre croissant et les valeurs de texte par ordre alphabétique. Pour illustrer cela, la requête suivante répertorie les colonnes + name et` + birthdate`, mais trie les résultats par date de naissance:

SELECT name, birthdate FROM dinners ORDER BY birthdate;
Output+---------+------------+
| name    | birthdate  |
+---------+------------+
| Etta    | 1938-01-25 |
| Irma    | 1941-02-18 |
| Gladys  | 1944-05-28 |
| Dolly   | 1946-01-19 |
| Barbara | 1948-12-25 |
+---------+------------+
5 rows in set (0.00 sec)

Notez que le comportement par défaut de + ORDER BY + consiste à trier le jeu de résultats par ordre croissant. Pour inverser cela et avoir le jeu de résultats trié par ordre décroissant, fermez la requête avec + DESC +:

SELECT name, birthdate FROM dinners ORDER BY birthdate DESC;
Output+---------+------------+
| name    | birthdate  |
+---------+------------+
| Barbara | 1948-12-25 |
| Dolly   | 1946-01-19 |
| Gladys  | 1944-05-28 |
| Irma    | 1941-02-18 |
| Etta    | 1938-01-25 |
+---------+------------+
5 rows in set (0.00 sec)

Comme mentionné précédemment, la clause + WHERE + est utilisée pour filtrer les résultats en fonction de conditions spécifiques. Toutefois, si vous utilisez la clause + WHERE + avec une fonction d’agrégat, une erreur sera renvoyée, comme dans le cas de la tentative suivante pour déterminer quels côtés sont les favoris d’au moins trois de vos amis:

SELECT COUNT(name), side FROM dinners WHERE COUNT(name) >= 3;
OutputERROR 1111 (HY000): Invalid use of group function

La clause + HAVING + a été ajoutée à SQL pour fournir une fonctionnalité similaire à celle de la clause + WHERE + tout en étant également compatible avec les fonctions d’agrégat. Il est utile de penser à la différence entre ces deux clauses en ce sens que "+ WHERE " s’applique à des enregistrements individuels, tandis que " HAVING " s’applique aux enregistrements de groupe. À cette fin, chaque fois que vous publiez une clause ` HAVING`, la clause` + GROUP BY` doit également être présente.

L’exemple suivant est une autre tentative de recherche des plats d’accompagnement préférés d’au moins trois de vos amis, bien que celui-ci renvoie un résultat sans erreur:

SELECT COUNT(name), side FROM dinners GROUP BY side HAVING COUNT(name) >= 3;
Output+-------------+-------+
| COUNT(name) | side  |
+-------------+-------+
|           3 | fries |
+-------------+-------+
1 row in set (0.00 sec)

Les fonctions d’agrégation sont utiles pour résumer les résultats d’une colonne particulière dans un tableau donné. Cependant, dans de nombreux cas, il est nécessaire d’interroger le contenu de plusieurs tables. Nous allons examiner plusieurs façons de procéder dans la section suivante.

Interroger plusieurs tables

Le plus souvent, une base de données contient plusieurs tables, chacune contenant différents ensembles de données. SQL fournit différentes manières d’exécuter une requête unique sur plusieurs tables.

La clause + JOIN + peut être utilisée pour combiner des lignes de deux ou plusieurs tables dans un résultat de requête. Pour ce faire, il recherche une colonne liée entre les tables et trie les résultats de manière appropriée dans la sortie.

Les instructions + SELECT + qui incluent une clause + JOIN + suivent généralement cette syntaxe:

SELECT ., .
FROM
JOIN  ON .=.;

Notez que, comme les clauses + JOIN + comparent le contenu de plusieurs tables, l’exemple précédent spécifie la table dans laquelle sélectionner chaque colonne en précédant le nom de la colonne avec le nom de la table et un point. Vous pouvez spécifier la table dans laquelle une colonne doit être sélectionnée de la sorte, quelle que soit la requête, bien que cela ne soit pas nécessaire lors de la sélection dans une seule table, comme nous l’avons fait dans les sections précédentes. Passons en exemple avec les exemples de données.

Imaginez que vous vouliez offrir à chacun de vos amis une paire de chaussures de bowling comme cadeau d’anniversaire. Les informations sur la date de naissance et la pointure de vos amis étant conservées dans des tableaux distincts, vous pouvez interroger les deux tableaux séparément, puis comparer les résultats. Avec une clause + JOIN +, vous pouvez cependant trouver toutes les informations souhaitées en une seule requête:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
JOIN dinners ON tourneys.name=dinners.name;
Output+---------+------+------------+
| name    | size | birthdate  |
+---------+------+------------+
| Dolly   |  8.5 | 1946-01-19 |
| Etta    |    9 | 1938-01-25 |
| Irma    |    7 | 1941-02-18 |
| Barbara |  7.5 | 1948-12-25 |
| Gladys  |    8 | 1944-05-28 |
+---------+------+------------+
5 rows in set (0.00 sec)

La clause + JOIN utilisée dans cet exemple, sans aucun autre argument, est une clause interne` + JOIN`. Cela signifie qu’il sélectionne tous les enregistrements dont les valeurs correspondent dans les deux tables et les imprime dans le jeu de résultats, tandis que tous les enregistrements qui ne correspondent pas sont exclus. Pour illustrer cette idée, ajoutons une nouvelle ligne à chaque table qui n’a pas d’entrée correspondante dans l’autre:

INSERT INTO tourneys (name, wins, best, size)
VALUES ('Bettye', '0', '193', '9');
INSERT INTO dinners (name, birthdate, entree, side, dessert)
VALUES ('Lesley', '1946-05-02', 'steak', 'salad', 'ice cream');

Ensuite, relancez l’instruction + SELECT + précédente avec la clause + JOIN +:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
JOIN dinners ON tourneys.name=dinners.name;
Output+---------+------+------------+
| name    | size | birthdate  |
+---------+------+------------+
| Dolly   |  8.5 | 1946-01-19 |
| Etta    |    9 | 1938-01-25 |
| Irma    |    7 | 1941-02-18 |
| Barbara |  7.5 | 1948-12-25 |
| Gladys  |    8 | 1944-05-28 |
+---------+------+------------+
5 rows in set (0.00 sec)

Notez que, comme la table + tourneys + n’a pas d’entrée pour Lesley et que la table + dinners + n’a pas d’entrée pour Bettye, ces enregistrements sont absents de cette sortie.

Il est toutefois possible de renvoyer tous les enregistrements d’une des tables à l’aide d’une clause outer + JOIN +. Dans MySQL, les clauses + JOIN + sont écrites sous la forme + LEFT JOIN + ou + RIGHT JOIN +.

Une clause + LEFT JOIN + renvoie tous les enregistrements de la table «gauche» et uniquement les enregistrements correspondants de la table de droite. Dans le contexte des jointures externes, la table de gauche est celle référencée par la clause + FROM + et la table de droite, toute table référencée après l’instruction + JOIN +.

Exécutez à nouveau la requête précédente, mais cette fois-ci, utilisez la clause + LEFT JOIN +:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
LEFT JOIN dinners ON tourneys.name=dinners.name;

Cette commande retournera tous les enregistrements de la table de gauche (dans ce cas, + tourneys +) même s’il n’a pas d’enregistrement correspondant dans la table de droite. Chaque fois qu’il n’ya pas d’enregistrement correspondant dans la table de droite, il est renvoyé sous la forme «+ NULL +» ou simplement une valeur vide, selon votre SGBDR:

Output+---------+------+------------+
| name    | size | birthdate  |
+---------+------+------------+
| Dolly   |  8.5 | 1946-01-19 |
| Etta    |    9 | 1938-01-25 |
| Irma    |    7 | 1941-02-18 |
| Barbara |  7.5 | 1948-12-25 |
| Gladys  |    8 | 1944-05-28 |
| Bettye  |    9 | NULL       |
+---------+------+------------+
6 rows in set (0.00 sec)

Maintenant, exécutez à nouveau la requête, cette fois avec une clause + RIGHT JOIN +:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
RIGHT JOIN dinners ON tourneys.name=dinners.name;

Cela renverra tous les enregistrements de la table de droite (+ dinners +). Comme la date de naissance de Lesley est enregistrée dans le tableau de droite, mais qu’il n’ya pas de ligne correspondante pour elle dans le tableau de gauche, les colonnes + name + et + size + renverront sous la forme de valeurs + NULL + dans cette rangée:

Output+---------+------+------------+
| name    | size | birthdate  |
+---------+------+------------+
| Dolly   |  8.5 | 1946-01-19 |
| Etta    |    9 | 1938-01-25 |
| Irma    |    7 | 1941-02-18 |
| Barbara |  7.5 | 1948-12-25 |
| Gladys  |    8 | 1944-05-28 |
| NULL    | NULL | 1946-05-02 |
+---------+------+------------+
6 rows in set (0.00 sec)

Notez que les jointures gauche et droite peuvent être écrites comme + LEFT OUTER JOIN + ou + + RIGHT OUTER JOIN +, bien que la partie + OUTER + de la clause soit implicite. De même, spécifier + INNER JOIN produira le même résultat que d’écrire simplement` + JOIN`.

Au lieu d’utiliser + JOIN + pour interroger les enregistrements de plusieurs tables, vous pouvez utiliser la clause + UNION +.

L’opérateur + UNION + fonctionne légèrement différemment d’une clause + JOIN +: au lieu d’imprimer les résultats de plusieurs tables sous la forme de colonnes uniques utilisant une seule instruction + SELECT +, + UNION + combine les résultats de deux instructions + SELECT + dans une seule colonne.

Pour illustrer, exécutez la requête suivante:

SELECT name FROM tourneys UNION SELECT name FROM dinners;

Cette requête supprimera toutes les entrées en double, ce qui correspond au comportement par défaut de l’opérateur + UNION:

Output+---------+
| name    |
+---------+
| Dolly   |
| Etta    |
| Irma    |
| Barbara |
| Gladys  |
| Bettye  |
| Lesley  |
+---------+
7 rows in set (0.00 sec)

Pour renvoyer toutes les entrées (y compris les doublons), utilisez l’opérateur + UNION ALL +:

SELECT name FROM tourneys UNION ALL SELECT name FROM dinners;
Output+---------+
| name    |
+---------+
| Dolly   |
| Etta    |
| Irma    |
| Barbara |
| Gladys  |
| Bettye  |
| Dolly   |
| Etta    |
| Irma    |
| Barbara |
| Gladys  |
| Lesley  |
+---------+
12 rows in set (0.00 sec)

Les noms et le nombre de colonnes dans la table de résultats reflètent le nom et le nombre de colonnes interrogées par la première instruction + SELECT +. Notez que lorsque vous utilisez + UNION + pour interroger plusieurs colonnes de plusieurs tables, chaque instruction + SELECT + doit interroger le même nombre de colonnes, les colonnes respectives doivent avoir des types de données similaires et les colonnes de chaque + SELECT + déclaration doit être dans le même ordre. L’exemple suivant montre ce qui pourrait résulter si vous utilisez une clause + UNION sur deux instructions` + SELECT` qui interrogent un nombre différent de colonnes:

SELECT name FROM dinners UNION SELECT name, wins FROM tourneys;
OutputERROR 1222 (21000): The used SELECT statements have a different number of columns

Une autre façon d’interroger plusieurs tables consiste à utiliser subqueries. Les sous-requêtes (également appelées requêtes inner ou _nested) sont des requêtes contenues dans une autre requête. Celles-ci sont utiles dans les cas où vous essayez de filtrer les résultats d’une requête par rapport au résultat d’une fonction d’agrégation distincte.

Pour illustrer cette idée, disons que vous voulez savoir lequel de vos amis a gagné plus de matches que Barbara. Plutôt que de demander combien de correspondances ont été remportées par Barbara, lancez une autre requête pour voir qui a gagné plus de jeux que vous, vous pouvez calculer les deux avec une seule requête:

SELECT name, wins FROM tourneys
WHERE wins > (
SELECT wins FROM tourneys WHERE name = 'Barbara'
);
Output+--------+------+
| name   | wins |
+--------+------+
| Dolly  |    7 |
| Etta   |    4 |
| Irma   |    9 |
| Gladys |   13 |
+--------+------+
4 rows in set (0.00 sec)

La sous-requête de cette instruction n’a été exécutée qu’une seule fois; il suffisait de trouver la valeur de la colonne + wins + dans la même ligne que + Barbara + dans la colonne + name +, et les données renvoyées par la sous-requête et la requête externe sont indépendantes les unes des autres. Il existe cependant des cas où la requête externe doit d’abord lire chaque ligne d’une table et comparer ces valeurs aux données renvoyées par la sous-requête afin de renvoyer les données souhaitées. Dans ce cas, la sous-requête est appelée sous-requête correlated.

L’instruction suivante est un exemple de sous-requête corrélée. Cette requête cherche à trouver lequel de vos amis a gagné plus de jeux que la moyenne de ceux qui ont la même pointure:

SELECT name, size FROM tourneys AS t
WHERE wins > (
SELECT AVG(wins) FROM tourneys WHERE size = t.size
);

Pour que la requête se termine, il faut d’abord collecter les colonnes + noms et` + taille de` de la requête externe. Ensuite, il compare chaque ligne de cet ensemble de résultats aux résultats de la requête interne, ce qui détermine le nombre moyen de gains pour des personnes ayant une taille de chaussure identique. Parce que vous n’avez que deux amis qui ont la même pointure, il ne peut y avoir qu’une seule ligne dans le jeu de résultats:

Output+------+------+
| name | size |
+------+------+
| Etta |    9 |
+------+------+
1 row in set (0.00 sec)

Comme mentionné précédemment, les sous-requêtes peuvent être utilisées pour interroger les résultats de plusieurs tables. Pour illustrer cela avec un dernier exemple, disons que vous vouliez organiser un dîner surprise pour le meilleur quilleur de tous les temps du groupe. Vous pouvez trouver lequel de vos amis a le meilleur record de bowling et retourner son repas préféré avec la requête suivante:

SELECT name, entree, side, dessert
FROM dinners
WHERE name = (SELECT name FROM tourneys
WHERE wins = (SELECT MAX(wins) FROM tourneys));
Output+--------+--------+-------+-----------+
| name   | entree | side  | dessert   |
+--------+--------+-------+-----------+
| Gladys | steak  | fries | ice cream |
+--------+--------+-------+-----------+
1 row in set (0.00 sec)

Notez que cette instruction inclut non seulement une sous-requête, mais également une sous-requête au sein de cette sous-requête.

Conclusion

L’émission de requêtes est l’une des tâches les plus courantes dans le domaine de la gestion de base de données. Il existe un certain nombre d’outils d’administration de base de données, tels que phpMyAdmin ou pgAdmin, qui vous permettent d’effectuer des requêtes et de visualiser les résultats, mais émettre des instructions + SELECT + à partir de la ligne de commande reste un workflow largement utilisé qui peut également vous fournir un contrôle plus important.

Si vous débutez avec SQL, nous vous encourageons à utiliser notre SQL Cheat Sheet référence et de consulter la documentation officielle de MySQL. De plus, si vous souhaitez en savoir plus sur SQL et les bases de données relationnelles, les didacticiels suivants pourraient vous intéresser:

Related