Learn SQL.
Think like an analyst.

What is a database?

A database is an organized collection of information stored so that people and applications can find, change, and analyze it. A database is not just a file. It is managed by database software that applies rules, controls access, protects data, and answers questions.

What does RDBMS mean?

RDBMS means Relational Database Management System. “Relational” means data is organized into related tables. For example, a Customers table can be related to an Orders table through a customer ID. “Management System” means software manages storage, security, queries, relationships, and data rules for you.

Connecting to and selecting a database

Connecting to a server identifies you. Selecting a database tells MySQL which collection of tables you want to work with during the current session. These are two separate ideas.

SHOW DATABASES;

CREATE DATABASE IF NOT EXISTS sales_lab;

USE sales_lab;

SELECT DATABASE();

Line-by-line breakdown

Installation and service commands

MySQL has two important pieces: the server, which stores and processes data, and the client, such as Workbench or the terminal, which sends SQL to that server. Install the server first; Workbench is optional but helpful for a beginner because it shows databases, tables, and results visually.

Windows

1. Install MySQL Community Server using MySQL Installer.
2. Choose the Developer Default option if you want Server and Workbench together.
3. Keep port 3306, create a root password, and remember it securely.
4. Start MySQL Workbench and create a connection to 127.0.0.1.

macOS terminal installation

# Install MySQL with Homebrew
brew install mysql

# Start the MySQL server as a background service
brew services start mysql

# Stop the service when you intentionally need to
brew services stop mysql

# Check that the command-line client is available
mysql --version

Ubuntu / Debian Linux

sudo apt update
sudo apt install mysql-server
sudo systemctl enable --now mysql
sudo systemctl status mysql

Creating a database

A database is a container for tables, views, stored procedures, and permissions. Businesses often separate databases by environment or business domain, such as sales, HR, inventory, development, and production.

CREATE DATABASE IF NOT EXISTS sales_db
CHARACTER SET utf8mb4
COLLATE utf8mb4_0900_ai_ci;

Creating a table from a business entity

A table represents one type of business object or event. Before creating it, define its grain. Grain means what one row represents. In a Customers table, one row should represent one customer. In an Orders table, one row should represent one order.

CREATE TABLE customers (
  customer_id INT PRIMARY KEY AUTO_INCREMENT,
  full_name VARCHAR(100) NOT NULL,
  email VARCHAR(255) UNIQUE,
  signup_date DATE NOT NULL
);

INSERT: adding data

INSERT creates a new row. You provide values for selected columns. Explicitly listing the columns is safer than depending on the table's physical column order.

INSERT INTO customers
  (full_name, email, signup_date)
VALUES
  ('Maya Singh',
   'maya@example.com',
   '2026-01-14');

SELECT: reading data

SELECT asks MySQL to return data. It does not modify the table. Think of it as asking a precise question: “Which columns do I want, and from which table?”

SELECT customer_id, full_name, email
FROM customers;

UPDATE: changing existing data

UPDATE changes values in existing rows. The WHERE clause is the safety boundary. It identifies exactly which rows should change.

UPDATE customers
SET email = 'new@example.com'
WHERE customer_id = 42;

DELETE and TRUNCATE

DELETE removes rows. It can use WHERE to target a specific population. TRUNCATE removes every row from a table and is commonly used for temporary staging tables.

DELETE FROM customers
WHERE customer_id = 42;

TRUNCATE TABLE staging_customers;

WHERE: filtering rows

WHERE decides which source rows qualify. It is how you express business conditions such as “paid orders,” “customers from the East region,” or “transactions greater than $500.”

SELECT order_id, total_amount
FROM orders
WHERE status = 'Paid'
  AND total_amount > 500;

Aggregate functions

Aggregate functions take many input rows and produce a summary value. They are useful when the business question asks “how many,” “how much,” “what is the average,” “what is the smallest,” or “what is the largest.”

SELECT
  COUNT(*) AS order_count,
  SUM(total_amount) AS revenue,
  AVG(total_amount) AS average_order,
  MIN(total_amount) AS smallest_order,
  MAX(total_amount) AS largest_order
FROM orders;

GROUP BY: one summary per group

GROUP BY divides rows into groups. If you group by region, MySQL creates one group for East, one for West, and so on. Then aggregate functions calculate values inside each group.

SELECT
  region,
  SUM(total_amount) AS regional_revenue
FROM orders
GROUP BY region;

HAVING: filtering groups

WHERE filters individual rows before grouping. HAVING filters groups after the aggregate calculation. You cannot use WHERE to filter SUM(total_amount), because SUM does not exist until after rows are grouped.

SELECT region,
  SUM(total_amount) AS revenue
FROM orders
GROUP BY region
HAVING SUM(total_amount) > 100000;

JOINs: connecting tables

A JOIN combines rows from two tables using a related column. Customers contain customer details; Orders contain transactions. The customer ID allows a query to bring the two business perspectives together.

SELECT
  c.full_name,
  o.order_id,
  o.total_amount
FROM customers AS c
INNER JOIN orders AS o
  ON o.customer_id = c.customer_id;

Subqueries: a query inside another query

A subquery is an inner query whose result is used by an outer query. It is helpful when a business comparison depends on a value that must first be calculated from the same dataset.

SELECT order_id, total_amount
FROM orders
WHERE total_amount > (
  SELECT AVG(total_amount)
  FROM orders
);

First understand the two kinds of export

