𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄𝗲𝗿: You have 2 minutes to solve this SQL query.
Retrieve the department name and the highest salary in each department from the employees table, but only for departments where the highest salary is greater than $70,000.

𝗠𝗲: Challenge accepted!

SELECT department, MAX(salary) AS highest_salary
FROM employees
GROUP BY department
HAVING MAX(salary) > 70000;

I used GROUP BY to group employees by department, MAX() to get the highest salary, and HAVING to filter the result based on the condition that the highest salary exceeds $70,000. This solution effectively shows my understanding of aggregation functions and how to apply conditions on the result of those aggregations.

𝗧𝗶𝗽 𝗳𝗼𝗿 𝗦𝗤𝗟 𝗝𝗼𝗯 𝗦𝗲𝗲𝗸𝗲𝗿𝘀:
It's not about writing complex queries; it's about writing clean, efficient, and scalable code. Focus on mastering subqueries, joins, and aggregation functions to stand out!

React with ❤️ for more

If I need to teach someone data analytics from the basics, here is my strategy:

1. I will first remove the fear of tools from that person

2. i will start with the excel because it looks familiar and easy to use

3. I put more emphasis on projects like at least 5 to 6 with the excel. because in industry you learn by doing things

4. I will release the person from the tutorial hell and move into a more action oriented person

5. Then I move to the sql because every job wants it , even with the ai tools you need strong understanding for it if you are going to use it daily

6. After strong understanding, I will push the person to solve 100 to 150 Sql problems from basic to advance

7. It helps the person to develop the analytical thinking

8. Then I push the person to solve 3 case studies as it helps how we pull the data in the real life

9. Then I move the person to power bi to do again 5 projects by using either sql or excel files

10. Now the fear is removed.

11. Now I push the person to solve unguided challenges and present them by video recording as it increases the problem solving, communication and data story telling skills

12. Further it helps you to clear case study round given by most of the companies

13. Now i help the person how to present them in resume and also how these tools are used in real world.

14. You know the interesting fact, all of above is present free in youtube and I also mentor the people through existing youtube videos.

15. But people stuck in the tutorial hell, loose motivation , stay confused that they are either in the right direction or not.

16. As a personal mentor , I help them to get of the tutorial hell, set them in the right direction and they stay motivated when they start to see the difference before amd after mentorship

I have curated best 80+ top-notch Data Analytics Resources 👇👇
https://topmate.io/analyst/861634

Hope this helps you 😊

✅ SQL Subquery Practice Questions with Answers

🔎 Q1. Retrieve employees whose salary is greater than the company’s average salary.
🗂️ Table: employees(emp_id, name, salary)

✅ Answer:

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

---

🔎 Q2. Identify customers who have placed more than three orders.
🗂️ Table: orders(order_id, customer_id, order_date)

✅ Answer:

SELECT customer_id
FROM orders
WHERE customer_id IN (
  SELECT customer_id
  FROM orders
  GROUP BY customer_id
  HAVING COUNT(order_id) > 3
);

---

🔎 Q3. Display employees working in departments where the average salary exceeds 60,000.
🗂️ Table: employees(emp_id, name, department_id, salary)

✅ Answer:

SELECT emp_id, name, department_id
FROM employees e
WHERE department_id IN (
  SELECT department_id
  FROM employees
  GROUP BY department_id
  HAVING AVG(salary) > 60000
);

---

🔎 Q4. Show products that have never been ordered.
🗂️ Tables: products(product_id, product_name), orders(order_id, product_id)

✅ Answer:

SELECT product_id, product_name
FROM products
WHERE product_id NOT IN (SELECT product_id FROM orders);

(Alternative safe approach to handle NULLs in orders)

SELECT p.product_id, p.product_name
FROM products p
LEFT JOIN orders o ON p.product_id = o.product_id
WHERE o.product_id IS NULL;

---

🔎 Q5. Fetch employee(s) receiving the maximum salary in the organization.
🗂️ Table: employees(emp_id, name, salary)

✅ Answer:

SELECT emp_id, name, salary
FROM employees
WHERE salary = (SELECT MAX(salary) FROM employees);

Double Tap ♥️ For More

Master SQL step-by-step! From basics to advanced, here are the key topics you need for a solid SQL foundation. 🚀

1. Foundations:
- Learn basic SQL syntax, including SELECT, FROM, WHERE clauses.
- Understand data types, constraints, and the basic structure of a database.

2. Database Design:
- Study database normalization to ensure efficient data organization.
- Learn about primary keys, foreign keys, and relationships between tables.

3. Queries and Joins:
- Practice writing simple to complex SELECT queries.
- Master different types of joins (INNER, LEFT, RIGHT, FULL) to combine data from multiple tables.

4. Aggregation and Grouping:
- Explore aggregate functions like COUNT, SUM, AVG, MAX, and MIN.
- Understand GROUP BY clause for summarizing data based on specific criteria.

5. Subqueries and Nested Queries:
- Learn how to use subqueries to perform operations within another query.
- Understand the concept of nested queries and their practical applications.

6. Indexing and Optimization:
- Study indexing for enhancing query performance.
- Learn optimization techniques, such as avoiding SELECT * and using appropriate indexes.

7. Transactions and ACID Properties:
- Understand the basics of transactions and their role in maintaining data integrity.
- Explore ACID properties (Atomicity, Consistency, Isolation, Durability) in database management.

8. Views and Stored Procedures:
- Create and use views to simplify complex queries.
- Learn about stored procedures for reusable and efficient query execution.

9. Security and Permissions:
- Understand SQL injection risks and how to prevent them.
- Learn how to manage user permissions and access control.

10. Advanced Topics:
- Explore advanced SQL concepts like window functions, CTEs (Common Table Expressions), and recursive queries.
- Familiarize yourself with database-specific features (e.g., PostgreSQL's JSON functions, MySQL's spatial data types).

11. Real-world Projects:
- Apply your knowledge to real-world scenarios by working on projects.
- Practice with sample databases or create your own to reinforce your skills.

12. Continuous Learning:
- Stay updated on SQL advancements and industry best practices.
- Engage with online communities, forums, and resources for ongoing learning and problem-solving.

Here are some free resources to learn & practice SQL 👇👇

SQL For Data Analysis: https://t.iss.one/sqlanalyst

For Practice- https://stratascratch.com/?via=free

SQL Learning Series: https://t.iss.one/sqlspecialist/567

Top 10 SQL Projects with Datasets: https://t.iss.one/DataPortfolio/16

Join for more free resources: https://t.iss.one/free4unow_backup

ENJOY LEARNING 👍👍

Recursive CTE in SQL

✅ SQL Subquery Practice Questions with Answers — Part 2 🧠🗂️

🔎 Q1. Find employees earning more than the average salary of their department. 
🗂️ Table: "employees(emp_id, name, department_id, salary)"

✅ Answer: 

SELECT name, department_id, salary
FROM employees e1
WHERE salary > (
    SELECT AVG(salary)
    FROM employees e2
    WHERE e1.department_id = e2.department_id
);

🔎 Q2. Get customers who never placed any order. 
🗂️ Tables: "customers(customer_id, name)", "orders(order_id, customer_id)"

✅ Answer: 

SELECT customer_id, name
FROM customers
WHERE customer_id NOT IN (
    SELECT customer_id
    FROM orders
);

🔎 Q3. Find the second highest salary from employees. 
🗂️ Table: "employees(emp_id, name, salary)"

✅ Answer: 

SELECT MAX(salary) AS second_highest_salary
FROM employees
WHERE salary < (
    SELECT MAX(salary)
    FROM employees
);

🔎 Q4. List products priced higher than the average product price. 
🗂️ Table: "products(product_id, product_name, price)"

✅ Answer: 

SELECT product_name, price
FROM products
WHERE price > (
    SELECT AVG(price)
    FROM products
);

🔎 Q5. Find employees who work in the same department as 'John'. 
🗂️ Table: "employees(emp_id, name, department_id)"

✅ Answer: 

SELECT name, department_id
FROM employees
WHERE department_id = (
    SELECT department_id
    FROM employees
    WHERE name = 'John'
);

