5 meilleures pratiques pour la rédaction de JOINs SQL

Ces meilleures pratiques pour Les jointures en SQL vous aideront à réaliser des requêtes SQL lisibles qui produisent des résultats précis, clairs et compréhensibles.

Étant donné que les bases de données relationnelles sont construites autour de tables liées, il n'est pas étonnant que Les jointures en SQL - qui vous permet de combiner les informations de plusieurs tables - soit l'une des principales compétences acquises par les débutants en SQL. Les jointures en SQL Le cours de LearnSQL.fr est l'endroit idéal pour rafraîchir vos connaissances sur les JOINs. Si vous voulez que vos requêtes SQL fonctionnent et aient une apparence professionnelle, vous devez suivre les meilleures pratiques de Les jointures en SQL. J'ai résumé certaines d'entre elles dans cet article.

Les jointures en SQL Vue d'ensemble

Disons que vous voulez voir toutes les commandes d'un ensemble de clients avec leur nom complet. Cela semble assez simple, non ? Cependant, dans la pratique, il est peu probable que vous trouviez des informations sur les clients et les commandes dans la même table. La table des commandes peut contenir un identifiant de client pour chaque commande, mais généralement rien de plus sur les clients.

Pour combiner les informations provenant des customers et orders vous devez joindre ces tables sur la base d'une valeur de colonne commune (par exemple, le numéro d'identification du client). Voici à quoi peut ressembler votre requête SQL si vous voulez voir toutes les colonnes des deux tables :

SELECT *
FROM customers
JOIN orders
ON customers.id = orders.customer_id;

Dans la clause SELECT, vous indiquez les colonnes que vous souhaitez voir apparaître dans le résultat. Ensuite, vous indiquez le nom d'une table dans la clause FROM et le nom d'une autre table dans la clause JOIN. Enfin, dans la clause ON, vous indiquez quelles colonnes de chaque table doivent être utilisées pour la jointure.

Vous pouvez vous entraîner à la syntaxe SQL JOIN avec notre Les jointures en SQL cours interactif, qui comprend 93 défis de codage. Si vous ne connaissez pas le site Les jointures en SQL, consultez mon guide pas à pas de la jonction de tables en SQL.

Avant de passer en revue les meilleures pratiques de SQL JOIN, je voudrais vous rappeler brièvement les différents types de Les jointures en SQL:

• INNER JOIN (ou simple JOIN) est le type de jointure de base. Il est utilisé pour afficher les enregistrements correspondants des deux tables.
• LEFT JOIN (ou LEFT OUTER JOIN) est utilisé pour conserver tous les enregistrements de la table de gauche et seulement les enregistrements correspondants de la table de droite.
• RIGHT JOIN (ou RIGHT OUTER JOIN) est utilisé pour conserver tous les enregistrements de la table de droite et uniquement les enregistrements correspondants de la table de gauche.
• FULL JOIN (ou FULL OUTER JOIN) est utilisé pour conserver tous les enregistrements de toutes les tables, même ceux qui ne correspondent pas.
• CROSS JOIN renvoie un ensemble de résultats contenant toutes les combinaisons possibles des lignes de deux tables.

Voici mon article avec des exemples de différents types de SQL JOIN.

SQL JOIN est un outil puissant qui va bien au-delà de la simple jonction de deux tables à l'aide d'une colonne commune. Vous pouvez utiliser différents types de Les jointures en SQL pour joindre une table avec elle-même (auto-jointure) ; joindre des tables sans colonne commune; joindre des tables en utilisant des opérateurs conditionnels autres que des égaux (jointures non égales) ; joindre plusieurs tables (plus de deux) dans une requête, ou joindre des tables sur la base de plusieurs colonnes.

Voyons maintenant quelles sont les meilleures pratiques SQL pour joindre deux tables ou plus.

5 Meilleures pratiques de Les jointures en SQL

Si vous voulez que vos requêtes SQL soient claires et lisibles - et, surtout, qu'elles renvoient le résultat attendu - vous devez suivre certaines pratiques pour écrire Les jointures en SQL.

1. Utilisez les mots-clés JOIN et ON

