Channel Public Channel

SQL Programming Resources

@sqlanalyst

Find top SQL resources from global universities, cool projects, and learning materials for data analytics.

Admin: @coderfun

Useful links: heylink.me/DataAnalytics

Promotions: @love_data

Open in Telegram

Subscribers: 76.7K
Photos: 599
Videos: 1
Links: 569

Showing posts older than #2288 · Back to latest

Older Posts 20 shown

Post #2287 2.78K Feb 5, 2026, 07:17 UTC

❤ 3

Post #2286 3.54K Feb 4, 2026, 21:04 UTC

Here are some commonly asked SQL interview questions along with brief answers:

1. What is SQL?
- SQL stands for Structured Query Language, used for managing and manipulating relational databases.

2. What are the types of SQL commands?
- SQL commands can be broadly categorized into four types: Data Definition Language (DDL), Data Manipulation Language (DML), Data Control Language (DCL), and Transaction Control Language (TCL).

3. What is the difference between CHAR and VARCHAR data types?
- CHAR is a fixed-length character data type, while VARCHAR is a variable-length character data type. CHAR will always occupy the same amount of storage space, while VARCHAR will only use the necessary space to store the actual data.

4. What is a primary key?
- A primary key is a column or a set of columns that uniquely identifies each row in a table. It ensures data integrity by enforcing uniqueness and can be used to establish relationships between tables.

5. What is a foreign key?
- A foreign key is a column or a set of columns in one table that refers to the primary key in another table. It establishes a relationship between two tables and ensures referential integrity.

6. What is a JOIN in SQL?
- JOIN is used to combine rows from two or more tables based on a related column between them. There are different types of JOINs, including INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL JOIN.

7. What is the difference between INNER JOIN and OUTER JOIN?
- INNER JOIN returns only the rows that have matching values in both tables, while OUTER JOIN (LEFT, RIGHT, FULL) returns all rows from one or both tables, with NULL values in columns where there is no match.

8. What is the difference between GROUP BY and ORDER BY?
- GROUP BY is used to group rows that have the same values into summary rows, typically used with aggregate functions like SUM, COUNT, AVG, etc., while ORDER BY is used to sort the result set based on one or more columns.

9. What is a subquery?
- A subquery is a query nested within another query, used to return data that will be used in the main query. Subqueries can be used in SELECT, INSERT, UPDATE, and DELETE statements.

10. What is normalization in SQL?
- Normalization is the process of organizing data in a database to reduce redundancy and dependency. It involves dividing large tables into smaller tables and defining relationships between them to improve data integrity and efficiency.

Around 90% questions will be asked from sql in data analytics interview, so please make sure to practice SQL skills using websites like stratascratch. ☺️💪

❤ 5

Post #2284 2.85K Feb 4, 2026, 05:58 UTC

👍 5
❤ 2

Post #2283 3.72K Feb 3, 2026, 14:10 UTC

✅ Handling NULL Values in SQL

What is NULL in SQL?
NULL means missing or unknown data.

It does NOT mean:
- 0
- Empty string ''
- False

👉 NULL = no value at all

Why NULLs exist in real data

Real business data is messy:
- Customer didn’t provide city
- Order amount not updated yet
- Employee not assigned a manager

So databases allow NULLs.

Example Table

Data: customers
customer_id: 1, name: Rahul, city: Pune, email: rahul@gmail.com
customer_id: 2, name: Neha, city: NULL, email: neha@gmail.com
customer_id: 3, name: Aman, city: Delhi, email: NULL

🚫 Biggest Beginner Mistake
❌ This is WRONG

SELECT * FROM customers WHERE city = NULL;

👉 This will return no rows

Why? Because NULL cannot be compared using = or !=

✅ Correct Way to Handle NULL
1️⃣ IS NULL: Used to find missing values

SELECT * FROM customers WHERE city IS NULL;

What this query does:
- Scans all rows
- Returns customers where city is missing

2️⃣ IS NOT NULL: Used to exclude missing values

SELECT * FROM customers WHERE email IS NOT NULL;

What this query does:
- Returns customers who have email
- Removes rows with NULL email

NULLs in JOINs (Very Important)
Customers data:
customer_id: 1, name: Rahul
customer_id: 2, name: Neha
customer_id: 3, name: Aman

Orders data:
order_id: 101, customer_id: 1, amount: 5000
order_id: 102, customer_id: 1, amount: 3000

LEFT JOIN with NULL check
👉 Find customers with NO orders

SELECT c.customer_id, c.name
FROM customers c
LEFT JOIN orders o ON c.customer_id = o.customer_id
WHERE o.customer_id IS NULL;

What this query does:
- Keeps all customers
- Matches orders where possible
- Filters customers without orders

NULLs in Aggregations
COUNT behavior (INTERVIEW FAVORITE)

SELECT COUNT(*) FROM customers;

