L'alias SQL est une petite fonctionnalité intéressante de SQL qui vous permet d'écrire un code plus concis et de créer des noms de colonne lorsqu'aucun nom de colonne n'existe.
Il existe deux types d'alias SQL ; alias de colonne et alias de table. Dans cet article, je donne un aperçu des deux.
Qu'est-ce qu'un alias en SQL ?
En SQL, un alias est une fonctionnalité qui nous permet d'attribuer temporairement un nom différent à une colonne ou à une table dans nos requêtes SQL. Cela nous permet de réduire la quantité de code dans nos requêtes, ce qui peut être particulièrement bénéfique dans les requêtes complexes.
Cela nous permet également de fournir des noms de colonne aux applications clientes où aucun nom de colonne n'existe (par exemple, lors de l'utilisation d'un champ calculé).
Avantages des alias SQL
Certains des principaux avantages des alias SQL incluent :
- Vous permet de fournir des noms plus lisibles aux en-têtes de colonne lorsqu'ils sont présentés dans les résultats
- Permet aux applications clientes de faire référence à un champ calculé par son nom lorsqu'aucun nom de colonne n'existe
- Vous permet de réduire le code et de rendre vos requêtes plus concises
- Peut être utilisé comme technique d'obscurcissement pour protéger les noms des colonnes sous-jacentes d'une requête
Je dois souligner que l'attribution d'un alias ne renomme pas réellement la colonne ou la table. Il fournit simplement un nom alternatif qui peut être utilisé pour s'y référer.
Syntaxe d'alias
Pour créer un alias dans SQL, faites simplement suivre le nom de la colonne ou de la table par l'alias que vous avez choisi. Vous pouvez éventuellement utiliser le AS mot-clé entre le nom de la colonne/table et votre alias.
Comme ceci pour les colonnes :
SELECT Column1 AS Alias1
...
or
SELECT Column1 Alias1
...Ou comme ceci pour les tableaux :
...
FROM Table1 AS Alias1
...
or
...
FROM Table1 Alias1
...Les exemples suivants illustreront mieux cela.
L'alias de la colonne
L'alias le plus couramment utilisé est probablement l'alias de colonne. L'alias de colonne vous permet de donner un nom temporaire à vos colonnes.
Il vous permet également de fournir un nom de colonne aux endroits où aucun nom de colonne n'existe.
Les deux exemples suivants montrent la même requête écrite avec et sans alias de colonne.
Sans alias de colonne
Voici une requête SQL simple qui ne fonctionne pas utiliser des alias de colonne.
SELECT
f_name,
l_name
FROM customers;Résultat :
+----------+----------+ | f_name | l_name | |----------+----------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +----------+----------+
Dans ce cas, je n'ai fourni aucun alias de colonne, et donc les noms de colonne sous-jacents réels ont été présentés comme en-têtes de colonne dans les résultats.
Avec alias de colonne
Voici la même requête, sauf que cette fois j'utilise des alias de colonne.
SELECT
f_name AS FirstName,
l_name AS LastName
FROM customers;Résultat :
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Notez que les alias de colonne ont été utilisés comme en-têtes de colonne dans les résultats.
Alias de colonne sur les champs calculés
Les alias de colonne peuvent également être utilisés sur des champs calculés où aucun nom de colonne n'existe. Je ne parle pas des colonnes calculées, où il y a un nom de colonne, mais des champs où la valeur est dérivée d'une expression autre qu'une simple valeur de colonne.
« Comment pourrait-il n'y avoir aucun nom de colonne ? » vous pouvez demander.
Eh bien, il existe de nombreuses occasions où vous pouvez constater qu'aucun nom de colonne n'est renvoyé dans une requête. Avez-vous déjà vu (No column name) comme en-tête de colonne des résultats de votre requête ?
Il existe de nombreuses situations où cela peut se produire.
Sans alias de colonne
Voici un exemple de requête qui ne renvoie pas d'en-tête de colonne.
SELECT
f_name + ' ' + l_name
FROM customers;Résultat :
+--------------------+ | (No column name) | |--------------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +--------------------+
Cet exemple concatène le prénom et le nom de chaque client et présente le résultat dans une colonne. Le seul problème est que le SGBD ne sait pas comment appeler la colonne.
C'est une opportunité parfaite pour un alias !
Avec un alias de colonne
Voici le même exemple, sauf que j'attribue maintenant un alias de colonne au résultat.
SELECT
f_name + ' ' + l_name AS FullName
FROM customers;Résultat :
+---------------+ | FullName | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
La bonne chose à ce sujet est que n'importe quelle application cliente peut désormais prendre ces résultats et se référer au champ calculé par son alias.
Notez que l'exemple ci-dessus utilise l'opérateur de concaténation de chaînes SQL Server (+ ). Dans DB2, Oracle, PostgreSQL et SQLite, vous devrez utiliser || . Et dans MySQL et MariaDB, utilisez le CONCAT() une fonction. Bien que cela n'ait rien à voir avec les alias SQL, je pensais juste le mentionner 🙂
Alias avec espaces
Il est également possible de créer des alias avec des espaces.
Lorsque vous faites cela, entourez l'alias de guillemets doubles. Dans certains SGBD, vous pouvez éventuellement utiliser d'autres caractères (tels que des crochets [] dans SQL Server).
SELECT
f_name + ' ' + l_name AS "Full Name"
FROM customers;Résultat :
+---------------+ | Full Name | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Gardez à l'esprit qu'il n'est généralement pas considéré comme une bonne pratique d'avoir des espaces dans les alias. Les espaces peuvent causer toutes sortes de problèmes aux applications clientes, et pour cette raison, vous devriez généralement éviter d'inclure des espaces dans vos alias de colonne.
Omettre le AS Mot clé
Comme mentionné, le AS le mot-clé est facultatif. Par conséquent, nous pourrions réécrire n'importe lequel des exemples précédents sans le AS mot-clé.
Voici un exemple.
SELECT
f_name FirstName,
l_name LastName
FROM customers;Résultat :
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Bien que vous puissiez omettre le AS mot-clé, certains professionnels de SQL préfèrent toujours l'inclure, pour des raisons de lisibilité.
Quelle que soit la syntaxe que vous préférez utiliser, je vous recommande de la garder cohérente. Si vous choisissez d'omettre le AS mot-clé, puis omettez-le partout. Si vous choisissez de l'inclure, alors incluez-le partout.
L'alias de la table
L'alias de table est similaire à l'alias de colonne, mais comme son nom l'indique, l'alias de table est pour les tables.
L'alias de table est également appelé nom de corrélation .
L'alias de table est souvent utilisé lors de l'exécution de jointures. Cela peut être particulièrement utile dans les requêtes complexes, car cela peut aider à garder le code plus concis et plus lisible.
Voici deux exemples ; une sans alias de table et une avec un alias de table.
Exemple sans alias de table
Voici un exemple de base d'une requête qui effectue une jointure gauche entre deux tables.
SELECT
PetTypes.PetType,
COUNT(Pets.PetTypeId) AS Count
FROM Pets
LEFT JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC, PetTypes.PetType;Résultat :
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Notez que nous épelons le nom de chaque table partout où nous avons besoin de la référencer.
Exemple avec un alias de table
Voici le même exemple, sauf avec des alias de table.
SELECT
pt.PetType,
COUNT(p.PetTypeId) AS Count
FROM Pets AS p
LEFT JOIN PetTypes AS pt
ON p.PetTypeId = pt.PetTypeId
GROUP BY pt.PetType
ORDER BY Count DESC, pt.PetType;Résultat :
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Comme pour les alias de colonne, le AS Le mot-clé est facultatif avec les alias de table. Dans Oracle, le AS Le mot-clé n'est même pas pris en charge avec les alias de table (bien qu'il soit pris en charge avec les alias de colonne).
Par conséquent, nous pourrions réécrire notre exemple comme suit.
SELECT
pt.PetType,
COUNT(p.PetTypeId) AS Count
FROM Pets p
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId
GROUP BY pt.PetType
ORDER BY Count DESC, pt.PetType;Résultat :
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Quoi qu'il en soit, même résultat.