Tout d'abord, il est fortement recommandé d'utiliser des jointures explicites, c'est-à-dire en utilisant les mots-clés JOIN et ON. Vous pouvez parfois rencontrer des requêtes SQL où les tables sont jointes implicitement en listant simplement les noms des tables dans la clause FROM et en utilisant la clause WHERE pour spécifier la condition de jointure.

Par exemple, les deux requêtes suivantes donnent le même résultat :

SELECT *
FROM customers
JOIN orders
ON customers.id = orders.customer_id;
SELECT *
FROM customers, orders
WHERE customers.id = orders.customer_id;

Cependant, seule la première de ces requêtes respecte les bonnes pratiques JOIN. La deuxième requête, qui comporte une jointure implicite, présente plusieurs problèmes :

• Elle est moins lisible; cela s'aggrave avec les requêtes SQL complexes. Vous devez regarder attentivement pour établir les tables qui sont jointes. Vous devez également trouver la condition de jointure, qui n'est pas précédée d'un mot-clé standard ON.
• Vous ne pouvez pas spécifier le type de jointure lorsque vous utilisez une jointure implicite (par exemple, FROM customers, orders). Cela peut poser un problème si vous avez besoin d'utiliser quelque chose de plus que le standard INNER JOIN.
• Définir une condition de jointure dans laclause WHERE peut être très déroutant, car ce n'est pas l'utilisation typique de cette clause. WHERE est utilisée pour filtrer les données ; une requête est difficile à comprendre lorsque des conditions de jointure sont mélangées à des conditions de filtrage dans une clause.

Utilisez donc JOIN pour spécifier les tables à joindre et ON pour spécifier la condition de jointure.

2. Choisissez le type de jointure SQL approprié

Avant d'écrire une requête SQL, réfléchissez bien au type de jointure SQL le plus approprié dans ce cas particulier.

Si vous joignez des clients à une liste de commandes terminées, voulez-vous inclure les clients qui n'ont pas encore de commandes terminées ? Voulez-vous inclure les commandes qui, pour une raison quelconque, n'ont pas l'ID du client correspondant ? En fonction de vos réponses, vous devrez peut-être utiliser LEFT JOIN, RIGHT JOIN, ou même FULL JOIN.

Veillez à choisir le type de jointure SQL approprié et à placer les noms de table dans le bon ordre lorsque vous utilisez LEFT JOIN ou RIGHT JOIN.

3. Concevez soigneusement la condition JOIN

Si vous joignez deux tables en utilisant leur clé primaire et leur clé étrangère respectives, la condition de jonction est généralement assez simple. Toutefois, ce n'est pas toujours le cas :

