40 SQL Interview Questions &

Solutions for DBAs

Asfaw Gedamu

July 2, 2025
40 SQL Interview Questions & Solutions For
DBAs
Your interviewer has 30 minutes. Your mission: write queries that show you can reason in data.
Not just recite syntax.

I pulled together 40 real-world SQL challenges that cover the exact patterns hiring managers
probe for:

Retention & Churn: month-over-month customer stickiness, six-month “silent” customers,

moving averages, and more

Salary & Rank Logic: second-highest salary, department pay gaps, in-department ranking
with RANK()

Revenue Analytics : Pareto 80 percent products, product-level revenue share, YoY growth

Window Magic: rolling 3-day sales, 90th-percentile spenders, consecutive-day purchases

Everyday Ops: duplicate detection, unsold products, employees hired on weekends

Now to the questions:

1. Calculate customer retention rate month-over-month

Input (Orders):

| customer_id | order_date |
|-------------|------------|
| 101 | 2023-01-15 |
| 101 | 2023-02-20 |
| 102 | 2023-01-10 |
| 103 | 2023-02-05 |
| 101 | 2023-03-01 |

Statement:

WITH monthly_customers AS (
SELECT DISTINCT
customer_id,
FORMAT(order_date, 'yyyy-MM') AS month
FROM Orders
),
retention AS (
SELECT m1.month,
COUNT(DISTINCT m1.customer_id) AS current_customers,
COUNT(DISTINCT m2.customer_id) AS retained_customers
FROM monthly_customers m1
LEFT JOIN monthly_customers m2 ON m1.customer_id = m2.customer_id
AND m2.month = DATEADD(MONTH, 1,
m1.month)
GROUP BY m1.month
)
SELECT month,
current_customers,
retained_customers,
ROUND(100.0 * retained_customers / NULLIF(current_customers,
0), 2) AS retention_rate
FROM retention
ORDER BY month;

Output:

| month | current_customers | retained_customers | retention_rate |

|---------|-------------------|--------------------|----------------|
| 2023-01 | 2 | 1 | 50.00 |
| 2023-02 | 2 | 1 | 50.00 |
| 2023-03 | 1 | 0 | 0.00 |

2. Retrieve the second highest salary from the Employee

table
Input (Employee):

| emp_id | name | salary |

|--------|--------|--------|
| 1 | Alice | 90000 |
| 2 | Bob | 75000 |
| 3 | Carol | 90000 |
| 4 | Dave | 60000 |
Statement:

SELECT MAX(salary) AS SecondHighestSalary

FROM Employee
WHERE salary < (SELECT MAX(salary) FROM Employee);

Output:

| SecondHighestSalary |
|---------------------|
| 75000 |

3. Find employees without department (Left Join usage)

Input (Employee):

| emp_id | name | department_id |

|--------|--------|---------------|
| 1 | Alice | 101 |
| 2 | Bob | NULL |
| 3 | Carol | 102 |
| 4 | Dave | NULL |

Input (Department):

| department_id | dept_name |
|---------------|-----------|
| 101 | Sales |
| 102 | Marketing |

Statement:

SELECT e.*
FROM Employee e
LEFT JOIN Department d ON e.department_id = d.department_id
WHERE d.department_id IS NULL;

Output:

| emp_id | name | department_id |

|--------|------|---------------|
| 2 | Bob | NULL |
| 4 | Dave | NULL |

4. Calculate the total revenue per product

| product_id | quantity | price |
|------------|----------|-------|
| 101 | 2 | 50 |
| 102 | 1 | 100 |
| 101 | 3 | 50 |
| 103 | 5 | 20 |

Statement:

SELECT product_id, SUM(quantity * price) AS total_revenue

FROM Sales
GROUP BY product_id;

Input (Sales):

Output:

| product_id | total_revenue |
|------------|---------------|
| 101 | 250 |
| 102 | 100 |
| 103 | 100 |

5. Get the top 3 highest-paid employees

Input (Employee):

| emp_id | name | salary |

|--------|--------|--------|
| 1 | Alice | 90000 |
| 2 | Bob | 75000 |
| 3 | Carol | 85000 |
| 4 | Dave | 60000 |

