SQL Aliases are temporary names given to a table or a column in a query, mainly to make output more readable or concise. Key points from the page:

• Purpose: Aliases make column or table names easier to understand, especially in results.
• Syntax: Created using the AS keyword, but AS is optional in many SQL dialects.
  • For columns: SELECT column_name AS alias_name FROM table_name;
  • For tables: SELECT column_name(s) FROM table_name AS alias_name;
• Scope: The alias only exists for the duration of the query.
• Examples:
  • SELECT CustomerID AS ID FROM Customers;
  • SELECT CustomerID ID FROM Customers;
• Spaces in Aliases: To include spaces in an alias, use square brackets [ ] or double quotes " ", e.g., AS [My Great Products].
• Concatenation: You can combine (concatenate) columns into one and assign a single alias (e.g., merge address fields into one).
• Table Aliases: Useful in queries with multiple tables—shorter references make queries easier to write and read.
  • Example: SELECT o.OrderID, c.CustomerName FROM Customers AS c, Orders AS o WHERE c.CustomerID = o.CustomerID;
• Common Use Cases: When combining columns, handling large or complex column names, using multiple tables, or applying functions.

The page also includes example exercises and notes about using aliases across different database systems (like MySQL and Oracle) and demonstrates best practices for readable, maintainable SQL code.[1]

1

SQL Aliases

SQL Aliases

SQL aliases are used to give a table, or a column in a table, a temporary name.

Aliases are often used to make column names more readable.

An alias only exists for the duration of that query.

An alias is created with the AS keyword.

SELECT CustomerID AS ID  
FROM Customers;

AS is Optional

Actually, in most database languages, you can skip the AS keyword and get the same result:

SELECT CustomerID ID  
FROM Customers;

Syntax

When alias is used on column:

SELECT column_name AS alias_name
FROM table_name;

When alias is used on table:

SELECT column_name(s)
FROM table_name AS alias_name;

Demo Database

Below is a selection from the Customers and Orders tables used in the examples:

Customers

Orders

Alias for Columns

The following SQL statement creates two aliases, one for the CustomerID column and one for the CustomerName column:

SELECT CustomerID AS ID, CustomerName AS Customer  
FROM Customers;

Using Aliases With a Space Character

If you want your alias to contain one or more spaces, like "My Great Products", surround your alias with square brackets or double quotes.

`Using [square brackets] for aliases with space characters:

SELECT ProductName AS [My Great Products]  
FROM Products;

Using "double quotes" for aliases with space characters:

SELECT ProductName AS "My Great Products"  
FROM Products;

`Note: Some database systems allows both [] and "", and some only allows one of them.

Concatenate Columns

The following SQL statement creates an alias named "Address" that combine four columns (Address, PostalCode, City and Country):

SELECT CustomerName, Address + ', ' + PostalCode + ' ' + City + ', ' + Country AS Address FROM Customers;

Note: To get the SQL statement above to work in MySQL use the following:

SELECT CustomerName, CONCAT(Address,', ',PostalCode,', ',City,', ',Country) AS Address  
FROM Customers;

Note: To get the SQL statement above to work in Oracle use the following:

SELECT CustomerName, (Address || ', ' || PostalCode || ' ' || City || ', ' || Country) AS Address FROM Customers;

Alias for Tables

The same rules applies when you want to use an alias for a table.

Refer to the Customers table as Persons instead:

SELECT * FROM Customers AS Persons;

It might seem useless to use aliases on tables, but when you are using more than one table in your queries, it can make the SQL statements shorter.

The following SQL statement selects all the orders from the customer with CustomerID=4 (Around the Horn). We use the "Customers" and "Orders" tables, and give them the table aliases of "c" and "o" respectively (Here we use aliases to make the SQL shorter):

SELECT o.OrderID, o.OrderDate, c.CustomerName  
FROM Customers AS c, Orders AS o  
WHERE c.CustomerName='Around the Horn' AND c.CustomerID=o.CustomerID;

The following SQL statement is the same as above, but without aliases:

SELECT Orders.OrderID, Orders.OrderDate, Customers.CustomerName  
FROM Customers, Orders  
WHERE Customers.CustomerName='Around the Horn' AND Customers.CustomerID=Orders.CustomerID;

Aliases can be useful when:

• There are more than one table involved in a query
• Functions are used in the query
• Column names are big or not very readable
• Two or more columns are combined together