SQL ile Veri Analizi: Temel Sorgulardan Window Functions'a

When it comes to working as a data analyst, SQL is one of the most fundamental and most frequently used tools. Because before any analysis starts, the first job is usually to pull the data correctly from where it lives and turn it into a meaningful shape.

While learning SQL, understanding which question can be solved with which SQL structure matters more than simply writing queries. In this post I go through the most commonly used SQL structures with real-life examples.

“The power of SQL is not only in fetching data, but in being able to pull the right question out of it.”

Why Does SQL Matter in Data Analysis?

Think of a company where most of the sales, customer, product, order or social media data is kept in databases. The data analyst's job is usually to extract, from those raw records, the data that answers the business question being asked.

1. SELECT — Which Data Do We Need?

The first structure you meet in SQL is SELECT. It defines which columns you want to see in the result.

SELECT
    customer_id,
    product,
    sales
FROM orders;

You can select a single column, or take every field in the data set:

SELECT product
FROM orders;

-- All columns
SELECT *
FROM orders;

2. WHERE — Filtering the Data

WHERE is used to take only the records that satisfy a given condition.

SELECT *
FROM orders
WHERE sales > 5000;

-- More than one condition
SELECT *
FROM orders
WHERE sales > 5000
  AND category = 'Electronics';

This structure is the first step of questions such as “What happened in a given category during a given period?”.

3. GROUP BY — Splitting the Data into Groups

In analysis we usually want to compare groups rather than individual records. Total sales by category, for example:

SELECT
    category,
    SUM(sales) AS total_sales
FROM orders
GROUP BY category;

-- Unique customers by city
SELECT
    city,
    COUNT(DISTINCT customer_id) AS customer_count
FROM orders
GROUP BY city;

4. HAVING — Filtering Grouped Data

While WHERE filters records, HAVING is used to filter group results.

SELECT
    category,
    SUM(sales) AS total_sales
FROM orders
GROUP BY category
HAVING SUM(sales) > 100000;

5. JOIN — Combining Data from Different Tables

Real-life data rarely sits in a single table. Customer information, orders and product details are often kept in separate tables.

SELECT
    o.order_id,
    c.customer_name,
    o.sales
FROM orders o
INNER JOIN customers c
    ON o.customer_id = c.customer_id;

6. CASE WHEN — Classifying the Data

Turning raw numbers into meaningful categories is a common need in analysis, and CASE WHEN is very handy for it.

SELECT
    customer_id,
    sales,
    CASE
        WHEN sales >= 10000 THEN 'High'
        WHEN sales >= 5000 THEN 'Medium'
        ELSE 'Low'
    END AS sales_level
FROM orders;

The same approach can be used in customer segmentation, performance classification, risk groups or campaign segments.

7. Using Several Structures Together

The real analytical power appears when these structures are used together rather than one by one.

SELECT
    category,
    COUNT(*) AS order_count,
    SUM(sales) AS total_sales,
    AVG(sales) AS average_sales
FROM orders
WHERE order_date >= '2025-01-01'
GROUP BY category
HAVING SUM(sales) > 50000
ORDER BY total_sales DESC;

This query is not really a single command; it tells a small analytical story: pick the period, group the categories, calculate the metrics, drop the low-volume groups and sort the result.

8. Window Functions — Analysis Without Losing Rows

Window functions are one of SQL's most powerful structures for data analysis. They let you calculate extra information for every row while aggregating, without losing the rows themselves.

SELECT
    category,
    product,
    sales,
    RANK() OVER (
        PARTITION BY category
        ORDER BY sales DESC
    ) AS category_rank
FROM product_sales;

Here every category is ranked within itself, so we can answer “Which are the best-selling products of each category?”.

ROW_NUMBER()

ROW_NUMBER() OVER (
    PARTITION BY customer_id
    ORDER BY order_date DESC
) AS last_order_rank

This structure can be used to sort a customer's orders by date and find the most recent one, for example.

LAG() and LEAD()

LAG(sales) OVER (
    ORDER BY order_date
) AS previous_sales

LAG() shows the value in the previous row and LEAD() the value in the next one. They are very useful for analysing period-over-period change in time series.

9. A Real Analysis: Monthly Sales Change

Imagine we want to calculate monthly sales and compare each month with the previous one.

WITH monthly_sales AS (
    SELECT
        DATE_TRUNC('month', order_date) AS month,
        SUM(sales) AS total_sales
    FROM orders
    GROUP BY DATE_TRUNC('month', order_date)
)

SELECT
    month,
    total_sales,
    LAG(total_sales) OVER (
        ORDER BY month
    ) AS previous_month_sales
FROM monthly_sales
ORDER BY month;

This result can then be used for change rates, growth trends or dashboard KPIs.

10. Thinking Analytically in SQL

It is not enough for a data analyst to ask only “How do I write this query?”. Breaking the question into pieces matters more.

Common Mistakes When Learning SQL

The Most Used Structures in SQL

Conclusion

SQL is not only a technical skill for a data analyst; it is one of the basic ways of asking questions of data. Structures such as SELECT, WHERE, GROUP BY, HAVING, JOIN and CASE WHEN build a solid foundation, while window functions add important flexibility for more advanced analyses.

The goal while learning SQL should not be memorising hundreds of queries. It is far more valuable to take a business question, break it into small pieces and learn to solve each piece with the right SQL structure.

“Good SQL is not just a query that runs; it is a query that produces a reliable answer to the right question from the right data.”