👉 Counts all rows

SELECT COUNT(city) FROM customers;

👉 Counts only non-NULL cities

Example

SELECT COUNT(email) FROM customers;

✔ Counts customers who have email
❌ Ignores NULL emails

Handling NULL using COALESCE

SELECT name, COALESCE(city, 'Unknown') AS city
FROM customers;

What this query does:
- If city exists → show city
- If city is NULL → show “Unknown”

NULLs in SUM / AVG

SELECT SUM(amount) FROM orders;

👉 NULL values are ignored, not treated as 0
But if all rows are NULL, result is NULL.
Safe approach:

SELECT COALESCE(SUM(amount), 0) FROM orders;

NULL vs Empty String
- NULL: No value
- '': Empty value

WHERE email IS NULL -- missing
WHERE email = '' -- empty but exists

Common NULL Mistakes (Must Avoid)
❌ Using = NULL
❌ Forgetting NULLs in LEFT JOIN
❌ Assuming COUNT(column) counts NULL
❌ Ignoring NULL replacement in reports

Interview One-Liner 💡
> NULL represents missing data and must be handled using IS NULL, IS NOT NULL, or COALESCE, not with =.

Double Tap ♥️ For More

❤ 10
👍 1

Post #2281 3.57K Feb 2, 2026, 12:57 UTC

❤ 8
🤔 1

Post #2279 3.76K Feb 1, 2026, 06:38 UTC

✅ SQL JOINS — Scenario-Based Interview Questions with Answers

Scenario 1: Find customers who have never placed an order

Tables: customers(customer_id, name) orders(order_id, customer_id);

Question: Business wants a list of customers with zero orders.

Answer:

SELECT c.customer_id, c.name FROM customers c LEFT JOIN orders o ON c.customer_id = o.customer_id WHERE o.customer_id IS NULL;

Why this works
• LEFT JOIN keeps all customers
• Orders missing → NULL
• WHERE filters only non-ordering customers

Scenario 2: Get total revenue per customer, including customers with no orders

Question: Show every customer and their total spend. If no orders, show 0.

Answer:

SELECT c.customer_id, c.name, COALESCE(SUM(o.amount), 0) AS total_spend FROM customers c LEFT JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.customer_id, c.name;

Explanation
• LEFT JOIN keeps all customers
• SUM aggregates orders
• COALESCE converts NULL to 0

Scenario 3: Find orders that don’t have a matching customer

Question: Audit data to find orphan orders.

Answer:

SELECT o.order_id, o.customer_id FROM orders o LEFT JOIN customers c ON o.customer_id = c.customer_id WHERE c.customer_id IS NULL;

Explanation
• LEFT JOIN from orders
• Missing customers become NULL
• Filters invalid data

Scenario 4: Get only customers who have placed at least one order

Question: Marketing wants only active customers.

Answer:

SELECT DISTINCT c.customer_id, c.name FROM customers c INNER JOIN orders o ON c.customer_id = o.customer_id;

Explanation
• INNER JOIN keeps only matching rows
• Customers without orders are excluded

Scenario 5: Find customers with more than 3 orders

Answer:

SELECT c.customer_id, c.name, COUNT(o.order_id) AS order_count FROM customers c INNER JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.customer_id, c.name HAVING COUNT(o.order_id) > 3;

Explanation
• JOIN combines data
• GROUP BY customer
• HAVING filters aggregated count

Scenario 6: Show latest order for each customer

Answer:

SELECT c.customer_id, c.name, MAX(o.order_date) AS last_order_date FROM customers c INNER JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.customer_id, c.name;

Explanation
• JOIN connects customers and orders
• MAX finds latest order per customer

Scenario 7: Find customers who ordered in 2024 but not in 2025

Answer:

SELECT DISTINCT c.customer_id, c.name FROM customers c INNER JOIN orders o2024 ON c.customer_id = o2024.customer_id LEFT JOIN orders o2025 ON c.customer_id = o2025.customer_id AND o2025.order_date >= '2025-01-01' WHERE o2024.order_date BETWEEN '2024-01-01' AND '2024-12-31' AND o2025.customer_id IS NULL;

Explanation
• INNER JOIN ensures 2024 orders
• LEFT JOIN checks absence in 2025
• NULL filter removes 2025 buyers

Scenario 8: Employee-Manager hierarchy (SELF JOIN)

Table: employees(employee_id, name, manager_id);

Answer:

SELECT e.name AS employee, m.name AS manager FROM employees e LEFT JOIN employees m ON e.manager_id = m.employee_id;

Explanation
• Same table joined twice
• Shows reporting structure

Scenario 9: Revenue by city

Answer:

SELECT c.city, SUM(o.amount) AS revenue FROM customers c INNER JOIN orders o ON c.customer_id = o.customer_id GROUP BY c.city;

