What is the difference between INNER JOIN and LEFT JOIN?

INNER JOIN returns only rows where the join key exists in BOTH tables. LEFT JOIN returns ALL rows from the left table, plus matching rows from the right table (or NULLs where no match exists). Use INNER JOIN when you only want matched pairs; use LEFT JOIN when you need to keep unmatched left rows (e.g., all customers whether or not they placed an order).

What is a window function and how is it different from GROUP BY?

A window function computes an aggregate value over a set of rows related to the current row WITHOUT collapsing them. GROUP BY collapses rows into one per group; window functions keep every row and add a computed column. Common window functions: ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, SUM() OVER, AVG() OVER.

What is an index and how does it speed up queries?

An index is a separate data structure (typically a B-tree) that lets the database find rows matching a column value without scanning the entire table. Trade-off: indexes speed up SELECT/WHERE/JOIN but slow down INSERT/UPDATE/DELETE (the index must be updated too) and consume disk space. Use indexes on columns frequently used in WHERE, JOIN, and ORDER BY.

What is normalization and why is it important?

Normalization is the process of organizing tables to reduce data redundancy and improve data integrity. 1NF: every column holds atomic values (no comma-separated lists). 2NF: 1NF + every non-key column depends on the whole primary key. 3NF: 2NF + no transitive dependencies. BCNF: 3NF + every determinant is a candidate key. Reduces update anomalies but may require more JOINs at read time.

What is the difference between UNION and UNION ALL?

UNION combines the result sets of two queries and removes duplicate rows. UNION ALL combines them and keeps all rows including duplicates. UNION ALL is faster because it skips the deduplication step. Use UNION when you need a distinct set; use UNION ALL when duplicates are acceptable or expected.

How do I prepare for SQL interviews in 3 weeks?

Week 1: SELECT, WHERE, ORDER BY, basic JOINs, GROUP BY, HAVING — 20 practice queries per day on HackerRank. Week 2: subqueries, window functions (ROW_NUMBER, RANK, LAG, LEAD), CTEs, indexes — 10 problems per day. Week 3: mock interviews with timed query writing, plus 50 real interview SQL questions from platforms like LeetCode and InterviewBit.

SQL Interview Questions 2026 Top 40 with Answers

Q: What are the most asked SQL topics in fresher interviews 2026?

SELECT/WHERE/ORDER BY basics (22%), JOINs (INNER, LEFT, RIGHT, FULL, SELF) (25%), GROUP BY + HAVING (12%), subqueries (10%), indexes and query optimization (10%), window functions ROW_NUMBER/RANK/DENSE_RANK (8%), transactions and ACID (7%), normalization 1NF/2NF/3NF (6%). TCS NQT and Infosys InfyTQ each dedicate one full coding round to SQL JOIN queries.

Q: What is the difference between WHERE and HAVING?

WHERE filters rows BEFORE grouping; HAVING filters groups AFTER aggregation. WHERE cannot reference aggregate functions (SUM, COUNT, AVG); HAVING can. Example: WHERE order_date >= '2026-01-01' filters individual orders; HAVING SUM(amount) > 10000 filters grouped-by-customer totals.

The top 40 SQL interview questions for freshers and experienced in 2026 cover eight clusters: SELECT/WHERE/ORDER BY basics (22%), JOINs (25%), GROUP BY + HAVING (12%), subqueries (10%), indexes and query optimization (10%), window functions ROW_NUMBER/RANK/DENSE_RANK (8%), transactions and ACID (7%), and normalization 1NF/2NF/3NF (6%). Most fresher interviews (TCS NQT, Infosys InfyTQ, Cognizant GenC) dedicate one full coding round to SQL JOIN queries, plus 8–12 MCQs on output prediction. This guide gives you all 40 questions with concise answers and 12 working SQL examples you can run on MySQL or PostgreSQL.

SQL Topic Weightage in 2026 Fresher Interviews
Company Round Formats (TCS / Infosys / Cognizant)
SQL Basics (Q1–Q8)
JOINs Explained (Q9–Q15)
GROUP BY, HAVING, Aggregation (Q16–Q20)
Subqueries & CTEs (Q21–Q25)
Window Functions (Q26–Q30)
Indexes & Performance (Q31–Q34)
Transactions & ACID (Q35–Q37)
Normalization (Q38–Q40)
3-Week SQL Interview Prep Plan

