Structured query language (SQL)

Every retrieval query answers three questions in a fixed order.

Clause	Question it answers
SELECT	Which fields (columns) do I want to see?
FROM	Which table is the data in?
WHERE	Which records (rows) do I want?

The tables used throughout this section

Student

StudentID	Forename	Surname	YearGroup	TutorID	FeesPaid
S1041	Amara	Okafor	10	T07	True
S1042	Ben	Whitton	11	T11	False
S1043	Chen	Liu	10	T07	True
S1044	Dina	Petrov	11	T07	False

Tutor

TutorID	TutorName	Room
T07	Ms Rahman	12
T11	Mr Ellis	5

Selecting fields

SELECT Forename, Surname
FROM Student

Returns just those two columns, for every record — because there is no WHERE clause.

To return all fields, use *:

SELECT *
FROM Student

Filtering records with WHERE

SELECT Forename, Surname
FROM Student
WHERE YearGroup = 10

Returns Amara Okafor and Chen Liu.

⚠️ Quotes. Text values are enclosed in quotation marks; numbers are not.

SELECT StudentID
FROM Student
WHERE Surname = 'Liu'        -- text: quotes needed

SELECT StudentID
FROM Student
WHERE YearGroup = 11         -- number: no quotes

Comparison operators

Operator	Meaning	Example
=	Equal to	WHERE YearGroup = 10
<>	Not equal to	WHERE YearGroup <> 10
>	Greater than	WHERE Price > 20
<	Less than	WHERE Price < 20
>=	Greater than or equal to	WHERE YearGroup >= 10
<=	Less than or equal to	WHERE Price <= 50

Combining conditions

SELECT Forename, Surname
FROM Student
WHERE YearGroup = 11 AND FeesPaid = False

Logical operator	Effect
AND	Both conditions must be true
OR	At least one condition must be true
NOT	Reverses the condition

⚠️ AND narrows, OR widens. WHERE YearGroup = 10 AND YearGroup = 11 returns nothing, because no record can be in both years. If you want students in either year, you need OR.

Partial matches with LIKE

SELECT Forename, Surname
FROM Student
WHERE Surname LIKE 'W%'

Finds surnames starting with W. The % wildcard stands for any sequence of characters, so '%son' finds those ending in "son" and '%an%' those containing "an".

AQA tip. Answer questions in the order SELECT → FROM → WHERE. It is also worth reading the question to check whether it asks which fields to show or which records to find — those are different clauses, and answering the wrong one is a common way to lose an otherwise correct query.

ORDER BY sorts the results. It always comes after the WHERE clause.

SELECT Forename, Surname
FROM Student
ORDER BY Surname ASC

Keyword	Meaning	Numbers	Text	Dates
ASC	Ascending — the default if neither is stated	Smallest first	A → Z	Oldest first
DESC	Descending	Largest first	Z → A	Most recent first

With a WHERE clause

The clause order is fixed: SELECT → FROM → WHERE → ORDER BY.

SELECT Forename, Surname, YearGroup
FROM Student
WHERE FeesPaid = False
ORDER BY Surname DESC

Sorting by more than one field

SELECT Forename, Surname, YearGroup
FROM Student
ORDER BY YearGroup ASC, Surname ASC

Sorts by year group first, then within each year group by surname. The first field named is the primary sort.

Reading the question carefully

The question says	You need
"in alphabetical order"	ORDER BY Surname ASC
"reverse alphabetical order"	ORDER BY Surname DESC
"cheapest first"	ORDER BY Price ASC
"most expensive first"	ORDER BY Price DESC
"oldest student first"	ORDER BY DateOfBirth ASC (an earlier date means older)
"most recent order first"	ORDER BY OrderDate DESC

⚠️ The date traps. "Oldest person first" means the earliest date of birth, so ASC. But "oldest order first" also means the earliest date, so ASC — while "most recent first" is DESC. Work out which end of the date range is wanted rather than reacting to the word "oldest".

AQA tip. If the question does not ask for sorting, do not add ORDER BY — an unnecessary clause can introduce an error where none was needed. If it does ask, state ASC or DESC explicitly even though ASC is the default, because it shows the examiner you know which you intend.

⚠️ Exam questions will require that data is extracted from no more than two tables for any one query. So a two-table query is the most complex you will ever be asked to write.

The method

1. SELECT the fields you want, prefixing each with its table name where a name appears in both tables.
2. FROM both tables, separated by a comma.
3. WHERE — match the foreign key to the primary key. This is the join.
4. Add any further conditions with AND.

Example: list each student with their tutor's name

SELECT Student.Forename, Student.Surname, Tutor.TutorName
FROM Student, Tutor
WHERE Student.TutorID = Tutor.TutorID

Result:

Forename	Surname	TutorName
Amara	Okafor	Ms Rahman
Ben	Whitton	Mr Ellis
Chen	Liu	Ms Rahman
Dina	Petrov	Ms Rahman

Adding a further condition

SELECT Student.Surname, Tutor.Room
FROM Student, Tutor
WHERE Student.TutorID = Tutor.TutorID
AND Student.YearGroup = 10

The join condition comes first, then AND for the filter. Both are needed: the join says how the tables relate, the filter says which records to keep.

The Table.Field notation

Prefixing with the table name is essential when a field name exists in both tables — here TutorID — because otherwise it is ambiguous which is meant. It is good practice everywhere in a two-table query, and it never costs marks.

⚠️ The single biggest error: forgetting the join

-- WRONG — no join condition
SELECT Student.Surname, Tutor.TutorName
FROM Student, Tutor

Without WHERE Student.TutorID = Tutor.TutorID, the query pairs every student with every tutor: 4 students × 2 tutors = 8 meaningless rows, most of them showing the wrong tutor.

Whenever two tables appear in FROM, a matching condition must appear in WHERE.

Which field joins them?

Look for the same field name in both tables. It will be the primary key of one and a foreign key in the other. In the example, TutorID is the primary key of Tutor and a foreign key in Student — so it is the join field.

AQA tip. Write the join condition first, before anything else in the WHERE clause. Doing it in that fixed order means it never gets forgotten, which is the commonest way marks are lost on two-table questions.

The specification gives the syntax, so learn it exactly as written:

INSERT INTO table_name (column1, column2 …)
VALUES (value1, value2 …)

A worked insert

INSERT INTO Student (StudentID, Forename, Surname, YearGroup, TutorID, FeesPaid)
VALUES ('S1045', 'Ella', 'Moreau', 10, 'T11', False)

The rules

Rule	Detail
Order matters	The values must be in the same order as the columns listed
Count must match	Six columns require exactly six values
Quotes on text	'S1045', 'Ella' — but 10 and False have no quotes
Brackets required	Around both the column list and the value list
Primary key must be unique	Inserting an existing StudentID would be rejected
Foreign key must exist	'T11' must already be present in Tutor, or the insert would be rejected

Order matters — an illustration

-- WRONG: values do not match the column order
INSERT INTO Student (StudentID, Forename, Surname)
VALUES ('Ella', 'Moreau', 'S1045')

This would store "Ella" as the StudentID and "S1045" as the surname. The syntax is valid, so no error is reported — the data is simply wrong, which makes this a particularly damaging mistake.

One INSERT adds one record

Each INSERT INTO statement adds one record. Adding three students requires three statements.

AQA tip. Write the column list and the value list directly one above the other, so the correspondence can be checked at a glance. Then count both lists before moving on — a mismatch in count or order is the commonest INSERT error.

UPDATE

The specification's syntax:

UPDATE table_name
SET column1 = value1, column2 = value2 …
WHERE condition

Example — mark one student's fees as paid:

UPDATE Student
SET FeesPaid = True
WHERE StudentID = 'S1042'

Changing two fields at once — separate them with a comma:

UPDATE Student
SET YearGroup = 11, TutorID = 'T07'
WHERE StudentID = 'S1041'

Updating several records at once is normal and often intended:

UPDATE Student
SET YearGroup = 11
WHERE YearGroup = 10

This moves every Year 10 student up a year — one statement, many records changed.

DELETE

DELETE FROM table_name
WHERE condition

Example — remove one student:

DELETE FROM Student
WHERE StudentID = 'S1044'

⚠️ There is no field list. DELETE removes whole records, so DELETE Surname FROM Student is meaningless. To empty a field rather than remove a record, use UPDATE to set it to nothing.

⚠️ The most dangerous omission in SQL

Statement	Without WHERE
UPDATE Student SET YearGroup = 11	Puts every student in Year 11
DELETE FROM Student	Deletes every student record in the table

Both are valid SQL and both execute without warning. This is why every UPDATE and DELETE in an exam answer needs a WHERE clause unless the question explicitly asks to change or remove everything.

Comparing the four statement types

Task	Statement	Needs WHERE?
Retrieve data	SELECT … FROM … WHERE …	Optional — omitting it returns all records
Add a record	INSERT INTO … VALUES …	No — there is no existing record to match
Change existing data	UPDATE … SET … WHERE …	Yes, or every record changes
Remove records	DELETE FROM … WHERE …	Yes, or every record is deleted

Reading the question

The question asks you to	Statement
"list", "find", "display", "output"	SELECT
"add a new record"	INSERT INTO
"change", "amend", "correct", "increase"	UPDATE
"remove", "delete"	DELETE FROM

AQA tip. UPDATE uses SET to say what changes and WHERE to say which records — two different clauses doing two different jobs. Confusing them (UPDATE Student WHERE FeesPaid = True) is a guaranteed lost mark.