L'alias SQL è una piccola funzionalità di SQL che ti consente di scrivere codice più conciso e creare nomi di colonna quando non esiste alcun nome di colonna.
Esistono due tipi di alias SQL; alias di colonna e alias di tabella. In questo articolo, fornisco una panoramica di entrambi.
Cos'è un alias in SQL?
In SQL, un alias è una funzionalità che ci consente di assegnare temporaneamente un nome diverso a una colonna o tabella nelle nostre query SQL. Questo ci consente di ridurre la quantità di codice nelle nostre query, il che può essere particolarmente vantaggioso nelle query complesse.
Ci consente inoltre di fornire nomi di colonna alle applicazioni client in cui non esiste alcun nome di colonna (ad esempio, quando si utilizza un campo calcolato).
Vantaggi degli alias SQL
Alcuni dei principali vantaggi degli alias SQL includono:
- Ti consente di fornire nomi più leggibili alle intestazioni delle colonne quando vengono presentate nei risultati
- Consente alle applicazioni client di fare riferimento a un campo calcolato per nome in cui non esiste un nome di colonna
- Ti consente di ridurre il codice e rendere le tue query più concise
- Può essere utilizzato come tecnica di offuscamento per proteggere i nomi delle colonne sottostanti di una query
Devo sottolineare che l'assegnazione di un alias non rinomina effettivamente la colonna o la tabella. Fornisce semplicemente un nome alternativo che può essere utilizzato per fare riferimento ad esso.
Sintassi alias
Per creare un alias in SQL, segui semplicemente il nome della colonna o della tabella con l'alias scelto. Puoi opzionalmente utilizzare il AS parola chiave tra il nome della colonna/tabella e il tuo alias.
In questo modo per le colonne:
SELECT Column1 AS Alias1
...
or
SELECT Column1 Alias1
...O così per i tavoli:
...
FROM Table1 AS Alias1
...
or
...
FROM Table1 Alias1
...Gli esempi seguenti lo illustreranno meglio.
L'alias della colonna
Probabilmente l'alias più comunemente usato è l'alias di colonna. L'alias di colonna ti consente di fornire un nome temporaneo per le tue colonne.
Consente inoltre di fornire un nome di colonna in luoghi in cui non esiste alcun nome di colonna.
I due esempi seguenti mostrano la stessa query scritta con e senza alias di colonna.
Senza alias colonna
Ecco una semplice query SQL che non usa alias di colonna.
SELECT
f_name,
l_name
FROM customers;Risultato:
+----------+----------+ | f_name | l_name | |----------+----------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +----------+----------+
In questo caso, non ho fornito alcun alias di colonna, quindi i nomi delle colonne sottostanti effettivi sono stati presentati come intestazioni di colonna nei risultati.
Con colonna alias
Ecco la stessa query, tranne che questa volta utilizzo alias di colonna.
SELECT
f_name AS FirstName,
l_name AS LastName
FROM customers;Risultato:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Nota che gli alias di colonna sono stati utilizzati come intestazioni di colonna nei risultati.
Alias di colonna sui campi calcolati
Gli alias di colonna possono essere utilizzati anche sui campi calcolati in cui non esiste un nome di colonna. Non intendo su colonne calcolate, dove è presente un nome di colonna, ma su campi in cui il valore deriva da un'espressione diversa dal valore di una semplice colonna.
"Come potrebbe non esserci un nome di colonna?" potresti chiedere.
Bene, ci sono molte occasioni in cui potresti scoprire che non viene restituito alcun nome di colonna in una query. Hai mai visto (No column name) come intestazione di colonna dei risultati della tua query?
Ci sono molte situazioni in cui ciò può verificarsi.
Senza un alias di colonna
Ecco un esempio di query che non restituisce un'intestazione di colonna.
SELECT
f_name + ' ' + l_name
FROM customers;Risultato:
+--------------------+ | (No column name) | |--------------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +--------------------+
Questo esempio concatena il nome e il cognome di ogni cliente e presenta il risultato come una colonna. L'unico problema è che il DBMS non sa come chiamare la colonna.
Questa è un'opportunità perfetta per uno pseudonimo!
Con un alias di colonna
Ecco lo stesso esempio, tranne per il fatto che ora assegno un alias di colonna al risultato.
SELECT
f_name + ' ' + l_name AS FullName
FROM customers;Risultato:
+---------------+ | FullName | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
La cosa buona è che qualsiasi applicazione client può ora prendere questi risultati e fare riferimento al campo calcolato con il suo alias.
Si noti che l'esempio precedente usa l'operatore di concatenazione di stringhe di SQL Server (+ ). In DB2, Oracle, PostgreSQL e SQLite, dovrai utilizzare || . E in MySQL e MariaDB, usa CONCAT() funzione. Anche se questo non ha nulla a che fare con gli alias SQL, ho pensato di menzionarlo 🙂
Alias con spazi
È anche possibile creare alias con spazi.
Quando lo fai, racchiudi l'alias tra virgolette doppie. In alcuni DBMS, puoi opzionalmente utilizzare altri caratteri (come parentesi quadre [] in SQL Server).
SELECT
f_name + ' ' + l_name AS "Full Name"
FROM customers;Risultato:
+---------------+ | Full Name | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Tieni presente che generalmente non è considerata una buona pratica avere spazi negli alias. Gli spazi possono causare ogni tipo di problema alle applicazioni client e, per questo motivo, dovresti generalmente evitare di includere spazi negli alias delle colonne.
Omissione di AS Parola chiave
Come accennato, il AS la parola chiave è facoltativa. Pertanto, potremmo riscrivere uno qualsiasi degli esempi precedenti senza il AS parola chiave.
Ecco un esempio.
SELECT
f_name FirstName,
l_name LastName
FROM customers;Risultato:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Sebbene tu possa omettere il AS parola chiave, alcuni professionisti SQL preferiscono includerla sempre, per motivi di leggibilità.
Qualunque sia la sintassi che preferisci usare, ti consiglio di mantenerla coerente. Se scegli di omettere AS parola chiave, quindi omettila ovunque. Se scegli di includerlo, includilo ovunque.
L'alias del tavolo
L'alias della tabella è simile all'alias della colonna, ma come suggerisce il nome, l'alias della tabella è per le tabelle.
L'alias della tabella è anche noto come nome di correlazione .
L'alias di tabella viene spesso utilizzato durante l'esecuzione di join. Può essere particolarmente utile nelle query complesse, perché può aiutare a mantenere il codice più conciso e più leggibile.
Di seguito sono riportati due esempi; uno senza un alias di tabella e uno con un alias di tabella.
Esempio senza alias tabella
Ecco un esempio di base di una query che esegue un join sinistro tra due tabelle.
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;Risultato:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Nota che scriviamo il nome di ogni tabella ovunque sia necessario farvi riferimento.
Esempio con un alias tabella
Ecco lo stesso esempio, ad eccezione degli alias di tabella.
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;Risultato:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Come per gli alias di colonna, il AS la parola chiave è facoltativa con gli alias di tabella. In Oracle, il AS la parola chiave non è nemmeno supportata con gli alias di tabella (sebbene sia supportata con gli alias di colonna).
Pertanto, potremmo riscrivere il nostro esempio come segue.
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;Risultato:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Ad ogni modo, stesso risultato.