SQL Topic Weightage in 2026 Fresher Interviews

Topic Cluster	Frequency in Coding Round	Frequency in MCQ Round
SELECT, WHERE, ORDER BY, DISTINCT	15%	30%
JOINs (INNER, LEFT, RIGHT, SELF)	35%	20%
GROUP BY + HAVING, aggregate functions	15%	12%
Subqueries & CTEs	12%	8%
Window functions (ROW_NUMBER, RANK)	8%	5%
Indexes & EXPLAIN plans	5%	10%
Transactions, ACID, isolation levels	5%	10%
Normalization 1NF/2NF/3NF	5%	5%

Trend in 2026: Window-function questions doubled in frequency at Infosys InfyTQ and TCS NQT compared to 2024. Expect at least one ROW_NUMBER() or RANK() question in any product-company fresher round.

Company Round Formats: SQL Coverage

Company Round	SQL Format	Difficulty
TCS NQT (2026)	10–12 SQL MCQs + 1–2 SQL coding questions	Easy to medium (single JOIN + GROUP BY)
Infosys InfyTQ (2026)	10 SQL MCQs + 1 SQL coding (often 2 JOINs)	Easy to medium
Cognizant GenC (2026)	15 SQL MCQs + 1 SQL coding	Easy to medium
Wipro NLTH (2026)	8–10 SQL MCQs	Easy only
Accenture (2026)	10–12 SQL MCQs + 1 coding	Easy to medium
Product companies (Flipkart, PhonePe, Razorpay)	1–2 SQL live-coding rounds	Medium to hard (window functions, CTEs, optimization)

SQL Interview Questions

Q1. What is the difference between SQL and MySQL/PostgreSQL?
Answer: SQL (Structured Query Language) is the standard language for relational databases. MySQL, PostgreSQL, Oracle, and SQL Server are database management systems (DBMS) that implement SQL with proprietary extensions. ANSI SQL is the common subset; each DBMS adds vendor-specific functions (e.g., MySQL's LIMIT, PostgreSQL's ILIKE, Oracle's ROWNUM, SQL Server's TOP).

Q2. What is the difference between CHAR and VARCHAR?
Answer: CHAR(n) stores exactly n characters, padding with spaces if the value is shorter (fixed-length, faster for fixed-size data like country codes). VARCHAR(n) stores up to n characters without padding (variable-length, saves space for variable data like names). Use CHAR for codes (ISO country codes, state codes); use VARCHAR for free text.

Q3. What is a primary key?
Answer: A column (or combination of columns) that uniquely identifies each row in a table. Properties: NOT NULL, unique, immutable. Each table should have exactly one primary key. Composite primary keys use multiple columns (e.g., (order_id, line_item_id)). Surrogate keys (auto-increment integers or UUIDs) are often preferred over natural keys (real-world identifiers like email) because they're stable.

Q4. What is a foreign key?
Answer: A column in one table that references the primary key of another table, enforcing referential integrity. A row cannot be inserted with a foreign-key value that doesn't exist in the referenced table; a referenced row cannot be deleted while child rows exist (unless ON DELETE CASCADE is set). Example: orders.customer_id references customers.id.

Q5. What is the difference between DELETE, TRUNCATE, and DROP?
Answer:

Command	Removes	Rollback	Resets identity
`DELETE FROM table WHERE ...`	Specific rows (or all if no WHERE)	Yes (transactional)	No
`TRUNCATE TABLE table`	All rows	No (DDL, auto-committed in most DBs)	Yes
`DROP TABLE table`	Table itself + all data + structure	No	N/A (table is gone)

Q6. What is the difference between WHERE and HAVING?
Answer:

-- WHERE filters rows BEFORE grouping
SELECT department, AVG(salary) AS avg_salary
FROM employees
WHERE hire_date >= '2025-01-01'          -- only recent hires
GROUP BY department;

-- HAVING filters groups AFTER aggregation
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
HAVING AVG(salary) > 80000;              -- only well-paid departments

WHERE cannot reference aggregate functions; HAVING can. WHERE is also faster because it reduces rows before grouping; HAVING runs after the aggregation is complete.