• Il se peut qu'une colonne commune ne permette pas d'identifier les enregistrements de manière unique, auquel cas vous devrez utiliser deux conditions de jointure ou plus. Par exemple, si votre base de données contient plusieurs personnes ayant le même nom de famille, vous ne pouvez pas utiliser uniquement le nom de famille pour joindre des tables. Vous devez rechercher une autre colonne (par exemple, l'ID) ou une combinaison de colonnes. Voici comment joindre deux tables en utilisant une combinaison de deux colonnes (first_name et last_name) dans les deux tables :

  SELECT 
  s.first_name, 
  s.last_name, 
  u.id
  FROM students s
  JOIN users u
  ON s.first_name = u.first_name 
  AND s.last_name = u.last_name;
  

• Vous devrez peut-être appliquer des jointures non égales avec des opérateurs conditionnels au-delà des égaux. Si vous vérifiez que le prix d'une maison est conforme aux attentes des acheteurs lorsqu'il s'agit de joindre des acheteurs potentiels à des maisons à vendre, votre requête ressemblera à ceci :

  SELECT 
  	b.id, 
  	b.name, 
  	h.id, 
  	h.address, 
  	h.price
  FROM buyers b
  JOIN houses h
  	ON h.price BETWEEN b.min_price AND b.max_price;
  

• Il peut y avoir plusieurs enregistrements correspondants dans une autre table (par exemple, un client peut avoir plusieurs commandes). Voulez-vous obtenir toutes ces commandes ou seulement les plus récentes ? Si vous voulez joindre uniquement la commande la plus récente, votre requête sera légèrement plus complexe :

  SELECT 
  	customers.id, 
  	customers.first_name, 
  	customers.last_name,
  	orders.order_date, 
  	orders.order_status
  FROM customers
  JOIN orders
      ON orders.id = (
          SELECT TOP 1 id
          FROM orders
          WHERE customer_id = customers.id
          ORDER BY order_date DESC
      )
  ORDER BY customer_id;
  

La définition d'une condition de jointure correcte est cruciale pour obtenir le résultat correct après avoir joint des tables en SQL.

4. Utiliser des alias de table

L'utilisation d'alias de table est une bonne pratique lorsque vous joignez plusieurs tables ou lorsque vous joignez des tables dont le nom est long. En général, l'alias comprend simplement la première lettre du nom complet de la table ou deux lettres et plus si le nom de la table est composé de plusieurs mots (par exemple, c pour customers, ds pour daily_salesetc.).

Pour revenir à notre exemple, nous pouvons utiliser la requête suivante pour obtenir des informations sur l'ID, le prénom, le nom, l'ID de commande, la date de commande et le statut de la commande du client :

SELECT
	c.id,
	c.first_name,
	c.last_name,
	o.id,
	o.date,
	o.status
FROM customers c
JOIN orders o
	ON c.id = o.customer_id;

Notez que nous définissons les alias de table dans les clauses FROM et JOIN juste après le nom complet de la table. Ensuite, nous utilisons ces alias pour faire référence à des colonnes spécifiques de ces tables dans les instructions SELECT et ON. Cela peut nous permettre d'économiser beaucoup d'écriture, surtout si les noms de tables sont longs.

5. Utiliser des alias de colonne

Les alias de colonne sont les noms que nous attribuons aux colonnes dans le jeu de résultats. Par défaut, les colonnes de sortie auront les mêmes noms que les colonnes correspondantes dans les tables d'origine. Cependant, cela donne souvent lieu à des résultats confus.

Par exemple, le résultat de la requête de notre exemple ci-dessus comprendra deux colonnes portant le nom id qui correspondent aux colonnes ID du client et ID de la commande.

Vous pouvez suivre l'ordre des colonnes pour comprendre laquelle est laquelle, mais la meilleure approche est d'utiliser des alias de colonnes :

SELECT
	c.id AS customer_id, 
	c.first_name, 
	c.last_name, 
	o.id AS order_id, 
	o.date AS order_date, 
	o.status AS order_status.
FROM customers c
JOIN orders o
	ON c.id = o.customer_id;

Notez que j'utilise également des alias de colonne pour les colonnes avec la date de commande et le statut de la commande. Dans le tableau résultant, il n'est pas clair à quoi correspondent ces dates et statuts. Pour éviter toute confusion, il est préférable de spécifier explicitement les noms de colonnes en utilisant les alias de colonnes. Consultez cet article pour plus de conseils sur les JOIN SQL.

Il est temps de pratiquer Les jointures en SQL!

SQL JOIN est l'une des principales compétences acquises par ceux qui commencent à travailler avec des bases de données relationnelles. Cependant, il y a beaucoup plus que de simples jointures. Il existe de nombreux outils et concepts avancés sous l'égide de Les jointures en SQL , notamment différents types de jointures externes, d'auto-jointures, de jointures non égales, etc.

Il est important de connaître et d'utiliser les meilleures pratiques de Les jointures en SQL dès le début :

• Définissez explicitement votre Les jointures en SQL avec les mots-clés JOIN et ON.
• Veillez à sélectionner le bon type de jointure SQL.
• Concevez avec soin la condition de jointure.
• Utilisez des alias de table, en particulier pour les noms de table longs.
• Utilisez des alias de colonne pour rendre la sortie de la requête plus compréhensible.

Les cours interactifs sont généralement la meilleure approche pour mettre en pratique les compétences nouvellement acquises. Si vous êtes très novice en SQL, je vous recommande de commencer par le cours SQL pour les débutants cours. Il vous permettra de vous familiariser avec les principaux sujets SQL, notamment Les jointures en SQL.

Pour mieux comprendre les différents types de JOIN, consultez le cours Les jointures en SQL cours. Il couvre INNER JOIN, LEFT JOIN, RIGHT JOIN, et FULL JOIN; le filtrage des données avec différents types de JOIN ; la jonction d'une table avec elle-même ; la jonction de tables sur des colonnes non clés, etc.

Merci de votre lecture et bon apprentissage !