Explanation
• JOIN links customers to orders
• GROUP BY city
• SUM calculates revenue

Scenario 10: Duplicate explosion after JOIN (classic trap)

Question: Why does this query show inflated revenue?

SELECT SUM(o.amount) FROM customers c JOIN orders o ON c.customer_id = o.customer_id;

Answer:
• Customer table may have duplicates
• JOIN multiplies rows
• Revenue gets inflated

Fix:

SELECT SUM(amount) FROM orders; or deduplicate customers before joining.

Interview golden rule for JOINS
Always explain:
1️⃣ Which table is LEFT
2️⃣ Which table is RIGHT
3️⃣ What rows are kept
4️⃣ Where NULLs appear

Double Tap ♥️ For More

❤ 7
👍 1
👏 1

Post #2277 3.45K Jan 30, 2026, 20:35 UTC

❤ 7
👏 2

Post #2276 3.18K Jan 30, 2026, 15:20 UTC

If you want to Excel at using the most used database language in the world, learn these powerful SQL features:

• Wildcards (%, _) – Flexible pattern matching
• Window Functions – ROW_NUMBER(), RANK(), DENSE_RANK(), LEAD(), LAG()
• Common Table Expressions (CTEs) – WITH for better readability
• Recursive Queries – Handle hierarchical data
• STRING Functions – LEFT(), RIGHT(), LEN(), TRIM(), UPPER(), LOWER()
• Date Functions – DATEDIFF(), DATEADD(), FORMAT()
• Pivot & Unpivot – Transform row data into columns
• Aggregate Functions – SUM(), AVG(), COUNT(), MIN(), MAX()
• Joins & Self Joins – Master INNER, LEFT, RIGHT, FULL, SELF JOIN
• Indexing – Speed up queries with CREATE INDEX

Like it if you need a complete tutorial on all these topics! 👍❤️

#sql

👍 6
❤ 4

Post #2274 3.59K Jan 29, 2026, 17:34 UTC

Today, let's move to the next topic of SQL Roadmap:

✅ SQL JOINS

What a JOIN is
• A JOIN combines data from two or more tables
• Tables connect using a common column
• That column is usually an ID
• JOIN answers questions one table cannot answer

Why JOINs exist
• Customer details sit in one table
• Orders sit in another table
• JOIN links customers to their orders

Example tables
customers
customer_id | name | city
orders
order_id | customer_id | amount

Connection
• customers.customer_id is primary key
• orders.customer_id is foreign key
• This shared column enables JOIN

Types of JOINs you must know
• INNER JOIN
• LEFT JOIN
• RIGHT JOIN
• FULL JOIN
• SELF JOIN

INNER JOIN
• Returns only matching rows from both tables
• Drops anything without a match

SELECT name, amount 
FROM customers 
INNER JOIN orders 
ON customers.customer_id = orders.customer_id;

• Matches customers with their orders
• Shows only customers who placed orders
• Removes customers with no orders
• Removes orders without customers

LEFT JOIN
• Returns all rows from left table
• Matches data from right table
• Shows NULL when no match exists

SELECT name, amount 
FROM customers 
LEFT JOIN orders 
ON customers.customer_id = orders.customer_id;

• Returns every customer
• Shows order amount if available
• Shows NULL if customer never ordered

RIGHT JOIN
• Returns all rows from right table
• Matches data from left table
• Opposite of LEFT JOIN

SELECT name, amount 
FROM customers 
RIGHT JOIN orders 
ON customers.customer_id = orders.customer_id;

• Returns all orders
• Shows customer name if exists
• Shows NULL for missing customer data

FULL JOIN
• Returns all rows from both tables
• Matches where possible
• Shows NULL when no match

SELECT name, amount 
FROM customers 
FULL JOIN orders 
ON customers.customer_id = orders.customer_id;

• Shows all customers
• Shows all orders
• Includes unmatched data from both sides

SELF JOIN
• Table joins with itself
• Used for hierarchy or comparison

SELECT e.name, m.name AS manager_name 
FROM employees e 
LEFT JOIN employees m 
ON e.manager_id = m.employee_id;

• Matches employee with manager
• Uses same table twice
• Shows reporting hierarchy

JOIN Comparison Summary
• INNER JOIN: Only matching data
• LEFT JOIN: All left table rows
• RIGHT JOIN: All right table rows
• FULL JOIN: Everything from both tables
• SELF JOIN: Table joins itself

Double Tap ♥️ For More

❤ 8

Post #2272 3.12K Jan 29, 2026, 06:12 UTC

Please go through this top 5 SQL projects with Datasets that you can practice and can add in your resume