Q7. What is DISTINCT and when do you use it?
Answer: SELECT DISTINCT col FROM table returns unique values. Use it for de-duplicating results, especially with joins that can multiply rows. Be careful: SELECT DISTINCT a, b, c returns unique combinations of all three columns, not unique values of each individually. Performance penalty: DISTINCT requires a sort or hash to identify duplicates.

Q8. What is NULL in SQL and how is it different from zero or empty string?
Answer: NULL means "unknown" or "missing" — not zero, not empty string, not the string 'NULL'. Comparisons with NULL return NULL (not true/false), so you need IS NULL / IS NOT NULL rather than = NULL. Aggregate functions ignore NULLs (except COUNT(*)): SUM/AVG/COUNT(column) skip NULLs; COUNT(*) counts all rows. Use COALESCE(col, 0) to replace NULL with a default.

JOINs Explained (Q9–Q15)

Q9. Explain all JOIN types with examples.
Answer:

-- Sample tables
-- customers:    id, name
-- orders:       id, customer_id, amount

-- INNER JOIN: only rows where customer.id = orders.customer_id
SELECT c.name, o.amount
FROM customers c
INNER JOIN orders o ON c.id = o.customer_id;

-- LEFT JOIN: all customers, with order amount where present (NULL if no order)
SELECT c.name, o.amount
FROM customers c
LEFT JOIN orders o ON c.id = o.customer_id;

-- RIGHT JOIN: all orders, with customer name where present
SELECT c.name, o.amount
FROM customers c
RIGHT JOIN orders o ON c.id = o.customer_id;

-- FULL OUTER JOIN: all customers + all orders, NULLs on missing side
SELECT c.name, o.amount
FROM customers c
FULL OUTER JOIN orders o ON c.id = o.customer_id;

-- CROSS JOIN: every customer × every order (Cartesian product)
SELECT c.name, o.amount
FROM customers c
CROSS JOIN orders o;

-- SELF JOIN: join a table to itself (e.g., employee → manager)
SELECT e.name AS employee, m.name AS manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.id;

Q10. What's the difference between INNER JOIN and LEFT JOIN?
Answer: INNER JOIN returns only rows where the join key exists in BOTH tables. LEFT JOIN returns ALL rows from the left table, plus matching rows from the right table (NULLs where no match exists). Use INNER JOIN when you only want matched pairs (orders with their customers); use LEFT JOIN when you need to keep unmatched left rows (all customers whether or not they placed an order).
Q11. What is a SELF JOIN and when would you use it?
Answer: A join where a table is joined to itself. Common uses: employee → manager hierarchy (manager is also an employee), finding duplicate rows, comparing rows within the same table (e.g., pairs of customers in the same city). Use table aliases (e for employee, m for manager) to distinguish the two roles.
Q12. What is the difference between JOIN and UNION?
Answer: JOIN combines columns from two or more tables horizontally (adds more columns per row). UNION combines rows from two or more queries vertically (adds more rows). JOIN requires a related column; UNION requires the queries to have the same number of columns with compatible types. UNION removes duplicates; UNION ALL keeps them.
Q13. What is the difference between UNION and UNION ALL?
Answer: UNION combines the result sets and removes duplicate rows (requires a sort/hash to deduplicate — slower). UNION ALL combines them and keeps all rows including duplicates (faster, no dedup step). Use UNION when you need a distinct set; use UNION ALL when duplicates are acceptable or expected (e.g., combining logs from two days).

Q14. How do you find rows in Table A that don't have a match in Table B?
Answer:

-- Three equivalent patterns:

-- 1. LEFT JOIN ... WHERE NULL (most common in interviews)
SELECT a.*
FROM customers a
LEFT JOIN orders b ON a.id = b.customer_id
WHERE b.id IS NULL;

-- 2. NOT EXISTS (often faster, clearer intent)
SELECT *
FROM customers a
WHERE NOT EXISTS (
    SELECT 1 FROM orders b WHERE b.customer_id = a.id
);

-- 3. NOT IN (avoid when b.id can be NULL — NULLs in subquery break NOT IN)
SELECT *
FROM customers
WHERE id NOT IN (SELECT customer_id FROM orders);

Q15. What is a CROSS JOIN and when is it useful?
Answer: Returns the Cartesian product of two tables — every row in A paired with every row in B. SELECT * FROM colors CROSS JOIN sizes produces every color-size combination. Common uses: generating test data, building date × category grids for reports, combinatorial puzzles. Use sparingly on large tables — a 10K × 10K cross join produces 100M rows.

GROUP BY, HAVING, Aggregation (Q16–Q20)

Q16. What are the SQL aggregate functions?
Answer: COUNT() (rows or non-null values), SUM() (total), AVG() (mean), MIN() (smallest), MAX() (largest). COUNT(*) counts rows including NULLs; COUNT(column) counts non-NULL values in that column. Aggregates ignore NULLs by default. Use DISTINCT inside aggregate for unique values: COUNT(DISTINCT customer_id).

Q17. How do you find the second-highest salary in a table?
Answer:

-- Three approaches:

-- 1. Subquery with MAX (works on all DBs)
SELECT MAX(salary) FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

-- 2. LIMIT + OFFSET (MySQL/PostgreSQL)
SELECT DISTINCT salary FROM employees
ORDER BY salary DESC LIMIT 1 OFFSET 1;

-- 3. DENSE_RANK (PostgreSQL/Oracle/SQL Server — modern way)
SELECT salary FROM (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
    FROM employees
) ranked
WHERE rnk = 2;

Q18. How do you count employees per department?
Answer:

SELECT department, COUNT(*) AS employee_count
FROM employees
GROUP BY department
ORDER BY employee_count DESC;

Q19. How do you find departments with more than 10 employees?
Answer:

SELECT department, COUNT(*) AS n
FROM employees
GROUP BY department
HAVING COUNT(*) > 10;

-- WHERE filters rows; HAVING filters groups.
-- Don't write: GROUP BY ... WHERE COUNT(*) > 10  ← syntax error

Q20. What does GROUP BY do with NULL values?
Answer: NULLs are grouped together into a single group (NULL is treated as its own value for grouping). SELECT col, COUNT(*) FROM t GROUP BY col will include one row with NULL if any rows have NULL in col. This is different from most other operations where NULL is treated as unknown.

Subqueries & CTEs (Q21–Q25)

Q21. What is a subquery?
Answer: A query nested inside another query. Can appear in SELECT (scalar subquery), FROM (derived table), WHERE (filtered by subquery result), or HAVING. The subquery is evaluated first (in parentheses), and its result feeds the outer query. Correlated subqueries reference columns from the outer query and run once per outer row.

Q22. What is a CTE (Common Table Expression)?
Answer:

-- A CTE is a named temporary result set that exists only for the query.
-- Cleaner than nested subqueries, especially for multi-step logic.

WITH high_earners AS (
    SELECT department, employee_id, salary
    FROM employees
    WHERE salary > 100000
),
dept_totals AS (
    SELECT department, SUM(salary) AS total_salary
    FROM high_earners
    GROUP BY department
)
SELECT d.department, d.total_salary, COUNT(h.employee_id) AS n_high_earners
FROM dept_totals d
JOIN high_earners h ON d.department = h.department
GROUP BY d.department, d.total_salary;

-- CTEs can reference themselves recursively (organizational hierarchies, graphs)

Q23. What is the difference between correlated and non-correlated subqueries?
Answer: Non-correlated: subquery can run independently of the outer query (evaluated once). Faster and simpler. Correlated: subquery references columns from the outer query, so it must run once per outer row (slower on large data). Example correlated: SELECT e.name FROM employees e WHERE e.salary > (SELECT AVG(salary) FROM employees WHERE department = e.department).
Q24. What is the difference between EXISTS and IN?
Answer: -- IN: subquery returns a list; main query checks if value is in the list. SELECT name FROM customers WHERE id IN (SELECT customer_id FROM orders); -- EXISTS: subquery returns a boolean (true if any row matches); -- typically faster on large data because it short-circuits on first match. SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id);
Rule of thumb: use EXISTS when the subquery references the outer query (correlated); use IN for non-correlated lists.

