Here are 10 practical SQL interview questions every developer should prepare.

1. What is the difference between WHERE and HAVING?

WHERE filters individual rows before grouping, while HAVING filters grouped results after GROUP BY.

SELECT DepartmentId, COUNT(*) AS EmployeeCount
FROM Employees
WHERE IsActive = 1
GROUP BY DepartmentId
HAVING COUNT(*) > 5;

In this query:

• WHERE removes inactive employees before grouping.

• HAVING returns only departments with more than five active employees.

2. What is the difference between INNER JOIN and LEFT JOIN?

An INNER JOIN returns only matching rows from both tables.

A LEFT JOIN returns every row from the left table and matching rows from the right table. If there is no match, the right-side columns contain NULL.

SELECT
    E.EmployeeId,
    E.EmployeeName,
    D.DepartmentName
FROM Employees E
LEFT JOIN Departments D
    ON E.DepartmentId = D.DepartmentId;

Use LEFT JOIN when the main table’s records must appear even when related information is missing.

3. How can you find duplicate records?

Use GROUP BY with HAVING COUNT(*) > 1.

SELECT Email, COUNT(*) AS DuplicateCount
FROM Customers
GROUP BY Email
HAVING COUNT(*) > 1;

Before deleting duplicates, determine which record must be retained. Never delete duplicate data without validating business rules and taking a backup where appropriate.

4. How can you find the second-highest salary?

A window function provides a clean solution:

WITH RankedSalaries AS
(
    SELECT
        EmployeeId,
        EmployeeName,
        Salary,
        DENSE_RANK() OVER (ORDER BY Salary DESC) AS SalaryRank
    FROM Employees
)
SELECT EmployeeId, EmployeeName, Salary
FROM RankedSalaries
WHERE SalaryRank = 2;

DENSE_RANK() assigns the same rank to equal salaries, so this query returns everyone receiving the second-highest distinct salary.

5. What is the difference between DELETE, TRUNCATE, and DROP?

DELETE

• Removes selected rows.

• Supports a WHERE condition.

• Leaves the table structure in place.

• Is fully logged in most database systems.

DELETE FROM Employees
WHERE EmployeeId = 101;

TRUNCATE

• Removes all rows.

• Does not support WHERE.

• Usually uses less logging than DELETE.

• Commonly resets an identity counter, depending on the database system.

TRUNCATE TABLE Employees;

DROP

• Removes the complete database object, including its structure.

DROP TABLE Employees;

These commands should be used with extreme care in production.

6. What is a CTE, and when should you use one?

A Common Table Expression, or CTE, is a named temporary result set available to the statement that immediately follows it.

WITH DepartmentTotals AS
(
    SELECT
        DepartmentId,
        COUNT(*) AS EmployeeCount
    FROM Employees
    GROUP BY DepartmentId
)
SELECT *
FROM DepartmentTotals
WHERE EmployeeCount > 10;

CTEs are helpful for:

• Improving query readability

• Breaking complex logic into understandable sections

• Writing recursive queries

• Removing duplicate rows using window functions

A CTE is not automatically faster than a subquery. Performance depends on the execution plan and query structure.

7. What is an index, and how does it improve performance?

An index helps the database locate rows without scanning an entire table.

For example:

CREATE INDEX IX_Employees_Email
ON Employees (Email);

This index may improve queries that search or join using the Email column.

However, indexes are not free. They:

• Consume storage

• Add work to INSERT, UPDATE, and DELETE operations

• Require maintenance

• Can be ineffective if created on unsuitable columns

A strong candidate should explain both the benefit and cost of indexing.

8. What is the difference between clustered and nonclustered indexes?

In SQL Server, a clustered index determines how table data is logically ordered and stored at the leaf level. A table can have only one clustered index.

A nonclustered index is a separate structure containing index keys and row locators. A table can have multiple nonclustered indexes.

A primary key does not always have to be clustered. The correct choice depends on access patterns, key width, uniqueness, and insert behavior.

9. Why might a query be slow even when it returns the correct result?

A correct query can still perform poorly because of:

• Missing or unsuitable indexes

• Returning unnecessary columns with SELECT *

• Non-sargable conditions

• Implicit data-type conversions

• Outdated statistics

• Large table scans

• Incorrect joins

• Parameter sensitivity

• Blocking or deadlocks

• Processing more rows than necessary

Example of a potentially non-sargable condition:

SELECT *
FROM Orders
WHERE YEAR(OrderDate) = 2026;

A more index-friendly version is:

SELECT *
FROM Orders
WHERE OrderDate >= '20260101'
  AND OrderDate <  '20270101';

A developer should inspect the actual execution plan and runtime statistics instead of guessing.

10. What is a transaction, and why is it important?

A transaction treats multiple database operations as one logical unit. Either all required operations succeed, or the transaction is rolled back.

BEGIN TRY
    BEGIN TRANSACTION;

    UPDATE Accounts
    SET Balance = Balance - 500
    WHERE AccountId = 1;

    UPDATE Accounts
    SET Balance = Balance + 500
    WHERE AccountId = 2;

    COMMIT TRANSACTION;
END TRY
BEGIN CATCH
    IF @@TRANCOUNT > 0
        ROLLBACK TRANSACTION;

    THROW;
END CATCH;

Transactions protect data consistency, but long-running transactions can increase blocking and raise the risk of deadlocks. Keep transactions focused and as short as practical.

Final Interview Tip

Do not prepare only definitions. Practise explaining:

• Why you selected a particular query

• How it behaves with duplicate or missing data

• What can go wrong in production

• How you would test its performance

• Which trade-offs you considered

Interviewers value developers who can connect SQL syntax to real production decisions.

Want to practise technical and resume-based mock interviews with AI?

Explore Way2Ask and prepare for your next interview with greater confidence.