Top 20 SQL Interview Questions and Answers

SQL (Structured Query Language) is a standard programming language used to manage and manipulate relational databases.

Main types of SQL statements:

• DDL (Data Definition Language): CREATE, ALTER, DROP, TRUNCATE - defines database structure
• DML (Data Manipulation Language): SELECT, INSERT, UPDATE, DELETE - manipulates data
• DCL (Data Control Language): GRANT, REVOKE - controls access permissions
• TCL (Transaction Control Language): COMMIT, ROLLBACK, SAVEPOINT - manages transactions

Example:

DDL (Data Definition Language):

• Defines database structure and schema
• Commands: CREATE, ALTER, DROP, TRUNCATE, RENAME
• Auto-committed (cannot be rolled back)
• Affects the structure of the database

DML (Data Manipulation Language):

• Manipulates data within database objects  
• Commands: SELECT, INSERT, UPDATE, DELETE
• Not auto-committed (can be rolled back)
• Affects the data in the database

DCL (Data Control Language):

• Controls access and permissions
• Commands: GRANT, REVOKE
• Manages user privileges

TCL (Transaction Control Language):

• Manages transactions and database consistency
• Commands: COMMIT, ROLLBACK, SAVEPOINT
• Controls transaction behavior

DELETE:

• DML command - removes rows from a table
• Can use WHERE clause to delete specific rows
• Can be rolled back (if not committed)
• Maintains table structure
• Slower for large datasets
• Triggers are fired

TRUNCATE:

• DDL command - removes all rows from a table
• Cannot use WHERE clause
• Cannot be rolled back
• Maintains table structure
• Faster than DELETE
• Resets auto-increment counter
• Triggers are NOT fired

DROP:

• DDL command - removes entire table/database
• Removes table structure and all data
• Cannot be rolled back
• Frees up space completely

Example:

WHERE Clause:

• Filters rows before grouping
• Used with SELECT, UPDATE, DELETE
• Cannot use aggregate functions
• Applied to individual rows
• Used before GROUP BY

HAVING Clause:

• Filters groups after grouping
• Used only with SELECT and GROUP BY
• Can use aggregate functions (COUNT, SUM, AVG, etc.)
• Applied to groups
• Used after GROUP BY

Example:

PRIMARY KEY:

• Uniquely identifies each row in a table
• Cannot contain NULL values
• Only one PRIMARY KEY per table
• Automatically creates a unique index
• Ensures entity integrity

FOREIGN KEY:

• References PRIMARY KEY of another table
• Maintains referential integrity
• Can contain NULL values
• Multiple FOREIGN KEYs allowed per table
• Prevents invalid data insertion

Example:

INNER JOIN:

• Returns only matching rows from both tables
• Excludes non-matching rows

LEFT JOIN (LEFT OUTER JOIN):

• Returns all rows from left table
• Returns matching rows from right table
• NULL for non-matching right table rows

RIGHT JOIN (RIGHT OUTER JOIN):

• Returns all rows from right table
• Returns matching rows from left table
• NULL for non-matching left table rows

FULL JOIN (FULL OUTER JOIN):

• Returns all rows from both tables
• NULL for non-matching rows from either table

Example:

GROUP BY:

• Groups rows with same values into summary rows
• Used with aggregate functions (COUNT, SUM, AVG, MAX, MIN)
• Reduces multiple rows into single rows

ORDER BY:

• Sorts the result set in ascending or descending order
• Can sort by one or more columns
• Default is ASC (ascending)

Example:

Subqueries are queries nested inside another query. They can be used in SELECT, FROM, WHERE, and HAVING clauses.

Types:

• Scalar Subquery: Returns single value
• Row Subquery: Returns single row
• Column Subquery: Returns single column
• Table Subquery: Returns table (used in FROM clause)

When to use:

• When you need data from multiple tables
• To filter based on aggregated values
• To compare values with aggregated results
• When JOIN might be complex

Example:

A view is a virtual table based on the result of a SQL query. It doesn't store data but displays data from underlying tables.

Advantages:

• Simplifies complex queries
• Provides security by hiding sensitive data
• Allows data abstraction
• Can be used like a regular table

Types:

• Simple View: Based on single table
• Complex View: Based on multiple tables, includes functions

Example:

Indexes are database objects that improve query performance by providing faster data retrieval.

Purpose:

• Speed up SELECT queries
• Enforce uniqueness (UNIQUE index)
• Improve JOIN performance
• Speed up ORDER BY and GROUP BY operations

Advantages:

• Faster data retrieval
• Improved query performance
• Enforces uniqueness
• Speeds up sorting and grouping

Disadvantages:

• Additional storage space required
• Slower INSERT, UPDATE, DELETE operations (indexes need to be updated)
• Maintenance overhead
• More indexes = more storage and slower writes

Example:

Normalization is the process of organizing data in a database to reduce redundancy and improve data integrity.

1NF (First Normal Form):

• Each column contains atomic values (no multi-valued attributes)
• Each row is unique
• No repeating groups

2NF (Second Normal Form):

• Must be in 1NF
• All non-key attributes fully dependent on primary key
• No partial dependencies

3NF (Third Normal Form):

• Must be in 2NF
• No transitive dependencies
• Non-key attributes independent of each other

BCNF (Boyce-Codd Normal Form):

• Must be in 3NF
• Every determinant is a candidate key
• Stricter than 3NF

Example: A table with employee_id, employee_name, department_id, department_name violates 3NF because department_name depends on department_id, not directly on employee_id. Solution: Split into employees and departments tables.

Stored Procedures:

• Pre-compiled SQL code stored in database
• Can return zero, one, or multiple values
• Can have input and output parameters
• Can contain DML statements (INSERT, UPDATE, DELETE)
• Cannot be used in SELECT statements
• Can call functions
• Better for complex business logic

Functions:

• Must return a single value or table
• Can have only input parameters
• Cannot contain DML statements (only SELECT)
• Can be used in SELECT statements
• Cannot call stored procedures
• Better for calculations and data retrieval

Example:

ACID properties ensure reliable database transactions:

A - Atomicity:

• Transaction is all-or-nothing
• Either all operations succeed or all fail
• No partial transactions

C - Consistency:

• Database remains in valid state before and after transaction
• All constraints and rules are maintained
• No data corruption

I - Isolation:

• Concurrent transactions don't interfere with each other
• Each transaction sees consistent data
• Prevents dirty reads, phantom reads

D - Durability:

• Committed transactions persist even after system failure
• Changes are permanently saved
• Uses transaction logs for recovery

Example: When transferring money between accounts, either both accounts are updated (commit) or neither is updated (rollback), ensuring data consistency.

A trigger is a stored procedure that automatically executes in response to specific events (INSERT, UPDATE, DELETE) on a table.

Types:

• BEFORE Trigger: Executes before the event
• AFTER Trigger: Executes after the event
• INSTEAD OF Trigger: Replaces the event (used with views)

When to use:

• Audit logging (track changes)
• Data validation
• Enforcing business rules
• Maintaining referential integrity
• Automatic calculations

Example:

Clustered Index:

• Determines the physical order of data in a table
• Only one clustered index per table
• Data rows are stored in sorted order
• Faster for range queries
• Primary key is typically a clustered index
• Slower for INSERT operations (data needs to be reordered)

Non-Clustered Index:

• Does not affect physical order of data
• Multiple non-clustered indexes allowed per table
• Contains pointers to data rows
• Separate structure from table data
• Faster for INSERT operations
• Requires additional storage space

Example:

Key Difference: Clustered index = table data is sorted, Non-clustered index = separate index structure with pointers to data.

Method 1: Using Subquery

Method 2: Using LIMIT/OFFSET

Method 3: Using ROW_NUMBER()

Method 4: Using DENSE_RANK() (handles ties)

Basic Query:

With Department Names (JOIN):

With Ordering:

With Filtering (HAVING):

Method 1: Using GROUP BY and HAVING

Method 2: Using Window Functions

Method 3: Using Self-Join

To Delete Duplicates (keep one):

Update with WHERE condition:

Update with CASE statement:

Update with JOIN:

Update with Subquery:

Using BETWEEN:

Using Comparison Operators:

Using DATE functions (MySQL):

Last 30 days:

Current month: