Comment utiliser les alias avec les JOINs en SQL

Les alias SQL sont des noms personnalisés que vous pouvez donner aux colonnes et aux tables que vous incluez dans vos requêtes. Les alias sont très utiles, car ils peuvent améliorer considérablement la lisibilité et la facilité de maintenance de votre requête. Nous allons examiner de plus près l'utilisation des alias SQL avec JOIN et les raisons pour lesquelles vous pourriez avoir besoin de le faire.

Il existe plusieurs types d'alias que vous pouvez utiliser en SQL :

1. Les alias pour les tables.
2. Alias pour les colonnes de la table.
3. Alias pour les sous-requêtes.

Bien qu'il existe plusieurs façons différentes d'utiliser les alias dans vos requêtes, la syntaxe est similaire pour toutes ces méthodes. Examinons la syntaxe des alias.

Syntaxe des alias SQL

La syntaxe présentée ci-dessous couvre les alias de colonnes et de tables :

SELECT
  t1.column_name (AS) new_column_name,
  t2.column_name (AS) other_new_column_name,
  ...
FROM table1 (AS) t1
JOIN table2 (AS) t2
  ON t1.column_name = t2.column_name
…

Si vous vous sentez dépassé par cette syntaxe, pensez à vous familiariser avec les bases des requêtes SQL en vous inscrivant à ce coursSQL pour les débutants . Il vous fournira une base solide et vous permettra de lire, écrire et comprendre les requêtes SQL avec facilité.

Alias de colonnes SQL

Tout d'abord, examinons les alias de colonne :

 t1.column_name (AS) new_column_name,
 t2.column_name (AS) other_new_column_name

Le mot-clé AS est ici facultatif. Vous pouvez l'inclure si vous le souhaitez, mais la requête se comportera exactement de la même manière.

L'alias est défini directement après le nom de la colonne (ou le mot-clé AS ). Dans ce cas, nos alias sont new_column_name et other_new_column_name.

Si vous souhaitez inclure des espaces dans le nom de votre nouvelle colonne, mettez-le entre guillemets. Nous pourrions mettre à jour cet exemple en :

SELECT t1.column_name (AS) 'new column name'

L'exclusion des guillemets simples ici provoquerait une erreur.

Voilà pour les alias SQL pour les noms de colonnes. Voyons maintenant les alias de table.

Alias de table SQL

Nous définissons les alias de table comme suit :

FROM table1 (AS) t1
JOIN table2 (AS) t2

Comme précédemment, l'inclusion du mot-clé AS est totalement facultative. Nous déclarons que l'alias de table1 est t1. De même, l'alias pour table2 est t2.

Lorsque vous renommez des tables de bases de données, vous devez utiliser les alias de table dans lacondition ON, dans la liste SELECT lors de la sélection des colonnes (s'il est nécessaire de spécifier la table pour la colonne), et dans d'autres parties de la requête.

Vous pouvez voir que nous suivons cette règle en incluant t1 et t2 dans notre clause SELECT:

SELECT
  t1.column_name (AS) new_column_name,
  t2.column_name (AS) other_new_column_name,
  ... 

Alias SQL pour les sous-requêtes

Une sous-requête SQL est une requête à l'intérieur d'une autre requête. Examinons la syntaxe de l'utilisation des alias dans une sous-requête.

SELECT column_1, 
       column_2 = (SELECT COUNT(t2.id)
                         FROM table_2 t2
                        WHERE t2.id = t1.id)
  FROM table_1 t1

La sous-requête est la partie de la requête en caractères gras. Vous pouvez voir comment les alias nous aident à accéder à la bonne table à chaque partie de la requête.

Ceci conclut notre étude de la syntaxe des alias SQL. Voyons quelques exemples pratiques d'utilisation des alias avec JOIN !

Exemples d'utilisation d'alias SQL avec JOIN

Dans cette section, nous allons examiner certains cas d'utilisation d'alias courants et expliquer comment mettre en œuvre chacun d'entre eux. Les jointures en SQL est un sujet délicat - il est inclus dans cet article sur les sujets SQL qui nécessitent de la pratique. Plus vous serez exposé à des exemples pratiques, mieux vous vous porterez.

Utilisation d'un alias avec des noms de colonne non uniques

Lorsque vous avez affaire à plusieurs tables, il est courant d'avoir le même nom de colonne dans les deux tables. Cela se produit fréquemment avec la colonne id. Voici un exemple qui le démontre :

SELECT employee.id, customer.id, employee_name, employee_department 
FROM employees 
INNER JOIN customer 
ON employee.id = customer.employee_id 

Les données résultantes s'affichent comme :

Ce résultat va dérouter les parties prenantes, car elles n'ont aucun moyen de savoir quel identifiant appartient à quelle table. L'introduction d'un alias de colonne pour chaque colonne id peut aider :

SELECT employee.id employee_id, customer.id customer_id, employee_name, employee_department 
FROM employees 
INNER JOIN customer 
ON employee.id = customer.employee_id 

Nous obtenons maintenant un résultat beaucoup plus compréhensible :

Améliorer la lisibilité des requêtes

Un alias peut simplifier et améliorer la lisibilité de votre requête. Par exemple, imaginons qu'il existe une colonne appelée cn_index qui stocke les noms des clients. Ce que cette colonne représente n'est pas immédiatement évident ; il vous faudrait la documentation du modèle de données ou quelqu'un qui vous l'explique pour en déchiffrer la signification. Ce problème peut être réduit en utilisant un alias dans toute requête incluant cette colonne. Cela pourrait ressembler à ceci :

SELECT cn_index AS customer_id 
FROM customers

Il en va de même pour toutes les tables mal nommées que vous rencontrez dans votre base de données.

Améliorer la maintenabilité des requêtes

Un alias contribue également à la facilité de maintenance. Imaginez que vous ayez une requête comme celle qui suit :

SELECT customer.id, customer.name, customer.age, client.id 
FROM customer 
JOIN client 
ON customer.id = client.id

Imaginons maintenant qu'une modification soit apportée à notre table customer par exemple, qu'elle soit renommée en customers_europe. Vous devriez effectuer ce changement partout où cette table est référencée :

SELECT customers_europe.id, customers_europe.name, customers_europe.age, client.id
FROM customers_europe
JOIN client 
ON customers_europe.id = client.id

Cela peut ne pas sembler être une étape importante, mais il s'agit d'une requête courte et simple. Imaginez que vous deviez mettre à jour plusieurs procédures et fonctions stockées à cause de ce changement.

Voyons comment les alias peuvent aider à résoudre ce problème. Notre première requête, une fois mise à jour pour utiliser un alias, pourrait ressembler à ceci :

SELECT c.id, c.name, c.age, client.id
FROM customer c
JOIN client
ON c.id = client.id

Maintenant, lorsque nous voulons mettre à jour notre table, nous ne devons effectuer la modification qu'à un seul endroit :

SELECT c.id, c.name, c.age, client.id
FROM customers_europe c
JOIN client
ON c.id = client.id

Il en résulte un gain de temps considérable si vous devez mettre à jour un grand nombre de requêtes, fonctions et procédures stockées existantes.

Auto-joints

Une auto-jonction vous permet de joindre une table à elle-même. Elle est utile pour interroger des données hiérarchiques ou comparer des lignes au sein d'une même table. Lors de l'auto-jonction d'une table, vous pouvez utiliser un LEFT JOIN ou un INNER JOIN. Lorsque vous effectuez une auto-jonction, il est important d'utiliser un alias SQL logique pour chaque instance de la table.

Voyons comment nous pouvons écrire une requête qui joint une table à elle-même. Pour notre exemple, nous allons utiliser la table suivante, tbl_employee. Elle contient tous les employés de l'entreprise, l'ID de leur département et l'ID de leur responsable :

Supposons que nous voulions un ensemble de résultats qui ne montre qu'un employé et son responsable. Comment pouvons-nous y parvenir ? En utilisant des alias en combinaison avec une jointure automatique. Regardez l'extrait de code ci-dessous :

SELECT e.employee_name AS 'Employee',
m.employee_name AS 'Manager'
FROM tbl_employee e
LEFT JOIN tbl_employee m
ON m.id = e.manager_id

Notez que nous avons utilisé LEFT JOIN comme jointure automatique. Lorsque vous joignez des tables, faites attention à l'erreur de colonne ambiguë, qui peut facilement se produire si vous ne faites pas attention. Pour éviter cette erreur, vous devez spécifier explicitement l'alias de la table dans le nom de la colonne (e.employee_name et m.employee_name).

L'exécution de la requête ci-dessus donne le jeu de résultats suivant :

Voilà le résultat souhaité ! Vous pouvez clairement voir chaque employé et son responsable. La plupart des employés dépendent de M. Burns. Cependant, vous pouvez voir que le responsable de Frank Grimes est Homer Simpson. Remarquez la valeur NULL dans la colonne Manager pour Montgomery Burns. Cela s'explique par le fait que Montgomery Burns n'a pas de responsable ; c'est lui le patron.

Modifions légèrement la requête et utilisons cette fois un INNER JOIN pour notre auto-jonction :

SELECT e.employee_name AS 'Employee',
m.employee_name AS 'Manager'
FROM tbl_employee e
INNER JOIN tbl_employee m
ON m.id = e.manager_id

La seule différence majeure est l'absence de Montgomery Burns dans la colonne Employee. En effet, la valeur manager_id pour lui était NULL et INNER JOIN ne renvoie que les colonnes correspondantes ; les valeurs NULL ne sont pas incluses.

Vous pouvez maintenant effectuer des auto-joints, qui sont applicables à de nombreux cas d'utilisation différents. Si vous voulez voir d'autres exemples, consultez cet excellent guide illustré sur les auto-joints. L'auto-jonction est également présentée dans ce guide pratique des jointures SQL. Mettez la page en signet ou téléchargez-la et vous aurez toujours un guide rapide des différents types de jointures.

Créer des résultats significatifs

Lorsque vous utilisez des fonctions d'agrégation, le résultat s'affiche par défaut dans une colonne sans nom. Un alias est un moyen idéal d'ajouter du sens aux résultats de vos fonctions d'agrégation.

Prenons un bref exemple pour voir comment cela fonctionne. Imaginons que nous ayons une table appelée payments qui contient des données de paiement :

Voici une requête :

SELECT SUM(payment_amount)
FROM payments

L'exécution de cette requête donne le résultat suivant :

Nous n'avons aucune idée de ce que ce résultat représente car il n'a pas de nom de colonne. Mettons à jour notre requête avec un alias pour rendre les résultats plus significatifs.

SELECT SUM(payment_amount) AS 'Sum of payments'
FROM payments

Exécutez la requête pour voir les résultats de notre nouvelle requête améliorée :

Ce ne sont là que quelques utilisations de l'alias SQL. Pour plus d'exemples, consultez cet article de blog sur l'utilisation des alias en SQL.

L'alias SQL JOIN expliqué

Nous avons vu comment un alias peut faciliter la lecture et la maintenance de votre requête SQL, sans oublier le rôle essentiel qu'il joue dans les auto-joints. Nous avons examiné de nombreux cas d'utilisation et exemples différents. Pour obtenir une formation plus complète sur le sujet, consultez le cours LearnSQL.fr Les jointures en SQL .

Si vous souhaitez en savoir plus que sur les JOIN, ou si vous recherchez une formation SQL complète, le parcours d'apprentissageLe SQL de A à Z est la meilleure option pour vous. À l'issue du parcours d'apprentissage, vous disposerez des outils nécessaires (y compris les JOIN et les alias) pour travailler librement et efficacement avec tout type de données.