The SQL SELECT Statement: A Beginner's Guide

Almost every SQL query you'll ever write starts with the same word: SELECT. It's how you ask a database to hand you rows of data. This guide walks through the SELECT statement piece by piece, using a simple Employees table as the running example. Every snippet below can be pasted straight into the SQL playground, which already has this exact table loaded.

The basic shape

A SELECT statement has two required parts: which columns you want, and which table to get them from.

SELECT column1, column2
FROM table_name;

To get every column without typing each name, use the asterisk wildcard:

SELECT * FROM Employees;

This is convenient while exploring a table, but in real applications it's better practice to name the columns you actually need — it makes the query's intent clear and avoids pulling data you'll never use.

Choosing specific columns

SELECT first_name, last_name, salary
FROM Employees;

The column order in your SELECT list controls the column order in the result — it doesn't need to match the table's original definition.

Renaming columns with AS

The AS keyword gives a column (or an expression) a friendlier name in the output, called an alias. It doesn't rename anything in the actual table.

SELECT
    first_name AS "First Name",
    salary AS annual_salary
FROM Employees;

Aliases are especially useful once you start using calculations or aggregate functions, where the raw expression makes an ugly column header:

SELECT
    first_name,
    salary,
    ROUND(salary * 12, 0) AS annual_salary
FROM Employees;

Removing duplicates with DISTINCT

If a column has repeated values and you only want to see each one once, add DISTINCT right after SELECT:

SELECT DISTINCT dept_id
FROM Employees;

DISTINCT applies to the combination of every selected column, not each column independently. So SELECT DISTINCT dept_id, manager_id returns each unique pair of department and manager, not each unique department followed by each unique manager separately.

Sorting results with ORDER BY

Rows come back in no guaranteed order unless you ask for one. ORDER BY sorts ascending by default:

SELECT first_name, salary
FROM Employees
ORDER BY salary DESC;

Use ASC (default, so usually omitted) for low-to-high, and DESC for high-to-low. You can sort by multiple columns — the second column only breaks ties in the first:

SELECT dept_id, first_name, salary
FROM Employees
ORDER BY dept_id ASC, salary DESC;

Limiting how many rows come back

LIMIT caps the number of rows returned — handy for previewing a large table or grabbing a "top N" list once combined with ORDER BY:

SELECT first_name, hire_date
FROM Employees
ORDER BY hire_date DESC
LIMIT 3;

That query returns the three most recent hires — LIMIT is evaluated after ORDER BY, so the sort happens first.

Calculations in the SELECT list

A SELECT list is not limited to columns that already exist. You can compute new ones from the row's values, and give the result a name with AS. Nothing is written back to the table — the calculation happens as the rows are returned:

SELECT name, unit_price, in_stock, unit_price * in_stock AS stock_value
FROM Products
ORDER BY stock_value DESC;

Functions work here too. ROUND is a common one, because a raw multiplication or division often produces more decimal places than anyone wants to read:

SELECT name, unit_price, ROUND(unit_price * 0.9, 2) AS sale_price
FROM Products
WHERE category = 'Hardware';

Joining text together

The standard SQL operator for gluing strings together is ||, which works in SQLite, PostgreSQL and Oracle. MySQL uses the CONCAT() function instead, and SQL Server uses +:

SELECT first_name || ' ' || last_name AS full_name, email
FROM Employees
ORDER BY full_name;

Note the ' ' in the middle. Without it you would get AnanyaRao — the operator joins exactly what you give it and adds nothing of its own.

Three mistakes worth avoiding early

Reaching for SELECT * out of habit

It is genuinely useful while exploring an unfamiliar table. In anything you intend to keep, name your columns. A saved query using * silently changes shape the day someone adds a column, and it moves far more data than the query actually needs.

Expecting a reliable order without ORDER BY

Rows come back in whatever order the database found convenient. It often looks sorted, which is precisely the trap — that apparent order is not a promise, and it can change when the data grows or an index is added. If order matters, say so explicitly.

Assuming DISTINCT applies to one column

SELECT DISTINCT a, b removes duplicate combinations of a and b, not duplicates of a. It is a modifier on the whole row the query returns, not on the column it happens to sit next to.

Putting it together

A more complete example, combining everything above:

SELECT
    first_name,
    last_name,
    dept_id,
    ROUND(salary, 0) AS salary
FROM Employees
ORDER BY salary DESC
LIMIT 5;

Practice this topic

Reading explains it; solving it is what makes it stick. These exercises use exactly what this page covered, and your answer is checked by running it against the same database:

• Just the names and prices Easy
• The three priciest items Easy
• Which countries do we sell to? Easy
• Companies beginning with A Medium

See all 42 exercises →

Frequently asked questions

Where to go next

Once SELECT feels comfortable, the next step is filtering rows with WHERE, then combining data from multiple tables with JOINs:

• The SQL WHERE Clause: Filtering Data with Every Operator
• SQL JOINs Explained: INNER, LEFT, RIGHT & FULL
• SQL String Functions: UPPER, SUBSTRING, TRIM & More