Statement:

SELECT TOP 3 *
FROM Employee
ORDER BY salary DESC;

Output:

| emp_id | name | salary |

|--------|-------|--------|
| 1 | Alice | 90000 |
| 3 | Carol | 85000 |
| 2 | Bob | 75000 |

6. Customers who made purchases but never returned

products
Input (Customers):

| customer_id | name |
|-------------|--------|
| 101 | Alice |
| 102 | Bob |
| 103 | Carol |

Input (Orders):

| order_id | customer_id |
|----------|-------------|
| 1 | 101 |
| 2 | 102 |
| 3 | 103 |

Input (Returns):

| return_id | customer_id |
|-----------|-------------|
| 1 | 101 |

Statement:

SELECT DISTINCT c.customer_id

FROM Customers c
JOIN Orders o ON c.customer_id = o.customer_id
WHERE c.customer_id NOT IN (SELECT customer_id FROM Returns);
Output:

| customer_id |
|-------------|
| 102 |
| 103 |

7. Show the count of orders per customer

Input (Orders):

| order_id | customer_id |
|----------|-------------|
| 1 | 101 |
| 2 | 101 |
| 3 | 102 |
| 4 | 101 |
| 5 | 103 |

Statement:

SELECT customer_id, COUNT(*) AS order_count

FROM Orders
GROUP BY customer_id;

Output:

| customer_id | order_count |
|-------------|-------------|
| 101 | 3 |
| 102 | 1 |
| 103 | 1 |

8. Retrieve all employees who joined in 2023

Input (Employee):

| emp_id | name | hire_date |

|--------|--------|------------|
| 1 | Alice | 2023-01-15 |
| 2 | Bob | 2022-11-20 |
| 3 | Carol | 2023-03-10 |
| 4 | Dave | 2021-05-05 |
Statement:

SELECT *
FROM Employee
WHERE YEAR(hire_date) = 2023;

Output:

| emp_id | name | hire_date |

|--------|-------|------------|
| 1 | Alice | 2023-01-15 |
| 3 | Carol | 2023-03-10 |

9. Calculate the average order value per customer

Input (Orders):

| order_id | customer_id | total_amount |

|----------|-------------|--------------|
| 1 | 101 | 100 |
| 2 | 101 | 150 |
| 3 | 102 | 75 |
| 4 | 101 | 200 |

Statement:

SELECT customer_id, AVG(total_amount) AS avg_order_value

FROM Orders
GROUP BY customer_id;

Output:

| customer_id | avg_order_value |
|-------------|-----------------|
| 101 | 150 |
| 102 | 75 |

10. Get the latest order placed by each customer

Input (Orders):
| order_id | customer_id | order_date |
|----------|-------------|------------|
| 1 | 101 | 2023-01-15 |
| 2 | 101 | 2023-02-20 |
| 3 | 102 | 2023-01-10 |
| 4 | 101 | 2023-03-05 |

Statement:

SELECT customer_id, MAX(order_date) AS latest_order_date

FROM Orders
GROUP BY customer_id;

Output:

| customer_id | latest_order_date |
|-------------|-------------------|
| 101 | 2023-03-05 |
| 102 | 2023-01-10 |

11. Find products that were never sold

Input (Products):

| product_id | product_name |
|------------|--------------|
| 101 | Laptop |
| 102 | Phone |
| 103 | Tablet |
| 104 | Monitor |

Input (Sales):

| sale_id | product_id | quantity |

|---------|------------|----------|
| 1 | 101 | 2 |
| 2 | 102 | 1 |
| 3 | 101 | 3 |

Statement:

SELECT p.product_id
FROM Products p
LEFT JOIN Sales s ON p.product_id = s.product_id
WHERE s.product_id IS NULL;

Output:

| product_id |
|------------|
| 103 |
| 104 |

12. Identify the most selling product

Input (Sales):

| sale_id | product_id | quantity |

|---------|------------|----------|
| 1 | 101 | 2 |
| 2 | 102 | 1 |
| 3 | 101 | 3 |
| 4 | 103 | 5 |
| 5 | 102 | 2 |

Statement:

SELECT TOP 1 product_id, SUM(quantity) AS total_qty

