El alias de SQL es una característica pequeña y agradable de SQL que le permite escribir código más conciso y crear nombres de columna cuando no existe ningún nombre de columna.
Hay dos tipos de alias de SQL; alias de columna y alias de tabla. En este artículo, ofrezco una descripción general de ambos.
¿Qué es un alias en SQL?
En SQL, un alias es una característica que nos permite asignar temporalmente un nombre diferente a una columna o tabla en nuestras consultas SQL. Esto nos permite reducir la cantidad de código en nuestras consultas, lo que puede ser particularmente beneficioso en consultas complejas.
También nos permite proporcionar nombres de columna a aplicaciones cliente donde no existe ningún nombre de columna (por ejemplo, cuando se usa un campo calculado).
Beneficios de los alias de SQL
Algunos de los principales beneficios de los alias de SQL incluyen:
- Le permite proporcionar nombres más legibles a los encabezados de las columnas cuando se presentan en los resultados
- Permite que las aplicaciones cliente se refieran a un campo calculado por nombre donde no existe un nombre de columna
- Le permite reducir el código y hacer que sus consultas sean más concisas
- Se puede utilizar como técnica de ofuscación para proteger los nombres de las columnas subyacentes de una consulta
Debo señalar que asignar un alias en realidad no cambia el nombre de la columna o tabla. Simplemente proporciona un nombre alternativo que se puede usar para referirse a él.
Sintaxis de alias
Para crear un alias en SQL, simplemente siga el nombre de la columna o tabla con su alias elegido. Opcionalmente, puede usar el AS palabra clave entre el nombre de la columna/tabla y su alias.
Me gusta esto para las columnas:
SELECT Column1 AS Alias1
...
or
SELECT Column1 Alias1
...O así para las tablas:
...
FROM Table1 AS Alias1
...
or
...
FROM Table1 Alias1
...Los siguientes ejemplos lo ilustrarán mejor.
El alias de la columna
Probablemente el alias más utilizado es el alias de columna. El alias de columna le permite proporcionar un nombre temporal para sus columnas.
También le permite proporcionar un nombre de columna en lugares donde no existe un nombre de columna.
Los siguientes dos ejemplos muestran la misma consulta escrita con y sin alias de columna.
Sin alias de columna
Aquí hay una consulta SQL simple que no usar alias de columna.
SELECT
f_name,
l_name
FROM customers;Resultado:
+----------+----------+ | f_name | l_name | |----------+----------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +----------+----------+
En este caso, no proporcioné ningún alias de columna, por lo que los nombres de columna subyacentes reales se presentaron como encabezados de columna en los resultados.
Con alias de columna
Esta es la misma consulta, excepto que esta vez uso alias de columna.
SELECT
f_name AS FirstName,
l_name AS LastName
FROM customers;Resultado:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Observe que los alias de columna se usaron como encabezados de columna en los resultados.
Alias de columna en campos calculados
Los alias de columna también se pueden usar en campos calculados donde no existe un nombre de columna. No me refiero a las columnas calculadas, donde hay un nombre de columna, sino a los campos donde el valor se deriva de una expresión que no es el valor de una columna simple.
"¿Cómo podría no haber un nombre de columna?" puedes preguntar.
Bueno, hay muchas ocasiones en las que puede encontrar que no se devuelve ningún nombre de columna en una consulta. ¿Alguna vez has visto (No column name) como encabezado de columna de los resultados de su consulta?
Hay muchas situaciones en las que esto puede ocurrir.
Sin alias de columna
Este es un ejemplo de una consulta que no devuelve un encabezado de columna.
SELECT
f_name + ' ' + l_name
FROM customers;Resultado:
+--------------------+ | (No column name) | |--------------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +--------------------+
Este ejemplo concatena el nombre y apellido de cada cliente y presenta el resultado como una columna. El único problema es que el DBMS no sabe cómo llamar a la columna.
¡Esta es una oportunidad perfecta para un alias!
Con un alias de columna
Este es el mismo ejemplo, excepto que ahora asigno un alias de columna al resultado.
SELECT
f_name + ' ' + l_name AS FullName
FROM customers;Resultado:
+---------------+ | FullName | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Lo bueno de esto es que cualquier aplicación cliente ahora puede tomar estos resultados y referirse al campo calculado por su alias.
Tenga en cuenta que el ejemplo anterior utiliza el operador de concatenación de cadenas de SQL Server (+ ). En DB2, Oracle, PostgreSQL y SQLite, deberá usar || . Y en MySQL y MariaDB, use CONCAT() función. Si bien esto no tiene nada que ver con los alias de SQL, pensé en mencionarlo 🙂
Alias con espacios
También es posible crear alias con espacios.
Cuando haga esto, rodee el alias con comillas dobles. En algunos DBMS, puede usar opcionalmente otros caracteres (como corchetes [] en SQL Server).
SELECT
f_name + ' ' + l_name AS "Full Name"
FROM customers;Resultado:
+---------------+ | Full Name | |---------------| | Homer Connery | | Bart Pitt | | Nancy Simpson | | Boris Trump | +---------------+
Tenga en cuenta que generalmente no se considera una buena práctica tener espacios en los alias. Los espacios pueden causar todo tipo de problemas para las aplicaciones cliente y, por ese motivo, generalmente debe evitar incluir espacios en los alias de sus columnas.
Omitir el AS Palabra clave
Como se mencionó, el AS la palabra clave es opcional. Por tanto, podríamos reescribir cualquiera de los ejemplos anteriores sin el AS palabra clave.
Aquí hay un ejemplo.
SELECT
f_name FirstName,
l_name LastName
FROM customers;Resultado:
+-------------+------------+ | FirstName | LastName | |-------------+------------| | Homer | Connery | | Bart | Pitt | | Nancy | Simpson | | Boris | Trump | +-------------+------------+
Aunque puedes omitir el AS palabra clave, algunos profesionales de SQL prefieren incluirla siempre, por razones de legibilidad.
Cualquiera que sea la sintaxis que prefiera usar, recomendaría mantenerla consistente. Si elige omitir el AS palabra clave, luego omítala en todas partes. Si elige incluirlo, inclúyalo en todas partes.
El alias de la mesa
El alias de tabla es similar al alias de columna, pero como sugiere el nombre, el alias de tabla es para tablas.
El alias de la tabla también se conoce como nombre de correlación .
El alias de la tabla se usa a menudo cuando se realizan uniones. Puede ser especialmente útil en consultas complejas, ya que puede ayudar a que el código sea más conciso y legible.
A continuación se muestran dos ejemplos; uno sin alias de tabla y otro con alias de tabla.
Ejemplo sin un alias de tabla
Este es un ejemplo básico de una consulta que realiza una combinación izquierda entre dos tablas.
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;Resultado:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Tenga en cuenta que deletreamos el nombre de cada tabla donde sea que necesitemos hacer referencia a ella.
Ejemplo con un alias de tabla
Este es el mismo ejemplo, excepto que los alias de las tablas.
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;Resultado:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Al igual que con los alias de columna, el AS la palabra clave es opcional con alias de tabla. En Oracle, el AS la palabra clave ni siquiera es compatible con alias de tabla (aunque sí lo es con alias de columna).
Por lo tanto, podríamos reescribir nuestro ejemplo de la siguiente manera.
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;Resultado:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
De cualquier manera, el mismo resultado.