🚀1. Web Analytics:
(https://www.kaggle.com/zynicide/wine-reviews)

🚀2. Healthcare Data Analysis:
(https://www.kaggle.com/cdc/mortality)

📌3. E-commerce Analysis:
(https://www.kaggle.com/olistbr/brazilian-ecommerce)

🚀4. Inventory Management:
(https://www.kaggle.com/code/govindji/inventory-management)

🚀 5. Analysis of Sales Data:
(https://www.kaggle.com/kyanyoga/sample-sales-data)

Small suggestion from my side for non tech students: kindly pick those datasets which you like the subject in general, that way you will be more excited to practice it, instead of just doing it for the sake of resume, you will learn SQL more passionately, since it’s a programming language try to make it more exciting for yourself.

Hope this piece of information helps you

Join for more -> https://t.me/addlist/4q2PYC0pH_VjZDk5

ENJOY LEARNING 👍👍

👍 2
❤ 1

Post #2271 3.22K Jan 28, 2026, 12:09 UTC

Today, let's move to the next topic of SQL Roadmap:

✅ HAVING vs WHERE

Why HAVING exists

- WHERE filters individual rows.
- Aggregations work on groups.
- You need HAVING to filter groups.

Key difference
- WHERE filters rows before grouping
- HAVING filters groups after aggregation

Think in order
- FROM reads table
- WHERE filters rows
- GROUP BY creates groups
- HAVING filters groups

Example table. orders
order_id | customer_id | amount | order_date

WHERE with aggregation

SELECT customer_id, SUM(amount)
FROM orders
WHERE amount > 5000
GROUP BY customer_id;

What this query does
- Removes orders below 5,000
- Groups remaining orders by customer
- Calculates total high value spend per customer

HAVING example

SELECT customer_id, SUM(amount)
FROM orders
GROUP BY customer_id
HAVING SUM(amount) > 20000;

What this query does
- Groups all orders by customer
- Calculates total spend per customer
- Keeps only customers with total spend above 20,000

WHERE vs HAVING side by side

Use WHERE when
- Filtering raw rows
- Condition does not involve aggregate functions

Use HAVING when
- Filtering aggregated results
- Condition uses SUM, COUNT, AVG

Combined WHERE and HAVING

SELECT customer_id, COUNT(*)
FROM orders
WHERE order_date >= '2024-01-01'
GROUP BY customer_id
HAVING COUNT(*) >= 5;

What this query does
- Keeps orders from 2024 onward
- Groups orders by customer
- Counts orders per customer
- Returns customers with at least 5 orders

Common beginner mistakes
- Using HAVING without GROUP BY
- Using WHERE with SUM or COUNT
- Mixing WHERE and HAVING logic

Interview one-liner
WHERE filters rows. HAVING filters groups.

Double Tap ❤️ For More

❤ 5

Post #2269 3.29K Jan 27, 2026, 10:02 UTC

Today, let's move to the next topic of SQL Roadmap:

✅ Basic SQL Queries: Aggregations and GROUP BY

• Why aggregations matter
• Raw rows hide patterns
• Businesses care about totals, averages, counts
• Aggregations turn rows into answers

• Common aggregate functions
• COUNT: counts rows
• SUM: adds values
• AVG: finds average
• MIN: finds smallest value
• MAX: finds largest value

• Examples
SELECT COUNT(*) FROM orders; -- total orders
SELECT SUM(amount) FROM orders; -- total revenue
SELECT AVG(amount) FROM orders; -- average order value
SELECT MIN(amount), MAX(amount) FROM orders; -- spend range

• GROUP BY
• Groups rows by a column
• Applies aggregation per group
• One result per group
SELECT customer_id, SUM(amount) FROM orders GROUP BY customer_id; -- total spend per customer
SELECT order_date, COUNT(*) FROM orders GROUP BY order_date; -- daily order volume

• Important rule
Every column in SELECT must be aggregated or present in GROUP BY.

• Using WHERE with GROUP BY
SELECT customer_id, SUM(amount) FROM orders
WHERE amount > 5000
GROUP BY customer_id; -- high-value orders per customer

Real business use:
• Revenue per customer
• Orders per day
• Average order value per city

SQL Roadmap: https://whatsapp.com/channel/0029VanC5rODzgT6TiTGoa1v/1615

Double Tap ♥️ For More

❤ 6

Post #2267 3.23K Jan 26, 2026, 08:11 UTC

Today, let's move to the next topic of SQL Roadmap:

✅ Basic SQL Queries: ORDER BY and LIMIT - Sorting and Controlling Output

Why Sorting
- Raw data has no order
- Sorted data reveals patterns
- Analysts sort data in almost every query

What ORDER BY Does
- ORDER BY sorts result rows
- Sorting happens after filtering
- Default order is ascending

Basic Syntax

SELECT column_name
FROM table_name
ORDER BY column_name;

SELECT name, city
FROM customers
ORDER BY name;

- Rows sorted alphabetically by name (A to Z)

Descending Order
- Use DESC for reverse order

SELECT name, signup_date
FROM customers
ORDER BY signup_date DESC;

Use Cases
- Latest users first
- Highest sales first
- Recent transactions on top

Sorting Numbers

SELECT order_id, amount
FROM orders
ORDER BY amount DESC;

Sorting by Multiple Columns
- First column sorts primary
- Second column breaks ties

SELECT city, signup_date
FROM customers
ORDER BY city, signup_date DESC;

LIMIT Explained
- LIMIT restricts number of rows returned
- Used to preview data
- Used to get top results

SELECT name, signup_date
FROM customers
ORDER BY signup_date DESC
LIMIT 5;

Top N Queries

SELECT name, amount
FROM orders
ORDER BY amount DESC
LIMIT 10;

Filtering + Sorting + Limiting Together
Execution order:
1. FROM
2. WHERE
3. ORDER BY
4. LIMIT

SELECT name, amount
FROM orders
WHERE amount > 5000
ORDER BY amount DESC
LIMIT 3;

Double Tap ♥️ For More

❤ 8

Post #2264 2.93K Jan 25, 2026, 09:58 UTC

SELECT name, city FROM customers;

Output
name | city
Rahul | Pune
Neha | Mumbai
Amit | Delhi
Priya | Pune

What Happens
- Database scans all rows
- Returns name and city columns
- No filtering yet

Why SELECT Matters
- Smaller output
- Faster queries
- Clear analysis

What WHERE Does
- WHERE filters rows
- It answers conditions like who, when, how much

Think Like This
- SELECT decides columns
- WHERE decides rows

Basic WHERE Example

SELECT name, city FROM customers WHERE city = 'Pune';

Output
name | city
Rahul | Pune
Priya | Pune

Common Operators
- = equal
- != not equal
- > greater than
- < less than
- > =, <=

Example

SELECT name, signup_date FROM customers WHERE signup_date >= '2024-03-01';

Output
name | signup_date
Amit | 2024-03-05
Priya | 2024-04-20

Logical Filters
AND
- All conditions must match
Example: SELECT name FROM customers WHERE city = 'Pune' AND signup_date >= '2024-01-01';

Output
name
Rahul
Priya

OR
- Any condition can match
Example: SELECT name FROM customers WHERE city = 'Pune' OR city = 'Mumbai';

Output
name
Rahul
Neha
Priya

IN
- Shortcut for multiple OR conditions
Example: SELECT name FROM customers WHERE city IN ('Pune','Mumbai','Delhi');

Output
name
Rahul
Neha
Amit
Priya

BETWEEN
- Filters within a range
- Inclusive of start and end
Example: SELECT name FROM customers WHERE signup_date BETWEEN '2024-01-01' AND '2024-03-31';

Output
name
Rahul
Neha
Amit

Filtering Numbers
Example table: orders
order_id | customer_id | amount | order_date
1 | 101 | 3000 | 2024-01-16
2 | 102 | 6000 | 2024-02-11
3 | 103 | 4000 | 2024-03-06

SELECT order_id, amount FROM orders WHERE amount > 5000;

Output
order_id | amount
2 | 6000

Filtering Text
- Text values go inside quotes
- Case sensitivity depends on database

Filtering NULL Values
- NULL means missing value
- = NULL does not work
Correct way: SELECT name FROM customers WHERE city IS NULL;

Assume city is NULL for customer_id 103
Output
name
Amit

Exclude NULL: SELECT name FROM customers WHERE city IS NOT NULL;

Output
name
Rahul
Neha
Priya

How SELECT and WHERE Work Together
- FROM picks the table
- WHERE filters rows
- SELECT picks columns
- Result is sent back

Real Business Example
- Manager asks for Pune customers with orders above 5,000
- WHERE applies city and amount filters
- SELECT shows required columns

Assume orders table has customer_id 101 with amount 6000

SELECT name FROM customers WHERE city = 'Pune' AND customer_id IN (SELECT customer_id FROM orders WHERE amount > 5000);

Output
name
Rahul

Common Beginner Mistakes
- Using WHERE before FROM
- Forgetting quotes for text
- Using = NULL
- Writing SELECT * always

Double Tap ♥️ For More

❤ 10

Post #2262 2.79K Jan 24, 2026, 21:52 UTC

Glad to see the amazing response on SQL roadmap. ❤️

Today, let's move to the next topic of SQL roadmap:

✅ Database Basics: Primary Key and Foreign Key

Why Keys Exist
Databases store millions of rows. Keys help identify and connect data correctly. Without keys, data breaks fast.

Primary Key
- A primary key uniquely identifies each row in a table
- No two rows share the same primary key
- It never stays empty

Example Table: customers
- Columns: customer_id, name, email, city
- Primary key: customer_id

Why Primary Key Matters
- Prevents duplicate records
- Helps find a row fast
- Keeps data consistent

Foreign Key
- A foreign key links one table to another
- It creates relationships between tables

Example Table: orders
- Columns: order_id, customer_id, order_date, amount
- Foreign key: customer_id

Relationship Explained
- customers.customer_id is primary key
- orders.customer_id is foreign key
- One customer has many orders

Why Foreign Keys Matter
- Enable joins
- Prevent orphan records
- Maintain data integrity

Simple Join Idea
SQL matches customer_id in both tables. This gives customer name with order amount.

Where Beginners Go Wrong
- Using names instead of IDs
- Allowing duplicate primary keys
- Ignoring missing foreign key values

Checkpoint
- You understand primary keys
- You understand foreign keys
- You know how tables connect

Double Tap ♥️ For More

❤ 5

Post #2261 2.88K Jan 24, 2026, 08:57 UTC

Glad to see the amazing response on SQL roadmap. ❤️

Today, let's start with the first topic of SQL roadmap:

✅ Introduction to SQL

SQL is the language you use to ask questions from data stored in databases. Companies store all important data in databases. Sales. Users. Payments. Inventory. When a manager asks a question, SQL pulls the answer.

What a database is
A database is an organized storage system for data. Think of it as a digital cupboard where each drawer holds related data. Each drawer is called a table.

What a table is
A table looks like an Excel sheet. It has rows and columns. Each table stores one type of data.

Example table: customers
- Columns
- customer_id
- name
- email
- city
- signup_date
- Rows
- Each row represents one customer
- One row equals one real-world record

How rows and columns work together
- Columns define what kind of data you store
- Rows hold actual values
- All rows follow the same column structure

Example row
- customer_id: 101
- name: Rahul
- email: rahul@gmail.com
- city: Pune
- signup_date: 2024-03-10

Why structure matters
- Clean structure makes data reliable
- Easy to filter, count, and analyze
- Required for accurate reporting

How SQL interacts with tables
- SQL reads data from tables
- SQL filters rows
- SQL selects columns
- SQL summarizes results

Simple SQL example
You ask the database to show names and cities of customers.

SELECT name, city FROM customers;

What happens behind the scenes
- Database scans the customers table
- Picks name and city columns
- Returns matching rows

Where you will use this daily
- Pull user lists
- Check sales numbers
- Validate data issues

Double Tap ♥️ For More

❤ 10

Post #2259 3.22K Jan 23, 2026, 09:22 UTC

✅ Complete SQL Roadmap in 2 Months

Month 1: Strong SQL Foundations
Week 1: Database and query basics
• What SQL does in analytics and business
• Tables, rows, columns
• Primary key and foreign key
• SELECT, DISTINCT
• WHERE with AND, OR, IN, BETWEEN
Outcome: You understand data structure and fetch filtered data.

Week 2: Sorting and aggregation
• ORDER BY and LIMIT
• COUNT, SUM, AVG, MIN, MAX
• GROUP BY
• HAVING vs WHERE
• Use case like total sales per product
Outcome: You summarize data clearly.

Week 3: Joins fundamentals
• INNER JOIN
• LEFT JOIN
• RIGHT JOIN
• Join conditions
• Handling NULL values
Outcome: You combine multiple tables correctly.

Week 4: Joins practice and cleanup
• Duplicate rows after joins
• SELF JOIN with examples
• Data cleaning using SQL
• Daily join-based questions
Outcome: You stop making join mistakes.

Month 2: Analytics-Level SQL
Week 5: Subqueries and CTEs
• Subqueries in WHERE and SELECT
• Correlated subqueries
• Common Table Expressions
• Readability and reuse
Outcome: You write structured queries.

Week 6: Window functions
• ROW_NUMBER, RANK, DENSE_RANK
• PARTITION BY and ORDER BY
• Running totals
• Top N per category problems
Outcome: You solve advanced analytics queries.

Week 7: Date and string analysis
• Date functions for daily, monthly analysis
• Year-over-year and month-over-month logic
• String functions for text cleanup
Outcome: You handle real business datasets.

Week 8: Project and interview prep
• Build a SQL project using sales or HR data
• Write KPI queries
• Explain query logic step by step
• Daily interview questions practice
Outcome: You are SQL interview ready.

Practice platforms
• LeetCode SQL
• HackerRank SQL
• Kaggle datasets

Double Tap ♥️ For Detailed Explanation of Each Topic

❤ 13

Post #2257 3.19K Jan 22, 2026, 08:06 UTC

Real-world SQL Scenario based Interview Questions with Answers

Question 1: Calculate conversion rate for a sales funnel

Tables: events (user_id, event_name, event_date)

Events: signup → product_view → purchase

Requirement: Count users at each stage, compute conversion from signup to purchase

WITH stages AS (
  SELECT user_id,
    MAX(CASE WHEN event_name = 'signup' THEN 1 ELSE 0 END) AS signup,
    MAX(CASE WHEN event_name = 'product_view' THEN 1 ELSE 0 END) AS view,
    MAX(CASE WHEN event_name = 'purchase' THEN 1 ELSE 0 END) AS purchase
  FROM events
  GROUP BY user_id
)

SELECT 
  SUM(signup) AS signups,
  SUM(purchase) AS purchases,
  ROUND(100.0 * SUM(purchase) / SUM(signup), 2) AS conversion_rate
FROM stages;

Question 2: Build a monthly retention cohort

Tables: users (user_id, signup_date), logins (user_id, login_date)

Requirement: Cohort by signup month, show retained users by login month

WITH cohort AS (
  SELECT user_id, DATE_TRUNC('month', signup_date) AS cohort_month
  FROM users
),
activity AS (
  SELECT l.user_id, DATE_TRUNC('month', l.login_date) AS activity_month
  FROM logins l
)

SELECT 
  c.cohort_month,
  a.activity_month,
  COUNT(DISTINCT a.user_id) AS active_users
FROM cohort c
JOIN activity a ON c.user_id = a.user_id
GROUP BY c.cohort_month, a.activity_month
ORDER BY c.cohort_month, a.activity_month;

Question 3: Calculate monthly churn rate

Tables: subscriptions (user_id, start_date, end_date)

Requirement: Churned users per month, churn rate = churned / active users

WITH active_users AS (
  SELECT DATE_TRUNC('month', start_date) AS month, COUNT(DISTINCT user_id) AS active_users
  FROM subscriptions
  GROUP BY DATE_TRUNC('month', start_date)
),
churned_users AS (
  SELECT DATE_TRUNC('month', end_date) AS month, COUNT(DISTINCT user_id) AS churned_users
  FROM subscriptions
  WHERE end_date IS NOT NULL
  GROUP BY DATE_TRUNC('month', end_date)
)
SELECT 
  a.month,
  a.active_users,
  COALESCE(c.churned_users, 0) AS churned_users,
  ROUND(100.0 * COALESCE(c.churned_users, 0) / a.active_users, 2) AS churn_rate
FROM active_users a
LEFT JOIN churned_users c ON a.month = c.month
ORDER BY a.month;

Question 4: Calculate Daily Active Users

Table: user_activity (user_id, activity_date)

Requirement: DAU per day

SELECT activity_date, COUNT(DISTINCT user_id) AS dau
FROM user_activity
GROUP BY activity_date
ORDER BY activity_date;

Question 5: Revenue by marketing channel

Tables: orders (order_id, user_id, amount, order_date), users (user_id, channel)

Requirement: Total revenue per channel, monthly breakdown

SELECT 
  DATE_TRUNC('month', o.order_date) AS month,
  u.channel,
  SUM(o.amount) AS revenue
FROM orders o
JOIN users u ON o.user_id = u.user_id
GROUP BY DATE_TRUNC('month', o.order_date), u.channel
ORDER BY month, revenue DESC;

Question 6: Identify returning customers

Table: orders (order_id, customer_id, order_date)

Requirement: Customers with more than one order

SELECT customer_id
FROM orders
GROUP BY customer_id
HAVING COUNT(order_id) > 1;

Question 7: Top product by revenue per month

Table: sales (product_id, amount, sale_date)

WITH monthly_sales AS (
  SELECT 
    DATE_TRUNC('month', sale_date) AS month,
    product_id,
    SUM(amount) AS revenue
  FROM sales
  GROUP BY DATE_TRUNC('month', sale_date), product_id
),
ranked AS (
  SELECT *, RANK() OVER (PARTITION BY month ORDER BY revenue DESC) AS rnk
  FROM monthly_sales
)

SELECT month, product_id, revenue
FROM ranked
WHERE rnk = 1;

Double Tap ♥️ For More

❤ 7

Post #2255 2.89K Jan 21, 2026, 13:04 UTC

✅ SQL CASE Statements and Data Cleaning Interview Questions with Answers 📊

1. Classify customers based on total spend
Table: orders (order_id, customer_id, amount)

Requirement:
- Gold if total_spend >= 100000
- Silver if total_spend between 50000 and 99999
- Bronze otherwise

Solution:

SELECT customer_id,
CASE
WHEN SUM(amount) >= 100000 THEN 'Gold'
WHEN SUM(amount) >= 50000 THEN 'Silver'
ELSE 'Bronze'
END AS customer_category
FROM orders
GROUP BY customer_id;

2. Create an age group column for users
Table: users (user_id, age)

Requirement:
- Below 18
- 18 to 30
- Above 30

Solution:

SELECT user_id,
CASE
WHEN age < 18 THEN 'Below 18'
WHEN age BETWEEN 18 AND 30 THEN '18-30'
ELSE 'Above 30'
END AS age_group
FROM users;

3. Replace NULL salary with 0
Table: employees (employee_id, salary)

Solution:

SELECT employee_id, COALESCE(salary, 0) AS salary
FROM employees;

4. Count employees with missing email IDs
Table: employees (employee_id, email)

Solution:

SELECT COUNT(*) AS missing_email_count
FROM employees
WHERE email IS NULL;

5. Remove extra spaces from customer names
Table: customers (customer_id, name)

Solution:

SELECT customer_id, TRIM(name) AS clean_name
FROM customers;

6. Extract first 3 characters from product code
Table: products (product_code)

Solution:

SELECT product_code, SUBSTRING(product_code, 1, 3) AS product_prefix
FROM products;

7. Standardize date format
Table: orders (order_date)

Requirement: Convert to YYYY-MM-DD

Solution:

SELECT CAST(order_date AS DATE) AS clean_order_date
FROM orders;

8. Mark inactive users based on last login
Table: users (user_id, last_login_date)

Requirement: Inactive if last login before 2023-01-01

Solution:

SELECT user_id,
CASE
WHEN last_login_date < '2023-01-01' THEN 'Inactive'
ELSE 'Active'
END AS user_status
FROM users;

9. Handle empty string as NULL
Table: customers (phone_number)

Solution:

SELECT NULLIF(phone_number, '') AS phone_number
FROM customers;

10. Create a clean reporting column using multiple rules
Table: transactions (amount)

Requirement:
- High if amount >= 10000
- Medium if 5000 to 9999
- Low otherwise

Solution:

SELECT amount,
CASE
WHEN amount >= 10000 THEN 'High'
WHEN amount >= 5000 THEN 'Medium'
ELSE 'Low'
END AS transaction_type
FROM transactions;

Double Tap ♥️ For More

❤ 8

Post #2253 2.87K Jan 20, 2026, 19:27 UTC

✅ SQL CTEs and Subqueries Interview Questions with Answers 🖥️

1. Find employees who earn more than the average salary.

Table: employees (employee_id, name, salary)

SELECT name, salary 
FROM employees 
WHERE salary > ( 
  SELECT AVG(salary) 
  FROM employees 
);

Logic: Inner query calculates average salary. Outer query filters employees above average.

2. Find employees who earn the highest salary in each department.

Table: employees (employee_id, name, department, salary)

SELECT name, department, salary 
FROM employees e 
WHERE salary = ( 
  SELECT MAX(salary) 
  FROM employees 
  WHERE department = e.department 
);

Logic: Subquery runs per department. Matches max salary inside same department.

3. Find departments where average salary is greater than 60,000.

SELECT department 
FROM ( 
  SELECT department, AVG(salary) AS avg_salary 
  FROM employees 
  GROUP BY department 
) t 
WHERE avg_salary > 60000;

Logic: Inner query calculates department average. Outer query filters required departments.

4. Same query using CTE.

WITH dept_avg AS ( 
  SELECT department, AVG(salary) AS avg_salary 
  FROM employees 
  GROUP BY department 
) 
SELECT department 
FROM dept_avg 
WHERE avg_salary > 60000;

Logic: CTE stores aggregated result. Final query reads from CTE.

5. Find customers who placed more orders than the average number of orders.

Tables: customers (customer_id, name), orders (order_id, customer_id)

SELECT customer_id 
FROM orders 
GROUP BY customer_id 
HAVING COUNT(order_id) > ( 
  SELECT AVG(order_count) 
  FROM ( 
    SELECT COUNT(order_id) AS order_count 
    FROM orders 
    GROUP BY customer_id 
  ) x 
);

Logic: Inner query calculates orders per customer. Next level gets average. HAVING filters customers above average.

6. Find top-selling product by total sales amount.
Table: sales (product_id, amount)

SELECT product_id
FROM sales 
GROUP BY product_id 
HAVING SUM(amount) = ( 
  SELECT MAX(total_sales) 
  FROM ( 
    SELECT SUM(amount) AS total_sales 
    FROM sales 
    GROUP BY product_id 
  ) t 
);

Logic: Inner query calculates sales per product. Outer query finds max and matches it.

7. Rewrite using CTE.

WITH product_sales AS (
  SELECT product_id, SUM(amount) AS total_sales 
  FROM sales 
  GROUP BY product_id 
) 
SELECT product_id 
FROM product_sales 
WHERE total_sales = ( 
  SELECT MAX(total_sales) 
  FROM product_sales 
);

Logic: CTE avoids repeating aggregation. Cleaner and readable.

8. Find employees whose salary is greater than their department average.

WITH dept_avg AS (
  SELECT department, AVG(salary) AS avg_salary 
  FROM employees 
  GROUP BY department 
) 
SELECT e.name, e.salary 
FROM employees e 
JOIN dept_avg d ON e.department = d.department 
WHERE e.salary > d.avg_salary;

Logic: First compute department averages. Join back to employees. Filter higher earners.

Double Tap ♥️ For More

❤ 2

Older posts →