Utilisation de MySQL JOIN

Dans les chapitres précédents, nous avons appris comment lire des données à partir d'une seule table, ce qui est relativement simple, mais dans les applications réelles, nous devons souvent lire des données à partir de plusieurs tables de données.

Dans ce chapitre, nous allons présenter comment utiliser JOIN de MySQL pour interroger des données dans deux ou plusieurs tables.

Vous pouvez utiliser JOIN de MySQL dans les instructions SELECT, UPDATE et DELETE pour effectuer des requêtes multi-tables.

JOIN peut être grossièrement divisé en trois catégories selon sa fonctionnalité :

  • INNER JOIN (jointure interne, ou équijointure) :Récupère les enregistrements avec des relations de champs correspondantes dans les deux tables.
  • LEFT JOIN (jointure gauche) :Récupère tous les enregistrements de la table de gauche, même si la table de droite n'a pas d'enregistrements correspondants.
  • RIGHT JOIN (jointure droite) :Opposé de LEFT JOIN, utilisé pour récupérer tous les enregistrements de la table de droite, même si la table de gauche n'a pas d'enregistrements correspondants.

Structure de la base de données et téléchargement des données utilisés dans ce chapitre :example-mysql-join-test.sql。

INNER JOIN

INNER JOIN renvoie les lignes correspondantes qui satisfont la condition de jointure dans les deux tables. Voici la syntaxe de base de l'instruction INNER JOIN :

SELECT column1, column2, ...
FROM table1
INNER JOIN table2 ON table1.column_name = table2.column_name;

Description du paramètre :

  • column1, column2, ... sont les noms des colonnes que vous souhaitez sélectionner. Si vous utilisez*signifie sélectionner toutes les colonnes.
  • table1, table2sont les noms des deux tables à joindre.
  • table1.column_name = table2.column_nameest la condition de jointure, spécifiant les colonnes utilisées pour la mise en correspondance dans les deux tables.

INNER JOIN simple :

SELECT orders.order_id, customers.customer_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id;

L'instruction SQL ci-dessus sélectionnera l'ID de commande et le nom du client depuis la table orders et la table customers qui satisfont la condition de jointure.

2. Utilisation d'alias de table :

SELECT o.order_id, c.customer_name
FROM orders AS o
INNER JOIN customers AS c ON o.customer_id = c.customer_id;

L'instruction SQL ci-dessus utilise les alias de table o et c comme alias pour les tables orders et customers.

3. INNER JOIN sur plusieurs tables :

SELECT orders.order_id, customers.customer_name, products.product_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id
INNER JOIN order_items ON orders.order_id = order_items.order_id
INNER JOIN products ON order_items.product_id = products.product_id;

L'instruction SQL ci-dessus implique la jointure de quatre tables : orders, customers, order_items et products. Elle sélectionne l'ID de commande, le nom du client et le nom du produit, et joint les colonnes associées de ces tables.

4. Filtrage avec la clause WHERE :

SELECT orders.order_id, customers.customer_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id
WHERE orders.order_date >= '2023-01-01';

L'instruction SQL ci-dessus utilise la clause WHERE après INNER JOIN pour filtrer les commandes dont la date de commande est le '2023-01-01' ou après.

LEFT JOIN

LEFT JOIN renvoie toutes les lignes de la table de gauche et inclut les lignes correspondantes de la table de droite. S'il n'existe aucune ligne correspondante dans la table de droite, des valeurs NULL seront renvoyées. Voici la syntaxe de base de l'instruction LEFT JOIN :

SELECT column1, column2, ...
FROM table1
LEFT JOIN table2 ON table1.column_name = table2.column_name;

1. LEFT JOIN simple :

SELECT customers.customer_id, customers.customer_name, orders.order_id
FROM customers
LEFT JOIN orders ON customers.customer_id = orders.customer_id;

L'instruction SQL ci-dessus sélectionnera l'ID client et le nom du client dans la table customer, et inclura toutes les lignes de la table de gauche customers, ainsi que l'ID de commande correspondant (le cas échéant).

2. Utilisation d'alias de table :

SELECT c.customer_id, c.customer_name, o.order_id
FROM customers AS c
LEFT JOIN orders AS o ON c.customer_id = o.customer_id;

L'instruction SQL ci-dessus utilise les alias de table c et o pour remplacer respectivement les noms des tables customers et orders.

3. LEFT JOIN sur plusieurs tables :

SELECT customers.customer_id, customers.customer_name, orders.order_id, products.product_name
FROM customers
LEFT JOIN orders ON customers.customer_id = orders.customer_id
LEFT JOIN order_items ON orders.order_id = order_items.order_id
LEFT JOIN products ON order_items.product_id = products.product_id;