FROM Sales
GROUP BY product_id
ORDER BY total_qty DESC;

Output:

| product_id | total_qty |
|------------|-----------|
| 101 | 5 |

13. Get the total revenue and the number of orders per
region
Input (Orders):

| order_id | region | total_amount |

|----------|--------|--------------|
| 1 | East | 100 |
| 2 | West | 150 |
| 3 | East | 200 |
| 4 | North | 75 |
| 5 | East | 125 |

Statement:

SELECT region,
SUM(total_amount) AS total_revenue,
COUNT(*) AS order_count
FROM Orders
GROUP BY region;

Output:

| region | total_revenue | order_count |

|--------|---------------|-------------|
| East | 425 | 3 |
| West | 150 | 1 |
| North | 75 | 1 |

14. Count how many customers placed more than 5 orders

Input (Orders):

| order_id | customer_id |
|----------|-------------|
| 1 | 101 |
| 2 | 101 |
| 3 | 101 |
| 4 | 101 |
| 5 | 101 |
| 6 | 101 |
| 7 | 102 |
| 8 | 102 |
| 9 | 103 |

Statement:

SELECT COUNT(*) AS customer_count

FROM (
SELECT customer_id FROM Orders
GROUP BY customer_id
HAVING COUNT(*) > 5
) AS subquery;

Output:

| customer_count |
|----------------|
| 1 |

15. Retrieve customers with orders above the average order

value
Input (Orders):

| order_id | customer_id | total_amount |

|----------|-------------|--------------|
| 1 | 101 | 100 |
| 2 | 102 | 200 |
| 3 | 103 | 150 |
| 4 | 104 | 50 |
| 5 | 105 | 250 |

Statement:

SELECT *
FROM Orders
WHERE total_amount > (SELECT AVG(total_amount) FROM Orders);

Output:

| order_id | customer_id | total_amount |

|----------|-------------|--------------|
| 2 | 102 | 200 |
| 3 | 103 | 150 |
| 5 | 105 | 250 |

16. Find all employees hired on weekends

Input (Employee):

| emp_id | name | hire_date |

|--------|--------|------------|
| 1 | Alice | 2023-01-14 | -- Saturday
| 2 | Bob | 2023-01-16 | -- Monday
| 3 | Carol | 2023-01-15 | -- Sunday
| 4 | Dave | 2023-01-17 | -- Tuesday

Statement:

SELECT *
FROM Employee
WHERE DATENAME(WEEKDAY, hire_date) IN ('Saturday', 'Sunday');

Output:

| emp_id | name | hire_date |

|--------|-------|------------|
| 1 | Alice | 2023-01-14 |
| 3 | Carol | 2023-01-15 |

17. Find employees with salaries between $50,000 and

$100,000
Input (Employee):

| emp_id | name | salary |

|--------|--------|--------|
| 1 | Alice | 90000 |
| 2 | Bob | 45000 |
| 3 | Carol | 75000 |
| 4 | Dave | 110000 |

Statement:

SELECT *
FROM Employee
WHERE salary BETWEEN 50000 AND 100000;

Output:

| emp_id | name | salary |

|--------|-------|--------|
| 1 | Alice | 90000 |
| 3 | Carol | 75000 |
18. Get monthly sales revenue and order count
Input (Orders):

| order_id | date | amount |

|----------|------------|--------|
| 1 | 2023-01-15 | 100 |
| 2 | 2023-01-20 | 150 |
| 3 | 2023-02-05 | 200 |
| 4 | 2023-02-10 | 75 |
| 5 | 2023-03-01 | 125 |

Statement:

SELECT FORMAT(date, 'yyyy-MM') AS month,

SUM(amount) AS total_revenue,
COUNT(order_id) AS order_count
FROM Orders
GROUP BY FORMAT(date, 'yyyy-MM');

Output:

| month | total_revenue | order_count |

|---------|---------------|-------------|
| 2023-01 | 250 | 2 |
| 2023-02 | 275 | 2 |
| 2023-03 | 125 | 1 |

19. Rank employees by salary within each department

Input (Employee):

| employee_id | department_id | salary |