SELECT name, salary, ROW_NUMBER() OVER (ORDER BY salary DESC) AS rn_row, RANK() OVER (ORDER BY salary DESC) AS rnk, DENSE_RANK() OVER (ORDER BY salary DESC) AS drnk FROM employees; -- If salaries are 100, 90, 90, 80: -- ROW_NUMBER: 1, 2, 3, 4 (always unique, no ties) -- RANK: 1, 2, 2, 4 (ties share rank, next rank skips) -- DENSE_RANK: 1, 2, 2, 3 (ties share rank, next rank doesn't skip) -- Use ROW_NUMBER for "top N per group"; RANK/DENSE_RANK for "all employees earning top salary".

-- Using ROW_NUMBER (top 3 strictly, even if there are ties at the boundary) SELECT * FROM ( SELECT name, department, salary, ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS rn FROM employees ) ranked WHERE rn <= 3; -- Using DENSE_RANK (includes ties at boundary) SELECT * FROM ( SELECT name, department, salary, DENSE_RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS rnk FROM employees ) ranked WHERE rnk <= 3;

-- Compare each row to the previous/next row in the same partition. SELECT order_date, amount, LAG(amount) OVER (ORDER BY order_date) AS prev_amount, LEAD(amount) OVER (ORDER BY order_date) AS next_amount, amount - LAG(amount) OVER (ORDER BY order_date) AS diff_from_prev FROM orders; -- Common use: month-over-month growth, sequential comparisons, detecting gaps.

-- Cumulative sum ordered by date SELECT order_date, amount, SUM(amount) OVER (ORDER BY order_date) AS running_total, SUM(amount) OVER (ORDER BY order_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS explicit_running_total FROM orders;

EXPLAIN SELECT * FROM orders WHERE customer_id = 12345; -- Shows how the DB plans to execute the query: -- - Index scan vs full table scan -- - Join order and join algorithm (nested loop, hash join, merge join) -- - Estimated row counts at each step -- Use EXPLAIN ANALYZE (PostgreSQL) to also see actual timings and row counts.

Property	Meaning
Atomicity	All operations in a transaction succeed or all fail (no partial state)
Consistency	Transaction moves DB from one valid state to another (constraints not violated)
Isolation	Concurrent transactions don't see each other's uncommitted changes
Durability	Committed changes survive crashes (written to disk, not just memory)

Property

Meaning

Atomicity

All operations in a transaction succeed or all fail (no partial state)

Consistency

Transaction moves DB from one valid state to another (constraints not violated)

Isolation

Concurrent transactions don't see each other's uncommitted changes

Durability

Committed changes survive crashes (written to disk, not just memory)

Level	Dirty reads	Non-repeatable reads	Phantom reads
READ UNCOMMITTED	Yes	Yes	Yes
READ COMMITTED (PostgreSQL default)	No	Yes	Yes
REPEATABLE READ (MySQL InnoDB default)	No	No	Yes
SERIALIZABLE	No	No	No

Level

Dirty reads

Non-repeatable reads

Phantom reads

READ UNCOMMITTED

Yes

READ COMMITTED (PostgreSQL default)

Yes

REPEATABLE READ (MySQL InnoDB default)

Yes

SERIALIZABLE

3-Week SQL Interview Preparation Plan

Week	Focus	Daily Target
Week 1	SELECT, WHERE, ORDER BY, basic JOINs, GROUP BY, HAVING	20 practice queries on HackerRank SQL
Week 2	Subqueries, window functions (ROW_NUMBER, RANK, LAG, LEAD), CTEs, indexes	10 problems per day on LeetCode or InterviewBit
Week 3	Mock interviews with timed query writing + 50 real interview SQL questions	1 full mock + 15 timed queries

Resources and Next Steps

For the full 25-question curated Q&A collection at all difficulty levels (Level 1 foundational, Level 2 intermediate, Level 3 advanced), see the TutorsBot SQL Tutorial and the DBMS Interview Questions guide for RDBMS-specific patterns (normalization, ACID, indexing). For related interview prep, see our Python Interview Questions, Java Interview Questions, and OOPs Interview Questions.

SQL Interview Questions 2026 Top 40 with Answers

Table of Contents

SQL Topic Weightage in 2026 Fresher Interviews

Related Articles

DBMS Interview Questions 2026 Top 40 with Answers

Which Free AI Interview Preparation Tools Work in 2026?

OOPs Interview Questions Java 2026 Top 40 with Answers

Java Interview Questions 2026 Top 40 with Answers

Try It in the Browser

Company Round Formats: SQL Coverage