De SQL-alias is een leuke kleine functie van SQL waarmee je beknoptere code kunt schrijven en kolomnamen kunt maken als er geen kolomnaam bestaat.
Er zijn twee typen SQL-alias; kolomaliassen en tabelaliassen. In dit artikel geef ik een overzicht van beide.
Wat is een alias in SQL?
In SQL is een alias een functie waarmee we tijdelijk een andere naam kunnen toewijzen aan een kolom of tabel in onze SQL-query's. Hierdoor kunnen we de hoeveelheid code in onze zoekopdrachten verminderen, wat vooral nuttig kan zijn bij complexe zoekopdrachten.
Het stelt ons ook in staat om kolomnamen te geven aan clienttoepassingen waar geen kolomnaam bestaat (bijvoorbeeld bij gebruik van een berekend veld).
Voordelen van SQL-aliassen
Enkele van de belangrijkste voordelen van SQL-aliassen zijn:
- Hiermee kunt u beter leesbare namen aan de kolomkoppen geven wanneer ze in de resultaten worden weergegeven
- Hiermee kunnen clienttoepassingen op naam naar een berekend veld verwijzen waar geen kolomnaam bestaat
- Hiermee kunt u code verminderen en uw zoekopdrachten beknopter maken
- Kan worden gebruikt als een verduisteringstechniek om de namen van de onderliggende kolommen van een zoekopdracht te beschermen
Ik moet erop wijzen dat het toewijzen van een alias de kolom of tabel niet daadwerkelijk hernoemt. Het biedt eenvoudigweg een alternatieve naam die kan worden gebruikt om ernaar te verwijzen.
Aliassyntaxis
Om een alias in SQL te maken, volgt u gewoon de kolom- of tabelnaam met de door u gekozen alias. U kunt optioneel de AS . gebruiken zoekwoord tussen de kolom-/tabelnaam en uw alias.
Zo voor kolommen:
SELECT Column1 AS Alias1
...
or
SELECT Column1 Alias1
...Of zoals dit voor tabellen:
...
FROM Table1 AS Alias1
...
or
...
FROM Table1 Alias1
...De volgende voorbeelden zullen dit beter illustreren.
De Kolomalias
Waarschijnlijk de meest gebruikte alias is de kolomalias. Met de kolomalias kunt u een tijdelijke naam voor uw kolommen opgeven.
Het stelt u ook in staat om een kolomnaam op te geven op plaatsen waar geen kolomnaam bestaat.
De volgende twee voorbeelden laten dezelfde query zien die is geschreven met en zonder kolomaliassen.
Zonder kolomalias
Hier is een eenvoudige SQL-query die niet gebruik kolomaliassen.
SELECT
f_name,
l_name
FROM customers;Resultaat:
+----------+----------+ | f_name | l_name | |----------+----------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +----------+----------+
In dit geval heb ik geen kolomaliassen opgegeven, en dus werden de werkelijke onderliggende kolomnamen als kolomkoppen in de resultaten weergegeven.
Met kolomalias
Hier is dezelfde zoekopdracht, maar deze keer gebruik ik kolomaliassen.
SELECT
f_name AS FirstName,
l_name AS LastName
FROM customers;Resultaat:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Merk op dat de kolomaliassen werden gebruikt als kolomkoppen in de resultaten.
Kolomaliassen op berekende velden
Kolomaliassen kunnen ook worden gebruikt op berekende velden waar geen kolomnaam bestaat. Ik bedoel niet op berekende kolommen, waar een kolomnaam is, maar op velden waar de waarde is afgeleid van een andere uitdrukking dan de waarde van een eenvoudige kolom.
"Hoe kan er geen kolomnaam zijn?" je mag vragen.
Welnu, er zijn veel gelegenheden waarbij u merkt dat er geen kolomnaam wordt geretourneerd in een zoekopdracht. Heb je ooit (No column name) . gezien als kolomkop van uw zoekopdrachtresultaten?
Er zijn tal van situaties waarin dit kan voorkomen.
Zonder een kolomalias
Hier is een voorbeeld van een zoekopdracht die geen kolomkop retourneert.
SELECT
f_name + ' ' + l_name
FROM customers;Resultaat:
+--------------------+ | (No column name) | |--------------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +--------------------+
In dit voorbeeld worden de voor- en achternaam van elke klant samengevoegd en wordt het resultaat als één kolom weergegeven. Het enige probleem is dat het DBMS niet weet hoe de kolom moet worden genoemd.
Dit is een perfecte gelegenheid voor een alias!
Met een kolomalias
Hier is hetzelfde voorbeeld, behalve dat ik nu een kolomalias toewijs aan het resultaat.
SELECT
f_name + ' ' + l_name AS FullName
FROM customers;Resultaat:
+---------------+ | FullName | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Het goede hieraan is dat elke clienttoepassing nu deze resultaten kan gebruiken en met zijn alias naar het berekende veld kan verwijzen.
Merk op dat in het bovenstaande voorbeeld de SQL Server tekenreeksaaneenschakelingsoperator (+ ). In DB2, Oracle, PostgreSQL en SQLite moet u || gebruiken . En gebruik in MySQL en MariaDB de CONCAT() functie. Hoewel dit niets met SQL-aliassen te maken heeft, dacht ik het toch even te vermelden 🙂
Alias met spaties
Het is ook mogelijk om aliassen met spaties te maken.
Wanneer u dit doet, omringt u de alias met dubbele aanhalingstekens. In sommige DBMS'en kunt u optioneel andere tekens gebruiken (zoals vierkante haken [] in SQL Server).
SELECT
f_name + ' ' + l_name AS "Full Name"
FROM customers;Resultaat:
+---------------+ | Full Name | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Houd er rekening mee dat het over het algemeen niet als een goede gewoonte wordt beschouwd om spaties in aliassen te hebben. Spaties kunnen allerlei problemen veroorzaken voor client-applicaties, en om die reden moet u over het algemeen vermijden om spaties in uw kolomaliassen op te nemen.
De AS weglaten Zoekwoord
Zoals gezegd, de AS trefwoord is optioneel. Daarom zouden we elk van de voorgaande voorbeelden kunnen herschrijven zonder de AS zoekwoord.
Hier is een voorbeeld.
SELECT
f_name FirstName,
l_name LastName
FROM customers;Resultaat:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Hoewel u de AS . kunt weglaten zoekwoord, gebruiken sommige SQL-professionals het om redenen van leesbaarheid altijd liever.
Welke syntaxis u ook gebruikt, ik raad u aan deze consistent te houden. Als u ervoor kiest om de AS . weg te laten trefwoord, en laat het dan overal weg. Als je ervoor kiest om het op te nemen, voeg het dan overal toe.
De tabelalias
De tabelalias is vergelijkbaar met de kolomalias, maar zoals de naam al doet vermoeden, is de tabelalias voor tabellen.
De tabelalias is ook bekend als de correlatienaam .
De tabelalias wordt vaak gebruikt bij het uitvoeren van joins. Het kan vooral handig zijn bij complexe query's, omdat het kan helpen de code beknopter en leesbaarder te houden.
Hieronder staan twee voorbeelden; één zonder tabelalias en één met tabelalias.
Voorbeeld zonder tabelalias
Hier is een eenvoudig voorbeeld van een query die een left join uitvoert tussen twee tabellen.
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;Resultaat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Merk op dat we de naam van elke tabel spellen waar we ernaar moeten verwijzen.
Voorbeeld met een tabelalias
Hier is hetzelfde voorbeeld, behalve met tabelaliassen.
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;Resultaat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Net als bij kolomaliassen, is de AS trefwoord is optioneel bij tabelaliassen. In Oracle is de AS trefwoord wordt zelfs niet ondersteund met tabelaliassen (hoewel het wordt ondersteund met kolomaliassen).
Daarom zouden we ons voorbeeld als volgt kunnen herschrijven.
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;Resultaat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Hoe dan ook, hetzelfde resultaat.