SQL Basics for Students

Spreadsheets are where many people first work with data, but organizations of any size keep their important information in databases: customers, orders, patients, students, experiments, transactions. SQL is the language for asking questions of those databases. It is one of the most durable skills in technology, appearing in job descriptions for analysts, data scientists, developers, researchers and business roles. The core of it can be learned in a few weeks of practice, and it pairs well with spreadsheet skills. This guide explains the basics in plain language.

SQL has several dialects with small differences. This guide describes core concepts that apply broadly, and you should check the documentation for the system you use. It avoids naming specific products.

What a relational database is

A relational database organizes data into tables. Each table has:

• Columns (fields): the type of information, such as name, date or price.
• Rows (records): individual entries, such as one customer or one order.
• A primary key: a column (or set of columns) that uniquely identifies each row.

Tables connect through keys. For example, an orders table may contain a customer ID that matches the ID in a customers table. These relationships let you combine information without repeating it.

Think of a student society database: a members table (ID, name, course, year), an events table (ID, title, date) and an attendance table linking member IDs to event IDs.

Reading data with SELECT

The most common SQL task is retrieving data.

SELECT name, course
FROM members;

This returns the name and course columns for every row in the members table.

To return every column, you can use an asterisk, though it is good practice to select only what you need.

SELECT *
FROM members;

Remember the structure: SELECT what you want FROM where it lives.

Filtering with WHERE

Use WHERE to return only rows that meet a condition.

SELECT name, year
FROM members
WHERE course = 'Biology';

Common operators include equals, not equals, greater than, less than, ranges, lists and pattern matching. You can combine conditions with AND, OR and NOT.

SELECT name
FROM members
WHERE course = 'Biology' AND year >= 2;

Text values go in quotes. Be careful about case sensitivity and spelling, which can differ between systems.

Sorting and limiting

Use ORDER BY to sort results, and LIMIT (or a similar keyword in some systems) to restrict the number of rows.

SELECT name, year
FROM members
ORDER BY year DESC, name ASC
LIMIT 10;

This sorts by year from highest to lowest, then by name alphabetically, and returns the first ten rows.

Summarizing with aggregate functions and GROUP BY

Aggregate functions calculate values across rows: count, sum, average, minimum and maximum.

SELECT COUNT(*) AS total_members
FROM members;

GROUP BY lets you summarize by category.

SELECT course, COUNT(*) AS members_per_course
FROM members
GROUP BY course
ORDER BY members_per_course DESC;

To filter groups after summarizing, use HAVING.

SELECT course, COUNT(*) AS members_per_course
FROM members
GROUP BY course
HAVING COUNT(*) >= 5;

A useful way to remember the difference: WHERE filters rows before grouping, and HAVING filters groups after.

Combining tables with JOIN

Joins connect tables using related columns.

SELECT members.name, events.title
FROM attendance
JOIN members ON attendance.member_id = members.id
JOIN events ON attendance.event_id = events.id;

This returns the names of members and the titles of events they attended.

Key join types:

• Inner join: only rows that match in both tables.
• Left join: all rows from the left table, plus matches from the right, with blanks where there is no match.
• Right and full joins: variations that keep unmatched rows from one or both sides.

Joins are the part of SQL that takes most practice. Draw the tables on paper and trace how rows match.

Changing data: INSERT, UPDATE and DELETE

Besides reading, SQL can modify data.

INSERT INTO members (name, course, year)
VALUES ('Alex Kim', 'Chemistry', 1);

UPDATE members
SET year = 2
WHERE name = 'Alex Kim';

DELETE FROM members
WHERE name = 'Alex Kim';

Be extremely careful. An UPDATE or DELETE without a WHERE clause affects every row. On real data, test with a SELECT using the same WHERE condition first, work on a copy and use transactions if your system supports them. Make sure you have permission and backups.

Creating tables and thinking about design

Defining tables involves choosing column names, data types and keys.

CREATE TABLE events (
  id INTEGER PRIMARY KEY,
  title TEXT NOT NULL,
  event_date DATE
);

Basic design ideas:

• One table per kind of thing: members, events, orders.
• Avoid repeating data. Store a customer's details once and link to them.
• Choose appropriate types: numbers, text, dates.
• Use primary and foreign keys to enforce relationships.
• Use clear names.
• Consider constraints such as NOT NULL and uniqueness.

Database design is a deep subject. As a beginner, focus on reading and writing queries first.

Useful extras

• Aliases: rename columns or tables for readability using AS.
• DISTINCT: return unique values.
• Pattern matching: find text that starts, ends or contains something.
• CASE expressions: create conditional columns.
• Subqueries: queries inside queries.
• Date functions: extract parts of dates and calculate differences.
• NULL handling: missing values behave differently from zero or empty text, and need special checks.
• Window functions: advanced tools for rankings and running totals, which you can learn later.

A short practice routine

Each week, write five queries about a dataset you know: a count, a filter, a grouped summary, a join and one open question. Run them, check the results by hand on a small sample and explain each in a sentence. Keep a notebook of queries that you can reuse.

Common mistakes

• Forgetting WHERE on UPDATE or DELETE.
• Confusing WHERE and HAVING.
• Joining on the wrong columns, creating duplicate or missing rows.
• Selecting columns not in GROUP BY where the system does not allow it.
• Comparing with NULL using equals.
• Case and spelling mismatches.
• Not checking row counts after a join.
• Writing very long queries without testing parts.

Build queries step by step: start with a simple SELECT, check the output, add a filter, add a join and so on.

Practice and learning resources

• Use an interactive tutorial with a built-in database.
• Use sample databases supplied with learning platforms and database systems.
• Download public datasets and load them into a local database or browser tool.
• Practice with your own data: a budget, a reading list or society records.
• Solve problems from courses and challenge sites.
• Read documentation for your system.
• Compare answers: write the same query in different ways.
• Explain queries aloud to check understanding.

Combine SQL with spreadsheets and a language such as Python or R to load, analyze and visualize results.

Ethics, privacy and safety

Databases often contain personal information.

• Only access data you are authorized to use.
• Follow data protection laws and institutional rules.
• Anonymize or aggregate when reporting.
• Don't share sensitive data in public forums or code repositories.
• Beware of SQL injection when building applications: never put user input directly into queries. Use parameterized queries or safe libraries.
• Keep credentials secure. Never commit passwords to repositories.
• Secure your accounts with strong passwords and two-factor authentication. Our digital safety section explains how.
• Respect research ethics and consent.

Careers and next steps

SQL skills support roles such as data analyst, business analyst, marketing analyst, research assistant, software developer, product analyst and operations roles. Many entry-level job descriptions mention SQL, and interviews may include a short query test.

Build a small portfolio project: design a simple database, load data, write queries that answer questions and document your findings. Next steps include learning window functions, indexes and performance, data modeling and tools for visualization.

Common mistakes to avoid when learning

• Memorizing syntax without understanding.
• Skipping practice.
• Avoiding joins.
• Working only with tiny examples.
• Ignoring documentation.
• Neglecting data privacy.

A quick checklist

• Do I understand tables, rows, columns and keys?
• Can I write SELECT, WHERE, ORDER BY and GROUP BY queries?
• Can I join two or three tables and check the results?
• Do I take care with UPDATE and DELETE?
• Am I practicing with real data and respecting privacy?

Final thoughts

SQL lets you ask precise questions of data, and the core of it is within easy reach. Learn to select, filter, sort, group and join, and practice on real examples. Be careful with changes to data, protect privacy and build up queries step by step. With a few projects, you will have a skill that employers across many fields recognize.