SQL-aliaset är en trevlig liten funktion i SQL som låter dig skriva mer koncis kod och skapa kolumnnamn när inget kolumnnamn finns.
Det finns två SQL-aliastyper; kolumnalias och tabellalias. I den här artikeln ger jag en översikt över båda.
Vad är ett alias i SQL?
I SQL är ett alias en funktion som tillåter oss att tillfälligt tilldela ett annat namn till en kolumn eller tabell i våra SQL-frågor. Detta gör att vi kan minska mängden kod i våra frågor, vilket kan vara särskilt fördelaktigt i komplexa frågor.
Det tillåter oss också att tillhandahålla kolumnnamn till klientapplikationer där det inte finns något kolumnnamn (till exempel när ett beräknat fält används).
Fördelar med SQL-alias
Några av de främsta fördelarna med SQL-alias inkluderar:
- Låter dig ge mer läsbara namn till kolumnrubrikerna när de presenteras i resultaten
- Tillåter klientapplikationer att referera till ett beräknat fält med namn där inget kolumnnamn finns
- Låter dig minska koden och göra dina frågor mer kortfattade
- Kan användas som en obfuskeringsteknik för att skydda namnen på de underliggande kolumnerna i en fråga
Jag bör påpeka att tilldelning av ett alias faktiskt inte byter namn på kolumnen eller tabellen. Det ger helt enkelt ett alternativt namn som kan användas för att referera till det.
Aliassyntax
För att skapa ett alias i SQL, följ helt enkelt kolumnen eller tabellnamnet med ditt valda alias. Du kan valfritt använda AS nyckelord mellan kolumnen/tabellnamnet och ditt alias.
Så här för kolumner:
SELECT Column1 AS Alias1
...
or
SELECT Column1 Alias1
...Eller så här för bord:
...
FROM Table1 AS Alias1
...
or
...
FROM Table1 Alias1
...Följande exempel kommer att illustrera detta bättre.
Kolumnaliaset
Det förmodligen vanligaste aliaset är kolumnaliaset. Kolumnaliaset låter dig ange ett tillfälligt namn för dina kolumner.
Det låter dig också ange ett kolumnnamn på platser där det inte finns något kolumnnamn.
Följande två exempel visar samma fråga skriven med och utan kolumnalias.
Utan kolumnalias
Här är en enkel SQL-fråga som inte gör det använd kolumnalias.
SELECT
f_name,
l_name
FROM customers;Resultat:
+----------+----------+ | f_name | l_name | |----------+----------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +----------+----------+
I det här fallet angav jag inga kolumnalias, så de faktiska underliggande kolumnnamnen presenterades som kolumnrubriker i resultaten.
Med kolumnalias
Här är samma fråga, förutom den här gången använder jag kolumnalias.
SELECT
f_name AS FirstName,
l_name AS LastName
FROM customers;Resultat:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Observera att kolumnaliasen användes som kolumnrubriker i resultaten.
Kolumnalias på beräknade fält
Kolumnalias kan också användas på beräknade fält där det inte finns något kolumnnamn. Jag menar inte på beräknade kolumner, där det finns ett kolumnnamn, utan på fält där värdet härrör från ett annat uttryck än en enkel kolumns värde.
"Hur kunde det inte finnas något kolumnnamn?" du kan fråga.
Tja, det finns många tillfällen där du kan upptäcka att det inte finns något kolumnnamn som returneras i en fråga. Har du någonsin sett (No column name) som en kolumnrubrik för dina frågeresultat?
Det finns många situationer där detta kan inträffa.
Utan ett kolumnalias
Här är ett exempel på en fråga som inte returnerar en kolumnrubrik.
SELECT
f_name + ' ' + l_name
FROM customers;Resultat:
+--------------------+ | (No column name) | |--------------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +--------------------+
Det här exemplet sammanfogar varje kunds förnamn och efternamn och presenterar resultatet som en kolumn. Det enda problemet är att DBMS inte vet vad den ska kalla kolumnen.
Detta är ett perfekt tillfälle för ett alias!
Med ett kolumnalias
Här är samma exempel, förutom att jag nu tilldelar resultatet ett kolumnalias.
SELECT
f_name + ' ' + l_name AS FullName
FROM customers;Resultat:
+---------------+ | FullName | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Det som är bra med detta är att alla klientapplikationer nu kan ta dessa resultat och referera till det beräknade fältet med sitt alias.
Observera att exemplet ovan använder SQL Server-strängsammansättningsoperatorn (+ ). I DB2, Oracle, PostgreSQL och SQLite måste du använda || . Och i MySQL och MariaDB, använd CONCAT() fungera. Även om detta inte har något att göra med SQL-alias, tänkte jag bara nämna det 🙂
Alias med Spaces
Det är också möjligt att skapa alias med mellanslag.
När du gör detta, omge aliaset med dubbla citattecken. I vissa DBMS kan du valfritt använda andra tecken (som hakparenteser [] i SQL Server).
SELECT
f_name + ' ' + l_name AS "Full Name"
FROM customers;Resultat:
+---------------+ | Full Name | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Tänk på att det i allmänhet inte anses vara bra att ha mellanslag i alias. Mellanslag kan orsaka alla möjliga problem för klientapplikationer, och av den anledningen bör du i allmänhet undvika att inkludera mellanslag i dina kolumnalias.
Utesluter AS Nyckelord
Som nämnts, AS nyckelord är valfritt. Därför skulle vi kunna skriva om vilket som helst av de tidigare exemplen utan AS nyckelord.
Här är ett exempel.
SELECT
f_name FirstName,
l_name LastName
FROM customers;Resultat:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Även om du kan utelämna AS nyckelord föredrar vissa SQL-proffs att alltid inkludera det av läsbarhetsskäl.
Vilken syntax du än föredrar att använda, skulle jag rekommendera att hålla den konsekvent. Om du väljer att utelämna AS sökord och utelämna det överallt. Om du väljer att inkludera det, inkludera det överallt.
Tabellaliaset
Tabellaliaset liknar kolumnaliaset, men som namnet antyder är tabellaliaset för tabeller.
Tabellaliaset är också känt som korrelationsnamnet .
Tabellaliaset används ofta när man utför joins. Det kan vara särskilt användbart i komplexa frågor, eftersom det kan hjälpa till att hålla koden mer kortfattad och mer läsbar.
Nedan följer två exempel; en utan tabellalias och en med tabellalias.
Exempel utan tabellalias
Här är ett grundläggande exempel på en fråga som gör en vänsterkoppling mellan två tabeller.
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;Resultat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Observera att vi stavar namnet på varje tabell där vi behöver referera till det.
Exempel med ett tabellalias
Här är samma exempel, förutom med tabellalias.
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;Resultat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Som med kolumnalias, AS nyckelord är valfritt med tabellalias. I Oracle, AS sökord stöds inte ens med tabellalias (även om det stöds med kolumnalias).
Därför skulle vi kunna skriva om vårt exempel till följande.
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;Resultat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Hur som helst, samma resultat.