Double Tap ♥️ For More

✅ SQL Interview Roadmap – Step-by-Step Guide to Crack Any SQL Round 💼📊

Whether you're applying for Data Analyst, BI, or Data Engineer roles — SQL rounds are must-clear. Here's your focused roadmap:

1️⃣ Core SQL Concepts
🔹 Understand RDBMS, tables, keys, schemas
🔹 Data types, NULLs, constraints
🧠 Interview Tip: Be able to explain Primary vs Foreign Key.

2️⃣ Basic Queries
🔹 SELECT, FROM, WHERE, ORDER BY, LIMIT
🧠 Practice: Filter and sort data by multiple columns.

3️⃣ Joins – Very Frequently Asked!
🔹 INNER, LEFT, RIGHT, FULL OUTER JOIN
🧠 Interview Tip: Explain the difference with examples.
🧪 Practice: Write queries using joins across 2–3 tables.

4️⃣ Aggregations & GROUP BY
🔹 COUNT, SUM, AVG, MIN, MAX, HAVING
🧠 Common Question: Total sales per category where total > X.

5️⃣ Window Functions
🔹 ROW_NUMBER(), RANK(), DENSE_RANK(), LAG(), LEAD()
🧠 Interview Favorite: Top N per group, previous row comparison.

6️⃣ Subqueries & CTEs
🔹 Write queries inside WHERE, FROM, and using WITH
🧠 Use Case: Filtering on aggregated data, simplifying logic.

7️⃣ CASE Statements
🔹 Add logic directly in SELECT
🧠 Example: Categorize users based on spend or activity.

8️⃣ Data Cleaning & Transformation
🔹 Handle NULLs, format dates, string manipulation (TRIM, SUBSTRING)
🧠 Real-world Task: Clean user input data.

9️⃣ Query Optimization Basics
🔹 Understand indexing, query plan, performance tips
🧠 Interview Tip: Difference between WHERE and HAVING.

🔟 Real-World Scenarios
🧠 Must Practice:
• Sales funnel
• Retention cohort
• Churn rate
• Revenue by channel
• Daily active users

🧪 Practice Platforms
• LeetCode (Easy–Hard SQL)
• StrataScratch (Real business cases)
• Mode Analytics (SQL + Visualization)
• HackerRank SQL (MCQs + Coding)

💼 Final Tip:
Explain why your query works, not just what it does. Speak your logic clearly.

💬 Tap ❤️ for more!

✅ SQL Mistakes Beginners Should Avoid 🧠💻

1️⃣ Using SELECT *
• Pulls unused columns
• Slows queries
• Breaks when schema changes
• Use only required columns

2️⃣ Ignoring NULL Values
• NULL breaks calculations
• COUNT(column) skips NULL
• Use COALESCE or IS NULL checks

3️⃣ Wrong JOIN Type
• INNER instead of LEFT
• Data silently disappears
• Always ask: Do you need unmatched rows?

4️⃣ Missing JOIN Conditions
• Creates cartesian product
• Rows explode
• Always join on keys

5️⃣ Filtering After JOIN Instead of Before
• Processes more rows than needed
• Slower performance
• Filter early using WHERE or subqueries

6️⃣ Using WHERE Instead of HAVING
• WHERE filters rows
• HAVING filters groups
• Aggregates fail without HAVING

7️⃣ Not Using Indexes
• Full table scans
• Slow dashboards
• Index columns used in JOIN, WHERE, ORDER BY

8️⃣ Relying on ORDER BY in Subqueries
• Order not guaranteed
• Results change
• Use ORDER BY only in final query

9️⃣ Mixing Data Types
• Implicit conversions
• Index not used
• Match column data types

🔟 No Query Validation
• Results look right but are wrong
• Always cross-check counts and totals

🧠 Practice Task
• Rewrite one query
• Remove SELECT *
• Add proper JOIN
• Handle NULLs
• Compare result count

SQL Resources: https://whatsapp.com/channel/0029VanC5rODzgT6TiTGoa1v

❤️ Double Tap For More