|-------------|---------------|--------|
| 1 | 101 | 90000 |
| 2 | 101 | 85000 |
| 3 | 102 | 95000 |
| 4 | 101 | 90000 |
| 5 | 102 | 80000 |

Statement:

SELECT employee_id, department_id, salary,

 RANK() OVER (PARTITION BY department_id ORDER BY salary DESC)
AS salary_rk
FROM Employee;

Output:

| employee_id | department_id | salary | salary_rk |

|-------------|---------------|--------|-----------|
| 1 | 101 | 90000 | 1 |
| 4 | 101 | 90000 | 1 |
| 2 | 101 | 85000 | 3 |
| 3 | 102 | 95000 | 1 |
| 5 | 102 | 80000 | 2 |

20. Find customers who placed orders every month in 2023

Input (Orders):

| order_id | customer_id | order_date |

|----------|-------------|------------|
| 1 | 101 | 2023-01-15 |
| 2 | 101 | 2023-02-20 |
| 3 | 101 | 2023-03-05 |
| ... | ... | ... |
| 13 | 101 | 2023-12-10 |
| 14 | 102 | 2023-01-10 |
| 15 | 102 | 2023-02-15 |

Statement:

SELECT customer_id
FROM Orders
WHERE YEAR(order_date) = 2023
GROUP BY customer_id
HAVING COUNT(DISTINCT FORMAT(order_date,'yyyy-MM')) = 12;

Output:

| customer_id |
|-------------|
| 101 |
21. Find moving average of sales over the last 3 days
Input (Orders):

| order_id | order_date | total_amount |

|----------|------------|--------------|
| 1 | 2023-01-01 | 100 |
| 2 | 2023-01-02 | 150 |
| 3 | 2023-01-03 | 200 |
| 4 | 2023-01-04 | 175 |
| 5 | 2023-01-05 | 125 |

Statement:

SELECT order_date,
AVG(total_amount) OVER (ORDER BY order_date ROWS BETWEEN 2
PRECEDING AND CURRENT ROW) AS moving_avg
FROM Orders;

Output:

| order_date | moving_avg |
|------------|------------|
| 2023-01-01 | 100.00 |
| 2023-01-02 | 125.00 |
| 2023-01-03 | 150.00 |
| 2023-01-04 | 175.00 |
| 2023-01-05 | 166.67 |

22. Identify the first and last order date for each customer
Input (Orders):

| order_id | customer_id | order_date |

|----------|-------------|------------|
| 1 | 101 | 2023-01-15 |
| 2 | 101 | 2023-03-20 |
| 3 | 102 | 2023-02-10 |
| 4 | 101 | 2023-05-05 |
| 5 | 103 | 2023-04-01 |

Statement:
SELECT customer_id,
MIN(order_date) AS first_order,
MAX(order_date) AS last_order
FROM Orders
GROUP BY customer_id;

Output:

| customer_id | first_order | last_order |

|-------------|-------------|-------------|
| 101 | 2023-01-15 | 2023-05-05 |
| 102 | 2023-02-10 | 2023-02-10 |
| 103 | 2023-04-01 | 2023-04-01 |

23. Show product sales distribution (percent of total

revenue)
Input (Sales):

| product_id | quantity | price |

|------------|----------|-------|
| 101 | 2 | 50 |
| 102 | 1 | 100 |
| 101 | 3 | 50 |
| 103 | 5 | 20 |

Statement:

WITH TotalRevenue AS (
SELECT SUM(quantity * price) AS total
FROM Sales
)
SELECT s.product_id,
SUM(s.quantity * s.price) AS revenue,
SUM(s.quantity * s.price) * 100 / t.total AS revenue_pct
FROM Sales s
CROSS JOIN TotalRevenue t
GROUP BY s.product_id, t.total;

Output:

| product_id | revenue | revenue_pct |

|------------|---------|-------------|
| 101 | 250 | 55.56 |
| 102 | 100 | 22.22 |
| 103 | 100 | 22.22 |

24. Retrieve customers who made consecutive purchases (2

Days)
Input (Orders):

| id | order_date |
|----|------------|
| 101| 2023-01-01 |
| 101| 2023-01-02 |
| 101| 2023-01-04 |
| 102| 2023-01-10 |
| 102| 2023-01-11 |
| 103| 2023-01-15 |

