Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Clause JOIN Une clause SQL JOIN permet de combiner les données de deux ou plusieurs tables sur la base de champs communs. Les résultats peuvent ou non changer en fonction de la méthode de jointure spécifiée. Les jointures externes gauche et droite conservent les valeurs de l’une des tables jointes quand aucune correspondance n’est trouvée dans l’autre table. La combinaison du type JOIN et de la condition de jointure détermine les lignes incluses dans le jeu de résultats final. Les clauses SELECT et WHERE contrôlent ensuite les colonnes renvoyées et la manière dont les lignes sont filtrées. Comprendre les différents types de JOIN et savoir comment les utiliser efficacement est une compétence cruciale en SQL, car cela vous permet de combiner les données de plusieurs tables de manière flexible et puissante. ## Syntaxe ``` SELECT column1, column2, ..., columnn FROM table1 join_type table2 ON table1.column = table2.column; ``` ## Parameters *SÉLECTIONNEZ la colonne 1, la colonne 2,..., la colonne N* Les colonnes que vous souhaitez inclure dans le jeu de résultats. Vous pouvez sélectionner des colonnes dans l'une ou l'autre des tables impliquées dans le JOIN ou dans les deux. *À PARTIR DU TABLEAU 1* La première table (à gauche) de l'opération JOIN. *[JOINTURE \$1 JOINTURE INTÉRIEURE \$1 JOINTURE GAUCHE [EXTÉRIEURE] \$1 JOINTURE DROITE [EXTÉRIEURE] \$1 JOINTURE [EXTÉRIEURE] COMPLÈTE] table2 :* Type de JOIN à exécuter. JOIN ou INNER JOIN renvoie uniquement les lignes dont les valeurs correspondent dans les deux tables. LEFT [OUTER] JOIN renvoie toutes les lignes du tableau de gauche, avec les lignes correspondantes du tableau de droite. RIGHT [OUTER] JOIN renvoie toutes les lignes du tableau de droite, avec les lignes correspondantes du tableau de gauche. FULL [OUTER] JOIN renvoie toutes les lignes des deux tables, qu'il y ait une correspondance ou non. CROSS JOIN crée un produit cartésien des lignes des deux tables. *SUR table1.column = table2.column* La condition de jointure, qui indique comment les lignes des deux tables sont mises en correspondance. La condition de jointure peut être basée sur une ou plusieurs colonnes. *État où :* Clause facultative qui peut être utilisée pour filtrer davantage le jeu de résultats, en fonction d'une condition spécifiée. ## Exemple L’exemple suivant est une jointure entre deux tables avec la clause USING. Dans ce cas, les colonnes listid et eventid sont utilisées comme colonnes de jointure. Les résultats sont limités à seulement cinq lignes. ``` select listid, listing.sellerid, eventid, listing.dateid, numtickets from listing join sales using (listid, eventid) order by 1 limit 5; listid | sellerid | eventid | dateid | numtickets -------+----------+---------+--------+----------- 1 | 36861 | 7872 | 1850 | 10 4 | 8117 | 4337 | 1970 | 8 5 | 1616 | 8647 | 1963 | 4 5 | 1616 | 8647 | 1963 | 4 6 | 47402 | 8240 | 2053 | 18 ``` # Types de jointures ## INNER Il s'agit du type de jointure par défaut. Renvoie les lignes dont les valeurs correspondent dans les deux références de table. L'INNER JOIN est le type de jointure le plus couramment utilisé en SQL. Il s'agit d'un moyen puissant de combiner les données de plusieurs tables sur la base d'une colonne ou d'un ensemble de colonnes communs. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 INNER JOIN table2 ON table1.column = table2.column; ``` La requête suivante renverra toutes les lignes où une valeur customer\$1id correspond entre les tables clients et commandes. Le jeu de résultats contiendra les colonnes customer\$1id, name, order\$1id et order\$1date. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers INNER JOIN orders ON customers.customer_id = orders.customer_id; ``` La requête suivante est une jointure interne (sans le mot-clé JOIN) entre la table LISTING et la table SALES, où la valeur LISTID de la table LISTING est comprise entre 1 et 5. Cette requête met en correspondance les valeurs de la colonne LISTID dans les tables LISTING (table de gauche) et SALES (table de droite). Les résultats montrent que les valeurs LISTID 1, 4 et 5 correspondent aux critères. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing, sales where listing.listid = sales.listid and listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` L’exemple suivant est une jointure interne avec la clause ON. Dans ce cas, les lignes NULL ne sont pas renvoyées. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from sales join listing on sales.listid=listing.listid and sales.eventid=listing.eventid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` La requête suivante est une jointure interne de deux sous-requêtes de la clause FROM. La requête recherche le nombre de billets vendus et invendus pour les différentes catégories d’événements (concerts et spectacles). Les sous-requêtes de la clause FROM sont des sous-requêtes de *table* ; elles peuvent renvoyer plusieurs lignes et colonnes. ``` select catgroup1, sold, unsold from (select catgroup, sum(qtysold) as sold from category c, event e, sales s where c.catid = e.catid and e.eventid = s.eventid group by catgroup) as a(catgroup1, sold) join (select catgroup, sum(numtickets)-sum(qtysold) as unsold from category c, event e, sales s, listing l where c.catid = e.catid and e.eventid = s.eventid and s.listid = l.listid group by catgroup) as b(catgroup2, unsold) on a.catgroup1 = b.catgroup2 order by 1; catgroup1 | sold | unsold ----------+--------+-------- Concerts | 195444 |1067199 Shows | 149905 | 817736 ``` ## GAUCHE [EXTÉRIEUR] Renvoie toutes les valeurs de la référence de table de gauche et les valeurs correspondantes de la référence de table de droite, ou ajoute NULL en cas d'absence de correspondance. Elle est également appelée *jointure extérieure gauche*. Il renvoie toutes les lignes de la table de gauche (première) et les lignes correspondantes de la table de droite (deuxième). S'il n'y a aucune correspondance dans la bonne table, le jeu de résultats contiendra des valeurs NULL pour les colonnes de la bonne table. Le mot clé OUTER peut être omis, et la jointure peut être écrite simplement sous la forme LEFT JOIN. Le contraire d'une jointure externe gauche est une jointure externe droite, qui renvoie toutes les lignes de la table de droite et les lignes correspondantes de la table de gauche. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT [OUTER] JOIN table2 ON table1.column = table2.column; ``` La requête suivante renverra toutes les lignes de la table des clients, ainsi que les lignes correspondantes de la table des commandes. Si un client n'a aucune commande, le jeu de résultats inclura toujours les informations de ce client, avec des valeurs NULL pour les colonnes order\$1id et order\$1date. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers LEFT OUTER JOIN orders ON customers.customer_id = orders.customer_id; ``` La requête suivante est une jointure externe gauche. Les jointures externes gauche et droite conservent les valeurs de l’une des tables jointes quand aucune correspondance n’est trouvée dans l’autre table. Les tables gauche et droite sont la première et la deuxième répertoriées dans la syntaxe. Les valeurs NULL sont utilisées pour combler les « écarts » du jeu de résultats. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Les résultats montrent que LISTIDs 2 et 3 n'ont donné lieu à aucune vente. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing left outer join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 2 | NULL | NULL 3 | NULL | NULL 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` ## DROIT [EXTÉRIEUR] Renvoie toutes les valeurs de la référence de table de droite et les valeurs correspondantes de la référence de table de gauche, ou ajoute NULL en cas d'absence de correspondance. Elle est également appelée *jointure extérieure droite*. Elle renvoie toutes les lignes de la table de droite (deuxième) et les lignes correspondantes de la table de gauche (première). S'il n'y a aucune correspondance dans le tableau de gauche, le jeu de résultats contiendra des valeurs NULL pour les colonnes du tableau de gauche. Le mot clé OUTER peut être omis, et la jointure peut être écrite simplement sous la forme RIGHT JOIN. L'opposé d'une jointure externe droite est une jointure externe gauche, qui renvoie toutes les lignes de la table de gauche et les lignes correspondantes de la table de droite. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 RIGHT [OUTER] JOIN table2 ON table1.column = table2.column; ``` La requête suivante renverra toutes les lignes de la table des clients, ainsi que les lignes correspondantes de la table des commandes. Si un client n'a aucune commande, le jeu de résultats inclura toujours les informations de ce client, avec des valeurs NULL pour les colonnes order\$1id et order\$1date. ``` SELECT orders.order_id, orders.order_date, customers.customer_id, customers.name FROM orders RIGHT OUTER JOIN customers ON orders.customer_id = customers.customer_id; ``` La requête suivante est une jointure externe droite. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Les résultats montrent que LISTIDs 1, 4 et 5 correspondent aux critères. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing right outer join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` ## COMPLET [EXTÉRIEUR] Renvoie toutes les valeurs des deux relations, en ajoutant les valeurs NULL du côté qui ne correspond pas. Elle est également appelée *jointure externe complète*. Il renvoie toutes les lignes des tables de gauche et de droite, qu'il y ait une correspondance ou non. S'il n'y a aucune correspondance, le jeu de résultats contiendra des valeurs NULL pour les colonnes de la table qui n'ont pas de ligne correspondante. Le mot clé OUTER peut être omis, et la jointure peut être écrite simplement sous la forme FULL JOIN. La jointure externe complète est moins couramment utilisée que la jointure externe gauche ou la jointure externe droite, mais elle peut être utile dans certains scénarios où vous devez voir toutes les données des deux tables, même s'il n'y a aucune correspondance. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 FULL [OUTER] JOIN table2 ON table1.column = table2.column; ``` La requête suivante renverra toutes les lignes des tables des clients et des commandes. Si un client n'a aucune commande, le jeu de résultats inclura toujours les informations de ce client, avec des valeurs NULL pour les colonnes order\$1id et order\$1date. Si aucun client n'est associé à une commande, le jeu de résultats inclura cette commande, avec des valeurs NULL pour les colonnes customer\$1id et name. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers FULL OUTER JOIN orders ON customers.customer_id = orders.customer_id; ``` La requête suivante est une jointure complète. Les jointures complètes conservent les valeurs des tables jointes lorsqu’aucune correspondance n’est trouvée dans l’autre table. Les tables gauche et droite sont la première et la deuxième répertoriées dans la syntaxe. Les valeurs NULL sont utilisées pour combler les « écarts » du jeu de résultats. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Les résultats montrent que LISTIDs 2 et 3 n'ont donné lieu à aucune vente. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing full join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 2 | NULL | NULL 3 | NULL | NULL 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` La requête suivante est une jointure complète. Cette requête fait correspondre les valeurs de la colonne LISTID dans la table LISTING (la table de gauche) et la table SALES (la table de droite). Seules les lignes qui ne génèrent aucune vente (LISTIDs 2 et 3) apparaissent dans les résultats. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing full join sales on sales.listid = listing.listid where listing.listid between 1 and 5 and (listing.listid IS NULL or sales.listid IS NULL) group by 1 order by 1; listid | price | comm -------+--------+-------- 2 | NULL | NULL 3 | NULL | NULL ``` ## [GAUCHE] SEMI Renvoie les valeurs du côté gauche de la référence de table qui correspondent au côté droit. Elle est également appelée *demi-jointure gauche*. Elle renvoie uniquement les lignes de la table de gauche (première) qui ont une ligne correspondante dans la table de droite (deuxième). Il ne renvoie aucune colonne du tableau de droite, uniquement les colonnes du tableau de gauche. Le LEFT SEMI JOIN est utile lorsque vous souhaitez rechercher les lignes d'une table qui correspondent dans une autre table, sans avoir à renvoyer les données de la seconde table. Le LEFT SEMI JOIN est une alternative plus efficace à l'utilisation d'une sous-requête avec une clause IN ou EXISTS. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT SEMI JOIN table2 ON table1.column = table2.column; ``` La requête suivante renverra uniquement les colonnes customer\$1id et name de la table des clients, pour les clients qui ont au moins une commande dans la table des commandes. Le jeu de résultats n'inclura aucune colonne du tableau des commandes. ``` SELECT customers.customer_id, customers.name FROM customers LEFT SEMI JOIN orders ON customers.customer_id = orders.customer_id; ``` ## CROSS JOIN Renvoie le produit cartésien de deux relations. Cela signifie que le jeu de résultats contiendra toutes les combinaisons possibles de lignes des deux tableaux, sans qu'aucune condition ni aucun filtre ne soient appliqués. Le CROSS JOIN est utile lorsque vous devez générer toutes les combinaisons possibles de données à partir de deux tables, par exemple dans le cas de la création d'un rapport qui affiche toutes les combinaisons possibles d'informations sur les clients et les produits. Le CROSS JOIN est différent des autres types de jointure (INNER JOIN, LEFT JOIN, etc.) car il ne comporte aucune condition de jointure dans la clause ON. La condition de jointure n'est pas obligatoire pour une jointure croisée. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 CROSS JOIN table2; ``` La requête suivante renverra un jeu de résultats contenant toutes les combinaisons possibles de customer\$1id, customer\$1name, product\$1id et product\$1name à partir des tables clients et produits. Si le tableau des clients comporte 10 lignes et le tableau des produits 20 lignes, le jeu de résultats du CROSS JOIN contiendra 10 x 20 = 200 lignes. ``` SELECT customers.customer_id, customers.name, products.product_id, products.product_name FROM customers CROSS JOIN products; ``` La requête suivante est une jointure croisée ou cartésienne de la table LISTING et de la table SALES avec un prédicat pour limiter les résultats. Cette requête correspond aux valeurs des colonnes LISTID de la table SALES et de la table LISTING pour LISTIDs 1, 2, 3, 4 et 5 dans les deux tables. Les résultats montrent que 20 lignes correspondent aux critères. ``` select sales.listid as sales_listid, listing.listid as listing_listid from sales cross join listing where sales.listid between 1 and 5 and listing.listid between 1 and 5 order by 1,2; sales_listid | listing_listid -------------+--------------- 1 | 1 1 | 2 1 | 3 1 | 4 1 | 5 4 | 1 4 | 2 4 | 3 4 | 4 4 | 5 5 | 1 5 | 1 5 | 2 5 | 2 5 | 3 5 | 3 5 | 4 5 | 4 5 | 5 5 | 5 ``` ## ANTI-JOINTURE Renvoie les valeurs de la référence de table de gauche qui ne correspondent pas à la référence de table de droite. On l'appelle aussi « *anti-jointure gauche* ». L'opération ANTI JOIN est une opération utile lorsque vous souhaitez rechercher les lignes d'une table qui ne correspondent pas dans une autre table. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT ANTI JOIN table2 ON table1.column = table2.column; ``` La requête suivante renverra tous les clients qui n'ont pas passé de commande. ``` SELECT customers.customer_id, customers.name FROM customers LEFT ANTI JOIN orders ON customers.customer_id = orders.customer_id WHERE orders.order_id IS NULL; ``` ## NATURAL Spécifie que les lignes issues des deux relations seront implicitement mises en correspondance sur un pied d'égalité pour toutes les colonnes dont les noms sont identiques. Il fait automatiquement correspondre les colonnes portant le même nom et le même type de données entre les deux tables. Il n'est pas nécessaire de spécifier explicitement la condition de jointure dans la clause ON. Il combine toutes les colonnes correspondantes entre les deux tables dans le jeu de résultats. Le NATURAL JOIN est un raccourci pratique lorsque les tables que vous joignez comportent des colonnes portant le même nom et le même type de données. Cependant, il est généralement recommandé d'utiliser le plus explicite INNER JOIN... Syntaxe ON pour rendre les conditions de jointure plus explicites et plus faciles à comprendre. **Syntaxe :** ``` SELECT column1, column2, ..., columnn FROM table1 NATURAL JOIN table2; ``` L'exemple suivant est une jointure naturelle entre deux tables`departments`, `employees` avec les colonnes suivantes : + `employees`tableau : `employee_id``first_name`,`last_name`, `department_id ` + `departments`tableau :`department_id`, `department_name ` La requête suivante renverra un jeu de résultats qui inclut le prénom, le nom de famille et le nom du département pour toutes les lignes correspondantes entre les deux tables, en fonction de la `department_id` colonne. ``` SELECT e.first_name, e.last_name, d.department_name FROM employees e NATURAL JOIN departments d; ``` L’exemple suivant est une jointure naturelle entre deux tables. Dans ce cas, les colonnes listid, sellerid, eventid et dateid présentent des noms et des types de données identiques dans les deux tables et sont donc utilisées comme colonnes de jointure. Les résultats sont limités à seulement cinq lignes. ``` select listid, sellerid, eventid, dateid, numtickets from listing natural join sales order by 1 limit 5; listid | sellerid | eventid | dateid | numtickets -------+-----------+---------+--------+----------- 113 | 29704 | 4699 | 2075 | 22 115 | 39115 | 3513 | 2062 | 14 116 | 43314 | 8675 | 1910 | 28 118 | 6079 | 1611 | 1862 | 9 163 | 24880 | 8253 | 1888 | 14 ```