L'instruction SQL ci-dessus joint quatre tables : customers, orders, order_items et products, et sélectionne l'ID client, le nom du client, l'ID de commande et le nom du produit. La jointure LEFT JOIN garantit que même s'il n'y a aucune ligne correspondante dans order_items ou products, les informations sur le client et la commande sont toujours renvoyées.

4. Filtrage avec la clause WHERE :

SELECT customers.customer_id, customers.customer_name, orders.order_id
FROM customers
LEFT JOIN orders ON customers.customer_id = orders.customer_id
WHERE orders.order_date >= '2023-01-01' OR orders.order_id IS NULL;

L'instruction SQL ci-dessus utilise la clause WHERE après LEFT JOIN pour filtrer les commandes dont la date de commande est postérieure ou égale à '2023-01-01', ainsi que les clients sans commande correspondante.

LEFT JOIN est un type de jointure couramment utilisé, en particulier lorsque vous devez renvoyer toutes les lignes de la table de gauche. Lorsqu'il n'y a pas de ligne correspondante dans la table de droite, les colonnes associées s'affichent comme NULL. Lorsque vous utilisez LEFT JOIN, assurez-vous de comprendre la condition de jointure et de filtrer les résultats selon vos besoins.

RIGHT JOIN

RIGHT JOIN renvoie toutes les lignes de la table de droite et inclut les lignes correspondantes de la table de gauche. S'il n'y a pas de ligne correspondante dans la table de gauche, des valeurs NULL seront renvoyées. Voici la syntaxe de base de l'instruction RIGHT JOIN :

SELECT column1, column2, ...
FROM table1
RIGHT JOIN table2 ON table1.column_name = table2.column_name;

Voici un exemple simple de RIGHT JOIN :

SELECT customers.customer_id, orders.order_id
FROM customers
RIGHT JOIN orders ON customers.customer_id = orders.customer_id;

L'instruction SQL ci-dessus sélectionnera tous les ID de commande de la table de droite orders, et inclura les ID client correspondants de la table de gauche customers. S'il n'y a pas d'ID client correspondant dans la table customers, les colonnes associées s'afficheront comme NULL.

Pendant le développement, RIGHT JOIN n'est pas fréquemment utilisé, car il peut produire le même effet en utilisant LEFT JOIN et en inversant l'ordre des tables. Par exemple, la requête ci-dessus peut être réécrite avec LEFT JOIN comme suit :

SELECT customers.customer_id, orders.order_id
FROM orders
LEFT JOIN customers ON orders.customer_id = customers.customer_id;

L'instruction SQL ci-dessus renvoie le même résultat, car LEFT JOIN et RIGHT JOIN sont symétriques. En pratique, vous pouvez choisir la forme à utiliser selon vos préférences personnelles ou les normes de votre organisation.


Utilisation de INNER JOIN dans l'invite de commandes

INNER JOIN peut joindre plusieurs tables ensemble en fonction de la condition de jointure spécifiée, ce qui vous permet de récupérer des données associées dans une requête.

Lorsque vous utilisez INNER JOIN, assurez-vous que la condition de jointure est exacte et comprenez les relations entre les tables jointes.

Exemple

Nous avons deux tables, tcount_tbl et example_tbl, dans la base de données EXAMPLE.

Essayez l'exemple suivant :

Données de test pour l'exemple

mysql> use EXAMPLE; Base de données modifiée mysql> SELECT * FROM tcount_tbl; +---------------+--------------+ | example_author | example_count| +---------------+--------------+ | Example Tutorial |10 | | EXAMPLE.COM | 20 | | Google | 22 | +---------------+--------------+ 3 rows in set (0.01 sec) mysql> SELECT * from example_tbl; +-----------+---------------+---------------+-----------------+ | example_id | example_title | example_author | submission_date | +-----------+---------------+---------------+-----------------+ | 1| ApprentissagePHP| Tutoriel d'exemple |2017-04-12 | | 2| ApprentissageMySQL| Tutoriel d'exemple |2017-04-12 | | 3| ApprentissageJava | EXAMPLE.COM | 2015-05-01 | | 4| ApprentissagePython | EXAMPLE.COM | 2016-03-06 | | 5| ApprentissageC | FK | 2017-04-05 | +-----------+---------------+---------------+-----------------+ 5 lignes dans set (0.01 sec)

Ensuite, nous utilisons MySQLINNER JOIN (vous pouvez également omettre INNER et utiliser JOIN, avec le même effet)pour joindre les deux tables ci-dessus afin de lire les valeurs du champ example_count dans la table tcount_tbl correspondant à tous les champs example_author de la table example_tbl :