A SQL dump is a backup or migration file containing SQL instructions such as CREATE DATABASE, CREATE TABLE, and INSERT. It can recreate structure and data in another MySQL server. A CSV export is a flat text file containing rows and separators. It is excellent for Excel, Power BI, or sharing a filtered report, but it does not remember primary keys, foreign keys, data types, indexes, or relationships.

Export a complete database to a .sql file

The standard tool is mysqldump. It reads the database and writes SQL statements to a file. This is the correct choice when you want a restorable backup or need to move your development database to another machine.

# Export one database: structure and rows
mysqldump -u root -p northwind > northwind_backup.sql

# Export one table only
mysqldump -u root -p northwind orders > orders_backup.sql

# Export several named tables
mysqldump -u root -p northwind customers orders > customer_orders.sql

# Export every database on the server
mysqldump -u root -p --all-databases > all_databases.sql

Import a .sql file from the command line

Importing means sending the SQL statements inside the file to a MySQL server. For a full dump, the file may create the database and tables itself. For a dump that does not create the database, create and select the destination first.

# Import into an existing database
mysql -u root -p northwind < northwind_backup.sql

# Import a dump that contains CREATE DATABASE statements
mysql -u root -p < northwind_backup.sql

# Alternative: open the client, select a database, then run the file
mysql -u root -p
USE northwind;
SOURCE C:/backups/northwind_backup.sql;

Verify the import

SHOW DATABASES;
USE northwind;
SHOW TABLES;
SELECT COUNT(*) FROM customers;
SELECT COUNT(*) FROM orders;

Do not assume that “the import completed” means it is correct. Compare table counts, sample a few rows, and validate key relationships.

Export a query result to CSV

CSV export is perfect when a stakeholder needs the output of a specific SELECT rather than an entire database. The query below creates a file with one header row and one row per paid order.

SELECT
  'order_id', 'customer_id', 'order_date', 'total_amount'
UNION ALL
SELECT
  order_id, customer_id, order_date, total_amount
FROM orders
WHERE status = 'Paid'
INTO OUTFILE '/var/lib/mysql-files/paid_orders.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';

Import a CSV into a normal table

CSV has no schema, so create the destination table first. Then tell MySQL which separator, quote character, line ending, and column order the file uses.

CREATE TABLE imported_customers (
  customer_id INT,
  full_name VARCHAR(100),
  email VARCHAR(255),
  signup_date DATE
);

LOAD DATA LOCAL INFILE 'C:/imports/customers.csv'
INTO TABLE imported_customers
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
IGNORE 1 ROWS;

CSV import checklist

1. Confirm the CSV column order matches the table or provide a column list.
2. Check dates use a consistent format such as YYYY-MM-DD.
3. Remove currency symbols and thousands separators from numeric fields.
4. Load into a staging table first, then validate before moving to production tables.
5. Count imported rows and inspect rejected or incorrectly converted values.

Workbench import and export workflow

1. Export a full SQL dump: open Workbench, choose Server, Data Export, select the schema, choose Export to Self-Contained File, and start the export.
2. Import a SQL dump: choose Server, Data Import, select Import from Self-Contained File, choose the target schema, and start the import.
3. Export CSV: execute a SELECT, then use the result grid's export icon and choose CSV.
4. Import CSV: right-click a table, choose Table Data Import Wizard, select the CSV, map columns, preview, and execute.

Use Case 1: Top five customers by revenue

SELECT
  c.customer_id,
  c.full_name,
  SUM(o.total_amount) AS revenue
FROM customers AS c
INNER JOIN orders AS o
  ON o.customer_id = c.customer_id
WHERE o.status = 'Paid'
GROUP BY c.customer_id, c.full_name
ORDER BY revenue DESC
LIMIT 5;

Use Case 2: Monthly active users

SELECT
  DATE_FORMAT(event_time, '%Y-%m-01') AS month_start,
  COUNT(DISTINCT user_id) AS active_users
FROM user_events
WHERE event_name = 'login'
GROUP BY month_start
ORDER BY month_start;

Use Case 3: Identify missing data

-- Missing email addresses
SELECT customer_id, full_name
FROM customers
WHERE email IS NULL;

-- Customers without an order
SELECT c.customer_id, c.full_name
FROM customers AS c
LEFT JOIN orders AS o
  ON o.customer_id = c.customer_id
WHERE o.order_id IS NULL;

A strong BA does not stop at “there are 500 missing records.” You should identify the source process, business owner, defect severity, correction plan, and trend over time.

Deep Practice Studio: translate a stakeholder request

Step 1 — clarify the request before writing SQL

• Grain: one output row per customer.
• Measure: SUM of order revenue, not a count of orders.
• Time rule: order_date is greater than or equal to 90 days ago.
• Population: all customers, including those with no qualifying order.
• Business decision: high-value customers and retention follow-up.

Step 2 — build the query in layers

SELECT
    c.customer_id,
    CONCAT(c.first_name, ' ', c.last_name) AS customer_name,
    COALESCE(SUM(o.quantity * p.unit_price), 0) AS recent_revenue
FROM customers c
LEFT JOIN orders o
    ON o.customer_id = c.customer_id
   AND o.order_date >= DATE_SUB(CURDATE(), INTERVAL 90 DAY)
LEFT JOIN products p
    ON p.product_id = o.product_id
GROUP BY c.customer_id, c.first_name, c.last_name
ORDER BY recent_revenue DESC;