Best practices for writing SQL queries:

Join for more: https://t.iss.one/learndataanalysis

1- Write SQL keywords in capital letters.

2- Use table aliases with columns when you are joining multiple tables.

3- Never use select *, always mention list of columns in select clause.

4- Add useful comments wherever you write complex logic. Avoid too many comments.

5- Use joins instead of subqueries when possible for better performance.

6- Create CTEs instead of multiple sub queries , it will make your query easy to read.

7- Join tables using JOIN keywords instead of writing join condition in where clause for better readability.

8- Never use order by in sub queries , It will unnecessary increase runtime.

9- If you know there are no duplicates in 2 tables, use UNION ALL instead of UNION for better performance.

SQL Interview Questions with Answers Part-1: ☑️

1. What is SQL? 
   SQL (Structured Query Language) is a standardized programming language designed to manage and manipulate relational databases. It allows you to query, insert, update, and delete data, as well as create and modify schema objects like tables and views.

2. Differentiate between SQL and NoSQL databases. 
   SQL databases are relational, table-based, and use structured query language with fixed schemas, ideal for complex queries and transactions. NoSQL databases are non-relational, can be document, key-value, graph, or column-oriented, and are schema-flexible, designed for scalability and handling unstructured data.

3. What are the different types of SQL commands?
⦁ DDL (Data Definition Language): CREATE, ALTER, DROP (define and modify structure)
⦁ DML (Data Manipulation Language): SELECT, INSERT, UPDATE, DELETE (data operations)
⦁ DCL (Data Control Language): GRANT, REVOKE (permission control)
⦁ TCL (Transaction Control Language): COMMIT, ROLLBACK, SAVEPOINT (transaction management)

4. Explain the difference between WHERE and HAVING clauses.
⦁ WHERE filters rows before grouping (used with SELECT, UPDATE).
⦁ HAVING filters groups after aggregation (used with GROUP BY), e.g., filtering aggregated results like sums or counts.

5. Write a SQL query to find the second highest salary in a table. 
   Using a subquery:

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

Or using DENSE_RANK():

SELECT salary FROM (  
  SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) as rnk  
  FROM employees) t  
WHERE rnk = 2;

6. What is a JOIN? Explain different types of JOINs. 
   A JOIN combines rows from two or more tables based on a related column:
⦁ INNER JOIN: returns matching rows from both tables.
⦁ LEFT JOIN (LEFT OUTER JOIN): all rows from the left table, matched rows from right.
⦁ RIGHT JOIN (RIGHT OUTER JOIN): all rows from right table, matched rows from left.
⦁ FULL JOIN (FULL OUTER JOIN): all rows when there’s a match in either table.
⦁ CROSS JOIN: Cartesian product of both tables.

7. How do you optimize slow-performing SQL queries?
⦁ Use indexes appropriately to speed up lookups.
⦁ Avoid SELECT *; only select necessary columns.
⦁ Use joins carefully; filter early with WHERE clauses.
⦁ Analyze execution plans to identify bottlenecks.
⦁ Avoid unnecessary subqueries; use EXISTS or JOINs.
⦁ Limit result sets with pagination if dealing with large datasets.

8. What is a primary key? What is a foreign key?
⦁ Primary Key: A unique identifier for records in a table; it cannot be NULL.
⦁ Foreign Key: A field that creates a link between two tables by referring to the primary key in another table, enforcing referential integrity.

9. What are indexes? Explain clustered and non-clustered indexes.
⦁ Indexes speed up data retrieval by providing quick lookups.
⦁ Clustered Index: Sorts and stores the actual data rows in the table based on the key; a table can have only one clustered index.
⦁ Non-Clustered Index: Creates a separate structure that points to the data rows; tables can have multiple non-clustered indexes.

10. Write a SQL query to fetch the top 5 records from a table. 
    In SQL Server and PostgreSQL:

SELECT * FROM table_name  
ORDER BY some_column DESC  
LIMIT 5;  

In SQL Server (older syntax):

SELECT TOP 5 * FROM table_name  
ORDER BY some_column DESC;  

React ♥️ for Part 2