Statement:

WITH cte AS (
SELECT id, order_date,
LAG(order_date) OVER (PARTITION BY id ORDER BY order_date)
AS prev_order_date
FROM Orders
)
SELECT id, order_date, prev_order_date
FROM cte
WHERE DATEDIFF(DAY, prev_order_date, order_date) = 1;

Output:

| id | order_date | prev_order_date |
|-----|------------|-----------------|
| 101 | 2023-01-02 | 2023-01-01 |
| 102 | 2023-01-11 | 2023-01-10 |

25. Find churned customers (no orders in the last 6 months)

Input (Orders) - Assuming current date is 2023-07-01:
| customer_id | order_date |
|-------------|------------|
| 101 | 2022-12-15 |
| 101 | 2023-01-20 |
| 102 | 2023-06-15 |
| 103 | 2022-10-10 |

Statement:

SELECT customer_id
FROM Orders
GROUP BY customer_id
HAVING MAX(order_date) < DATEADD(MONTH, -6, GETDATE());

Output:

| customer_id |
|-------------|
| 103 |

26. Calculate cumulative revenue by day

Input (Orders):

| order_date | total_amount |
|------------|--------------|
| 2023-01-01 | 100 |
| 2023-01-02 | 150 |
| 2023-01-03 | 200 |
| 2023-01-05 | 175 |

Statement:

SELECT order_date,
SUM(total_amount) OVER (ORDER BY order_date) AS
cumulative_revenue
FROM Orders;

Output:

| order_date | cumulative_revenue |
|------------|--------------------|
| 2023-01-01 | 100 |
| 2023-01-02 | 250 |
| 2023-01-03 | 450 |
| 2023-01-05 | 625 |

27. Identify top-performing departments by average salary

Input (Employee):

| emp_id | department_id | salary |

|--------|---------------|--------|
| 1 | 101 | 90000 |
| 2 | 101 | 85000 |
| 3 | 102 | 75000 |
| 4 | 102 | 80000 |
| 5 | 103 | 95000 |

Statement:

SELECT department_id,
AVG(salary) AS avg_salary
FROM Employee
GROUP BY department_id
ORDER BY avg_salary DESC;

Output:

| department_id | avg_salary |
|---------------|------------|
| 103 | 95000 |
| 101 | 87500 |
| 102 | 77500 |

28. Find customers who ordered more than the average

number of orders per customer
Input (Orders):

| order_id | customer_id |
|----------|-------------|
| 1 | 101 |
| 2 | 101 |
| 3 | 101 |
| 4 | 102 |
| 5 | 102 |
| 6 | 103 |

Statement:

WITH customer_orders AS (
SELECT customer_id, COUNT(*) AS order_count
FROM Orders
GROUP BY customer_id
)
SELECT * FROM customer_orders
WHERE order_count > (SELECT AVG(order_count) FROM customer_orders);

Output:

| customer_id | order_count |
|-------------|-------------|
| 101 | 3 |

29. Calculate revenue generated from new customers (first-

time orders)
Input (Orders):

| customer_id | order_date | total_amount |

|-------------|------------|--------------|
| 101 | 2023-01-15 | 100 |
| 101 | 2023-02-20 | 150 |
| 102 | 2023-01-10 | 200 |
| 103 | 2023-03-01 | 175 |

Statement:

WITH first_orders AS (
SELECT customer_id, MIN(order_date) AS first_order_date
FROM Orders
GROUP BY customer_id
)
SELECT SUM(o.total_amount) AS new_revenue
FROM Orders o
JOIN first_orders f ON o.customer_id = f.customer_id
WHERE o.order_date = f.first_order_date;

Output:

| new_revenue |
|-------------|
| 475 |

30. Find the percentage of employees in each department

Input (Employee):

| emp_id | department_id |
|--------|---------------|
| 1 | 101 |
| 2 | 101 |
| 3 | 102 |
| 4 | 103 |
| 5 | 103 |
| 6 | 103 |

Statement:

SELECT department_id,
COUNT(*) AS emp_count,
COUNT(*) * 100.0 / (SELECT COUNT(*) FROM Employee) AS pct
FROM Employee
GROUP BY department_id;