INNER JOIN

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a INNER JOIN tcount_tbl b ON a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Tutoriel d'exemple |10 | | 2| Tutoriel d'exemple |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | +-------------+-----------------+----------------+ 4 lignes dans set (0.00 sec)

L'instruction SQL ci-dessus est équivalente à :

Clause WHERE

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a, tcount_tbl b WHERE a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Tutoriel d'exemple |10 | | 2| Tutoriel d'exemple |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | +-------------+-----------------+----------------+ 4 lignes dans le jeu (0.01 sec)


MySQL LEFT JOIN

LEFT JOIN est un type de jointure couramment utilisé, en particulier lorsque vous devez renvoyer toutes les lignes de la table de gauche.

Lorsqu'il n'y a pas de ligne correspondante dans la table de droite, les colonnes associées s'affichent comme NULL.

Lorsque vous utilisez LEFT JOIN, assurez-vous de bien comprendre la condition de jointure et de filtrer les résultats selon vos besoins.

MySQL LEFT JOIN diffère de JOIN ; LEFT JOIN lit toutes les données de la table de données de gauche, même si la table de droite n'a pas de données correspondantes.

Exemple

Essayez l'exemple suivant, en utilisantexample_tblcomme table de gauche,tcount_tblcomme table de droite, pour comprendre l'application de MySQL LEFT JOIN :

LEFT JOIN

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a LEFT JOIN tcount_tbl b ON a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Tutoriel d'exemple |10 | | 2| Tutoriel d'exemple |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | | 5 | FK | NULL | +-------------+-----------------+----------------+ 5 lignes dans le jeu (0.01 sec)

L'exemple ci-dessus utilise LEFT JOIN, qui lit toutes les données des champs sélectionnés dans la table de données de gauche example_tbl, même s'il n'y a pas de valeur de champ example_author correspondante dans la table de droite tcount_tbl.


MySQL RIGHT JOIN

MySQL RIGHT JOIN lit toutes les données de la table de données de droite, même si la table de gauche n'a pas de données correspondantes.

Dans le développement réel, RIGHT JOIN n'est pas fréquemment utilisé, car il peut obtenir le même effet en utilisant LEFT JOIN et en intervertissant l'ordre des tables.

Exemple

Essayez l'exemple suivant, en utilisantexample_tblcomme table de gauche,tcount_tblcomme table de droite, pour comprendre l'application de MySQL RIGHT JOIN :

RIGHT JOIN

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a RIGHT JOIN tcount_tbl b ON a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Tutoriel d'exemple |10 | | 2| Tutoriel d'exemple |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | | NULL | NULL | 22 | +-------------+-----------------+----------------+ 5 lignes dans set (0.01 sec)

L'exemple ci-dessus utilise RIGHT JOIN, qui lit toutes les données des champs sélectionnés de la table de données de droite tcount_tbl, même s'il n'y a pas de valeur du champ example_author correspondante dans la table de gauche example_tbl.


Utilisation de JOIN dans les scripts PHP

En PHP, utilisez la fonction mysqli_query() pour exécuter des instructions SQL. Vous pouvez utiliser les mêmes instructions SQL ci-dessus comme paramètres de la fonction mysqli_query().

Essayez l'exemple suivant :

Test de MySQL ORDER BY :

<?php $dbhost = 'localhost'; //adresse de l'hôte du serveur MySQL $dbuser = 'root'; //nom d'utilisateur MySQL $dbpass = '123456'; //mot de passe de l'utilisateur MySQL $conn = mysqli_connect($dbhost, $dbuser, $dbpass); if(! $conn ) { die('Échec de la connexion :' . mysqli_error($conn)); } //Définir l'encodage pour éviter les caractères chinois corrompus mysqli_query($conn , "set names utf8"); $sql = 'SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a INNER JOIN tcount_tbl b ON a.example_author = b.example_author'; mysqli_select_db( $conn, 'EXAMPLE' ); $retval = mysqli_query( $conn, $sql ); if(! $retval ) { die('Impossible de lire les données :' . mysqli_error($conn)); } echo '<h2>Test de JOIN MySQL du tutoriel d'exemple<h2>'; echo '<table border="1"><tr><td>ID du tutoriel</td><td>Auteur</td><td>Nombre de connexions</td></tr>'; while($row = mysqli_fetch_array($retval, MYSQLI_ASSOC)) { echo "<tr><td> {$row['example_id']}</td> ". "<td>{$row['example_author']} </td> ". "<td>{$row['example_count']} </td> ". "</tr>"; } echo '</table>'; mysqli_close($conn); ?>

Le résultat de sortie est présenté dans la figure ci-dessous :

Autres extensions