SELECT, WHERE and sorting — your first real queries

The shape of a query

SELECT  columns you want
FROM    table they come from
WHERE   rows you keep
ORDER BY how to sort
LIMIT   how many rows to show;

Only SELECT and FROM are required. SQL keywords are not case-sensitive (select = SELECT); writing them in capitals is a readability convention.

SELECT and FROM

Return three columns from products:

SELECT product_name, category, list_price
FROM products
LIMIT 5;

SELECT * returns every column. It is fine for exploring, but in reports and dashboards list columns explicitly — * breaks when someone adds a column and makes queries slower on wide tables.

Calculated columns and aliases

You can compute new columns. AS gives a column (or table) an alias:

SELECT product_name,
       list_price,
       unit_cost,
       list_price - unit_cost                     AS unit_margin,
       ROUND((list_price - unit_cost) / list_price * 100, 1) AS margin_pct
FROM products
LIMIT 5;

Read row 1: the product sells for its list price, costs unit_cost, so each unit earns unit_margin before discounts, which is margin_pct of the price.

WHERE: keeping only the rows you need

WHERE keeps rows for which the condition is true. Comparison operators: =, <> (or !=), <, <=, >, >=.

SELECT store_name, city, open_date
FROM stores
WHERE region = 'East';

Text values go in single quotes. Dates stored in ISO format are compared as text and still work: order_date >= '2025-01-01'.

AND, OR, NOT

• AND — both conditions must be true.
• OR — at least one must be true.
• NOT — reverses a condition.

SELECT order_id, order_date, channel, status, discount_pct
FROM orders
WHERE order_date >= '2025-11-01'
  AND channel = 'online'
  AND NOT status = 'completed'
LIMIT 6;

IN, BETWEEN and LIKE

SELECT product_name, category, list_price
FROM products
WHERE category IN ('Electronics', 'Sports')
  AND list_price BETWEEN 50 AND 100
  AND product_name LIKE '%Pro'
ORDER BY list_price DESC
LIMIT 6;

• IN (…) is shorthand for several OR … = comparisons.
• BETWEEN a AND b is inclusive of both ends (>= a AND <= b).
• LIKE matches patterns: % = any sequence of characters, _ = exactly one character. '%Pro' = ends with "Pro". (In SQLite LIKE is case-insensitive for ASCII letters; in PostgreSQL it is case-sensitive — use ILIKE there.)

ORDER BY

Results have no guaranteed order unless you ask for one. ORDER BY sorts ascending (ASC, default) or descending (DESC); you can sort by several columns:

SELECT store_name, region, size_sqm
FROM stores
WHERE channel = 'store'
ORDER BY region ASC, size_sqm DESC;

DISTINCT

DISTINCT removes duplicate rows from the result — useful for listing the values a column takes:

SELECT DISTINCT status
FROM orders;

DISTINCT applies to the whole row you select: SELECT DISTINCT city, segment returns each unique combination.

LIMIT (and TOP)

LIMIT n returns at most n rows; combined with ORDER BY it gives "top N" lists. SQL Server uses SELECT TOP 5 … instead; standard SQL also has FETCH FIRST 5 ROWS ONLY.

SELECT product_name, list_price
FROM products
ORDER BY list_price DESC
LIMIT 5;

How SQL actually evaluates a query

You write SELECT first, but the database logically processes clauses in this order:

1. FROM — which table(s)
2. WHERE — filter rows
3. GROUP BY — form groups (next lessons)
4. HAVING — filter groups
5. SELECT — compute output columns and aliases
6. DISTINCT
7. ORDER BY — sort
8. LIMIT

This explains a classic error: you cannot use a SELECT alias inside WHERE (in most databases), because WHERE is evaluated before the alias exists. You can use it in ORDER BY.

Business application

A store manager asks: "Which Pro-variant products under 100 do we sell in Electronics? Most expensive first." That is one query: filter category, name pattern and price, then sort. Translating a sentence into WHERE conditions precisely — including what "under" means (< vs <=) — is the skill.

Practice — write the queries yourself

Use the editor to run your query before checking it. The answer checker executes your SQL and compares the result with the correct result, so any correct query is accepted.

Summary

• SELECT chooses columns (including calculated ones with aliases); FROM chooses the table.
• WHERE filters rows with comparisons, AND/OR/NOT (use parentheses!), IN, BETWEEN (inclusive) and LIKE.
• ORDER BY is the only way to guarantee order; DISTINCT removes duplicate rows; LIMIT/TOP caps output.
• Logical order: FROM → WHERE → GROUP BY → HAVING → SELECT → DISTINCT → ORDER BY → LIMIT.