Output:

| department_id | emp_count | pct |

|---------------|-----------|-------|
| 101 | 2 | 33.33 |
| 102 | 1 | 16.67 |
| 103 | 3 | 50.00 |

31. Retrieve the maximum salary difference within each

department
Input (Employee):
| emp_id | department_id | salary |
|--------|---------------|--------|
| 1 | 101 | 90000 |
| 2 | 101 | 75000 |
| 3 | 102 | 85000 |
| 4 | 102 | 82000 |
| 5 | 103 | 95000 |

Statement:

SELECT department_id,
MAX(salary) - MIN(salary) AS salary_diff
FROM Employee
GROUP BY department_id;

Output:

| department_id | salary_diff |
|---------------|-------------|
| 101 | 15000 |
| 102 | 3000 |
| 103 | 0 |

32. Find products that contribute to 80% of revenue (Pareto

Principle)
Input (Sales):

| product_id | quantity | price |

|------------|----------|-------|
| 101 | 10 | 100 |
| 102 | 5 | 200 |
| 103 | 20 | 50 |
| 104 | 8 | 75 |

Statement:

WITH sales_cte AS (
SELECT product_id, SUM(quantity * price) AS revenue
FROM Sales GROUP BY product_id
),
total_revenue AS (
SELECT SUM(revenue) AS total FROM sales_cte
)
SELECT s.product_id, s.revenue,
SUM(s.revenue) OVER (ORDER BY s.revenue DESC
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS
running_total
FROM sales_cte s, total_revenue t
WHERE SUM(s.revenue) OVER (ORDER BY s.revenue DESC
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) <= t.total *
0.8;

Output:

| product_id | revenue | running_total |

|------------|---------|---------------|
| 101 | 1000 | 1000 |
| 102 | 1000 | 2000 |

33. Calculate average time between purchases for each

customer
Input (Orders):

| customer_id | order_date |
|-------------|------------|
| 101 | 2023-01-01 |
| 101 | 2023-01-10 |
| 101 | 2023-01-25 |
| 102 | 2023-02-05 |
| 102 | 2023-02-20 |

Statement:

WITH cte AS (
SELECT customer_id, order_date,
LAG(order_date) OVER (PARTITION BY customer_id ORDER BY
order_date) AS prev_date
FROM Orders
)
SELECT customer_id,
AVG(DATEDIFF(DAY, prev_date, order_date)) AS avg_gap_days
FROM cte
WHERE prev_date IS NOT NULL
GROUP BY customer_id;

Output:

| customer_id | avg_gap_days |
|-------------|--------------|
| 101 | 12.0 |
| 102 | 15.0 |

34. Show last purchase for each customer with order amount
Input (Orders):

| customer_id | order_id | total_amount | order_date |

|-------------|----------|--------------|------------|
| 101 | 1001 | 150 | 2023-01-15 |
| 101 | 1002 | 200 | 2023-02-20 |
| 102 | 1003 | 175 | 2023-01-10 |
| 101 | 1004 | 125 | 2023-03-05 |

Statement:

WITH ranked_orders AS (
SELECT customer_id, order_id, total_amount,
ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY
order_date DESC) AS rn
FROM Orders
)
SELECT customer_id, order_id, total_amount
FROM ranked_orders
WHERE rn = 1;

Output:

| customer_id | order_id | total_amount |

|-------------|----------|--------------|
| 101 | 1004 | 125 |
| 102 | 1003 | 175 |

35. Calculate year-over-year growth in revenue

Input (Orders):

| order_date | total_amount |
|------------|--------------|
| 2021-01-15 | 1000 |
| 2021-02-20 | 1500 |
| 2022-01-10 | 2000 |
| 2022-03-05 | 2500 |
| 2023-02-01 | 3000 |

Statement:

SELECT FORMAT(order_date, 'yyyy') AS year,

SUM(total_amount) AS revenue,
SUM(total_amount) - LAG(SUM(total_amount)) OVER (ORDER BY
FORMAT(order_date, 'yyyy')) AS yoy_growth
FROM Orders
GROUP BY FORMAT(order_date, 'yyyy');

Output:

| year | revenue | yoy_growth |

|------|---------|------------|
| 2021 | 2500 | NULL |
| 2022 | 4500 | 2000 |
| 2023 | 3000 | -1500 |

36. Detect customers with purchases above their 90th

percentile
Input (Orders):

| customer_id | order_id | total_amount |

|-------------|----------|--------------|
| 101 | 1001 | 100 |
| 101 | 1002 | 200 |
| 101 | 1003 | 150 |
| 101 | 1004 | 500 |
| 102 | 1005 | 300 |

Statement:

WITH ranked_orders AS (
 SELECT customer_id, order_id, total_amount,
NTILE(10) OVER (PARTITION BY customer_id ORDER BY
total_amount) AS decile
FROM Orders
)
SELECT customer_id, order_id, total_amount
FROM ranked_orders
WHERE decile = 10;

Output:

| customer_id | order_id | total_amount |

|-------------|----------|--------------|
| 101 | 1004 | 500 |
| 102 | 1005 | 300 |

37. Retrieve longest gap between orders for each customer

Input (Orders):

| customer_id | order_date |
|-------------|------------|
| 101 | 2023-01-01 |
| 101 | 2023-01-10 |
| 101 | 2023-02-15 |
| 102 | 2023-01-05 |
| 102 | 2023-03-01 |

Statement:

WITH cte AS (
SELECT customer_id, order_date,
LAG(order_date) OVER (PARTITION BY customer_id ORDER BY
order_date) AS prev_order_date
FROM Orders
)
SELECT customer_id, MAX(DATEDIFF(DAY, prev_order_date, order_date)) AS
max_gap
FROM cte
WHERE prev_order_date IS NOT NULL
GROUP BY customer_id;
Output:

| customer_id | max_gap |
|-------------|---------|
| 101 | 36 |
| 102 | 55 |

38. Identify customers with revenue below 10th percentile

Input (Orders):

| customer_id | total_amount |
|-------------|--------------|
| 101 | 100 |
| 101 | 200 |
| 102 | 50 |
| 103 | 300 |
| 104 | 75 |

Statement:

WITH cte AS (
SELECT customer_id, SUM(total_amount) AS total_revenue
FROM Orders
GROUP BY customer_id
)
SELECT customer_id, total_revenue
FROM cte
WHERE total_revenue < (SELECT PERCENTILE_CONT(0.1) WITHIN GROUP (ORDER
BY total_revenue) FROM cte);

Output:

| customer_id | total_revenue |
|-------------|---------------|
| 102 | 50 |
| 104 | 75 |

39. Find employees with salary above department average

Input (Employee):

| employee_id | department_id | salary |

|-------------|---------------|--------|
| 1 | 101 | 90000 |
| 2 | 101 | 85000 |
| 3 | 102 | 95000 |
| 4 | 101 | 80000 |
| 5 | 102 | 90000 |

Statement:

WITH dept_avg AS (
SELECT department_id, AVG(salary) AS avg_salary
FROM Employee
GROUP BY department_id
)
SELECT e.employee_id, e.department_id, e.salary, d.avg_salary
FROM Employee e
JOIN dept_avg d ON e.department_id = d.department_id
WHERE e.salary > d.avg_salary;

Output:

| employee_id | department_id | salary | avg_salary |

|-------------|---------------|--------|------------|
| 1 | 101 | 90000 | 85000 |
| 3 | 102 | 95000 | 92500 |

40. Find duplicate records in a table

Input (your_table):

| column1 | column2 |
|---------|---------|
| John | Doe |
| Jane | Smith |
| John | Doe |
| Mike | Johnson |
| Jane | Smith |
Statement:

SELECT column1, column2, COUNT(*)

FROM your_table
GROUP BY column1, column2
HAVING COUNT(*) > 1;

Output:

| column1 | column2 | COUNT(*) |

|---------|---------|----------|
| John | Doe | 2 |
| Jane | Smith | 2 |

Conclusion
These questions cover advanced analytical scenarios including statistical calculations
(percentiles), time-based analysis (retention rates), and complex business metrics (Pareto
principle). Each solution demonstrates practical applications of window functions, CTEs, and
advanced joins that are essential for data analysis roles.