SQL for Beginners: Learn to Query a Database With Real Examples

Every app you use stores data somewhere: your orders, your messages, your bank transactions. Most of it sits in a database, and SQL (Structured Query Language, often said "sequel") is how you ask it questions.

SQL has been around for decades and is still asked about in analyst, developer and data interviews. It is also easier than it looks. A handful of commands covers most real work.

A relational database stores data in tables. Each table has columns (the fields) and rows (the records).

We'll use a small shop with two tables.

customers

orders

customer_id is a primary key in customers (unique per row) and a foreign key in orders (it points to a customer).

You can follow along in a free tool like SQLite or an online SQL playground by creating these tables.

SELECT name, cityFROM customers;

This returns the name and city of every customer. To get all columns:

SELECT *FROM customers;

SELECT * is handy while exploring, but in real work, list the columns you need.

SELECT nameFROM customersWHERE city = 'Chennai';

Result: Asha and Meena.

You can combine conditions:

SELECT *FROM ordersWHERE amount > 500 AND order_date >= '2026-09-01';

Useful operators:

• =, <> (not equal), <, >, <=, >=
• AND, OR, NOT
• IN ('Chennai', 'Pune')
• BETWEEN 100 AND 1000
• LIKE 'A%' (starts with A)
• IS NULL, IS NOT NULL (use these for missing values, not = NULL)

SELECT *FROM ordersORDER BY amount DESCLIMIT 3;

This returns the three largest orders. ASC is the default order, DESC is descending.

Aggregate functions summarise many rows into one value:

SELECT COUNT(*) AS total_orders,       SUM(amount) AS total_sales,       AVG(amount) AS average_orderFROM orders;

Common ones: COUNT, SUM, AVG, MIN, MAX. AS gives a column a readable name.

To see totals per customer:

SELECT customer_id,       COUNT(*) AS orders,       SUM(amount) AS total_spentFROM ordersGROUP BY customer_id;

Result:

Rule: every column in SELECT must either be in GROUP BY or inside an aggregate function.

WHERE filters rows before grouping. HAVING filters groups after:

SELECT customer_id, SUM(amount) AS total_spentFROM ordersGROUP BY customer_idHAVING SUM(amount) > 1000;

The orders table shows only customer_id. To show names, join the tables on the key:

SELECT c.name, o.order_id, o.amountFROM orders AS oJOIN customers AS c  ON o.customer_id = c.customer_id;

This is an INNER JOIN. It returns only rows that match in both tables.

Which customers have no orders? Use a LEFT JOIN, which keeps all rows from the left table:

SELECT c.name, o.order_idFROM customers AS cLEFT JOIN orders AS o  ON c.customer_id = o.customer_idWHERE o.order_id IS NULL;

Result: Kiran.

A quick guide:

• INNER JOIN: only matching rows
• LEFT JOIN: all rows from the left table, matches from the right (or NULL)
• RIGHT JOIN and FULL JOIN exist but are less common

Total spend per customer, with names, highest first:

SELECT c.name,       COUNT(o.order_id) AS orders,       SUM(o.amount) AS total_spentFROM customers AS cJOIN orders AS o  ON c.customer_id = o.customer_idGROUP BY c.nameORDER BY total_spent DESC;

Read it in the order the database runs it: FROM and JOIN pick the data, WHERE filters rows, GROUP BY groups, HAVING filters groups, SELECT chooses columns, ORDER BY sorts, LIMIT trims.

A query inside a query:

SELECT nameFROM customersWHERE customer_id IN (  SELECT customer_id  FROM orders  WHERE amount > 1000);

This returns customers who have at least one order above 1,000. As you gain confidence, you can also use CTEs (WITH clauses) to make long queries easier to read.

These functions differ between databases (SQLite, MySQL, PostgreSQL, SQL Server), so check yours:

• Extract a month from a date
• Concatenate strings
• Convert text to upper case
• Date differences

For example, in PostgreSQL: DATE_TRUNC('month', order_date). In SQLite: strftime('%Y-%m', order_date).

SQL also changes data. Be careful.

INSERT INTO customers (customer_id, name, city)VALUES (5, 'Divya', 'Bengaluru');UPDATE customersSET city = 'Mumbai'WHERE customer_id = 2;DELETE FROM ordersWHERE order_id = 105;

Always use WHERE with UPDATE and DELETE. Without it, they affect every row. Test with a SELECT first, and never experiment on a live production database.

• Forgetting WHERE on an update or delete
• Using = NULL instead of IS NULL
• Joining on the wrong column and getting duplicates
• Mixing up WHERE and HAVING
• Selecting columns not in GROUP BY
• Not checking the number of rows before and after a join

When a query returns something unexpected, debug in small steps: run the pieces separately. See how to debug any bug.

1. Install SQLite or use an online playground.
2. Create your own small tables from something you know: expenses, a cricket tournament, a reading list.
3. Use public datasets and practice sites such as SQLBolt, Mode's SQL tutorial, W3Schools SQL, HackerRank SQL and LeetCode database problems.
4. Write the query yourself, then check against the answer.
5. Explain queries aloud or in writing. See writing in public.
6. Review key patterns with flashcards. See spaced repetition.

• Data analyst work: see the data analyst roadmap.
• Python: connect to databases and run queries. See Python roadmap.
• Web apps: backends use databases. See how a website works.
• Cloud: managed databases are a core cloud service. See cloud computing explained.

AI tools can write SQL, but you must understand what it does. Check results on small examples. See using AI at work.

It is a query language for databases. It is declarative: you describe what you want, not how to get it.

Any. SQLite is easy to start with, and PostgreSQL and MySQL are widely used. The basics are the same.

The basics take a few weeks of practice. Writing efficient, complex queries takes months.

Yes. Data still lives in databases, and people who understand SQL can check what AI-generated queries do.

SQL databases use tables and a fixed schema. NoSQL databases use other models, such as documents or key-value pairs. Start with SQL.

Syntax varies slightly between database systems. Check the documentation for the one you use.