SQL-aliasset er en fin lille funktion i SQL, der giver dig mulighed for at skrive mere kortfattet kode og oprette kolonnenavne, når der ikke findes et kolonnenavn.
Der er to SQL-aliastyper; kolonnealiasser og tabelaliasser. I denne artikel giver jeg et overblik over begge dele.
Hvad er et Alias i SQL?
I SQL er et alias en funktion, der giver os mulighed for midlertidigt at tildele et andet navn til en kolonne eller tabel i vores SQL-forespørgsler. Dette giver os mulighed for at reducere mængden af kode i vores forespørgsler, hvilket kan være særligt fordelagtigt i komplekse forespørgsler.
Det giver os også mulighed for at give kolonnenavne til klientapplikationer, hvor der ikke findes et kolonnenavn (f.eks. ved brug af et beregnet felt).
Fordele ved SQL-aliaser
Nogle af de vigtigste fordele ved SQL-aliaser inkluderer:
- Giver dig mulighed for at angive mere læsbare navne til kolonneoverskrifterne, når de præsenteres i resultaterne
- Tillader klientapplikationer at henvise til et beregnet felt ved navn, hvor der ikke findes et kolonnenavn
- Giver dig mulighed for at reducere kode og gøre dine forespørgsler mere kortfattede
- Kan bruges som en sløringsteknik til at beskytte navnene på de underliggende kolonner i en forespørgsel
Jeg skal påpege, at tildeling af et alias faktisk ikke omdøber kolonnen eller tabellen. Det giver simpelthen et alternativt navn, der kan bruges til at henvise til det.
Aliassyntaks
For at oprette et alias i SQL skal du blot følge kolonne- eller tabelnavnet med dit valgte alias. Du kan valgfrit bruge AS søgeord mellem kolonne-/tabelnavnet og dit alias.
Sådan for kolonner:
SELECT Column1 AS Alias1
...
or
SELECT Column1 Alias1
...Eller sådan for borde:
...
FROM Table1 AS Alias1
...
or
...
FROM Table1 Alias1
...De følgende eksempler vil illustrere dette bedre.
Søjlealiaset
Sandsynligvis det mest brugte alias er kolonnealiaset. Kolonnealiaset giver dig mulighed for at angive et midlertidigt navn til dine kolonner.
Det giver dig også mulighed for at angive et kolonnenavn på steder, hvor der ikke findes et kolonnenavn.
De følgende to eksempler viser den samme forespørgsel skrevet med og uden kolonnealiaser.
Uden kolonnealias
Her er en simpel SQL-forespørgsel, som ikke gør brug kolonnealiasser.
SELECT
f_name,
l_name
FROM customers;Resultat:
+----------+----------+ | f_name | l_name | |----------+----------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +----------+----------+
I dette tilfælde angav jeg ikke nogen kolonnealiaser, og derfor blev de faktiske underliggende kolonnenavne præsenteret som kolonneoverskrifter i resultaterne.
Med kolonnealias
Her er den samme forespørgsel, bortset fra at denne gang bruger jeg kolonnealiaser.
SELECT
f_name AS FirstName,
l_name AS LastName
FROM customers;Resultat:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Bemærk, at kolonnealiasserne blev brugt som kolonneoverskrifter i resultaterne.
Kolonnealiaser på beregnede felter
Kolonnealiaser kan også bruges på beregnede felter, hvor der ikke findes et kolonnenavn. Jeg mener ikke på beregnede kolonner, hvor der er et kolonnenavn, men på felter, hvor værdien er afledt af et andet udtryk end en simpel kolonnes værdi.
"Hvordan kunne der ikke være noget kolonnenavn?" kan du spørge.
Nå, der er mange lejligheder, hvor du kan opdage, at der ikke er noget kolonnenavn, der returneres i en forespørgsel. Har du nogensinde set (No column name) som en kolonneoverskrift for dine forespørgselsresultater?
Der er mange situationer, hvor dette kan forekomme.
Uden et kolonnealias
Her er et eksempel på en forespørgsel, der ikke returnerer en kolonneoverskrift.
SELECT
f_name + ' ' + l_name
FROM customers;Resultat:
+--------------------+ | (No column name) | |--------------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +--------------------+
Dette eksempel sammenkæder hver kundes fornavn og efternavn og præsenterer resultatet som én kolonne. Det eneste problem er, at DBMS'en ikke ved, hvad den skal kalde kolonnen.
Dette er en perfekt mulighed for et alias!
Med et kolonnealias
Her er det samme eksempel, bortset fra at jeg nu tildeler et kolonnealias til resultatet.
SELECT
f_name + ' ' + l_name AS FullName
FROM customers;Resultat:
+---------------+ | FullName | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Det gode ved dette er, at enhver klientapplikation nu kan tage disse resultater og henvise til det beregnede felt ved sit alias.
Bemærk, at ovenstående eksempel bruger SQL Server-strengsammenkædningsoperatoren (+ ). I DB2, Oracle, PostgreSQL og SQLite skal du bruge || . Og i MySQL og MariaDB skal du bruge CONCAT() fungere. Selvom dette ikke har noget at gøre med SQL-aliaser, tænkte jeg bare, at jeg ville nævne det 🙂
Aliaser med Spaces
Det er også muligt at oprette aliaser med mellemrum.
Når du gør dette, skal du omgive aliaset med dobbelte anførselstegn. I nogle DBMS'er kan du valgfrit bruge andre tegn (såsom firkantede parenteser [] i SQL Server).
SELECT
f_name + ' ' + l_name AS "Full Name"
FROM customers;Resultat:
+---------------+ | Full Name | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Husk, at det generelt ikke anses for god praksis at have mellemrum i aliaser. Mellemrum kan forårsage alle mulige problemer for klientapplikationer, og af den grund bør du generelt undgå at inkludere mellemrum i dine kolonnealiasser.
Udladelse af AS Søgeord
Som nævnt er AS søgeord er valgfrit. Derfor kunne vi omskrive et hvilket som helst af de foregående eksempler uden AS søgeord.
Her er et eksempel.
SELECT
f_name FirstName,
l_name LastName
FROM customers;Resultat:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Selvom du kan udelade AS nøgleord, foretrækker nogle SQL-professionelle altid at inkludere det af hensyn til læsbarheden.
Uanset hvilken syntaks du foretrækker at bruge, vil jeg anbefale at holde den konsekvent. Hvis du vælger at udelade AS søgeord, så udelad det overalt. Hvis du vælger at inkludere det, så medtag det overalt.
Tabelaliaset
Tabelaliaset ligner kolonnealiaset, men som navnet antyder, er tabelaliaset til tabeller.
Tabellaliaset er også kendt som korrelationsnavnet .
Tabelaliaset bruges ofte, når der udføres joins. Det kan især være nyttigt i komplekse forespørgsler, fordi det kan hjælpe med at holde koden mere kortfattet og mere læsbar.
Nedenfor er to eksempler; en uden tabelalias og en med tabelalias.
Eksempel uden et tabelalias
Her er et grundlæggende eksempel på en forespørgsel, der laver en venstre join mellem to 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 | +-----------+---------+
Bemærk, at vi staver navnet på hver tabel, hvor vi skal henvise til den.
Eksempel med et tabelalias
Her er det samme eksempel, undtagen med tabelaliasser.
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 kolonnealiaser er AS søgeord er valgfrit med tabelaliasser. I Oracle er AS søgeord er ikke engang understøttet med tabelaliasser (selvom det understøttes med kolonnealiasser).
Derfor kunne vi omskrive vores eksempel til følgende.
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 | +-----------+---------+
Uanset hvad, samme resultat.