SQL Interview Questions Mock Test

Everything you need to master the building blocks of SQL before moving to advanced topics.

• SQL definition, purpose, and how it interacts with relational databases

• Core data types: VARCHAR vs CHAR, INT vs BIGINT, TEXT vs VARCHAR, and ENUM

• NULL handling — what NULL means and how it differs from 0 or empty string

• Database vs table — structure, hierarchy, and CREATE operations

• SELECT * vs specific columns — performance and clarity trade-offs

• Filtering rows with WHERE clause using single and multiple conditions

Master the commands that define your database structure and manipulate the data inside it.

• CREATE TABLE with column definitions, data types, and inline constraints

• ALTER TABLE to add, modify, or drop columns on existing tables

• DROP TABLE and the difference between DROP, TRUNCATE, and DELETE

• INSERT vs INSERT INTO — syntax variations across SQL dialects

• UPDATE with and without WHERE — why a missing WHERE can be catastrophic

• DELETE operations and how they differ from TRUNCATE in transaction contexts

• Defining PRIMARY KEY, FOREIGN KEY, and UNIQUE constraints at table creation

Write precise, complex WHERE clauses using the full range of SQL filtering tools.

• IN operator to match against a list of values instead of chaining multiple ORs

• BETWEEN for range filtering — and why it is inclusive on both boundaries

• LIKE with % and _ wildcards for pattern matching on string columns

• IS NULL and IS NOT NULL — why = NULL never works and how NULL comparisons behave

• AND, OR, NOT operator combinations and their evaluation precedence

• Using parentheses to override default precedence and avoid logic bugs

• NOT IN and NOT BETWEEN for exclusion-based filtering scenarios

The most tested SQL topic in interviews — know exactly which JOIN to use and when.

• INNER JOIN — returning only rows that have a match in both tables

• LEFT OUTER JOIN — keeping all rows from the left table with NULLs for unmatched right rows

• RIGHT OUTER JOIN — keeping all rows from the right table with NULLs for unmatched left rows

• FULL OUTER JOIN — merging complete datasets and preserving all unmatched rows from both sides

• CROSS JOIN — generating a Cartesian product and when it is actually useful

• Joining 3 or more tables and managing multiple ON conditions

• Combining JOINs with WHERE, GROUP BY, and aggregate functions in a single query

• INNER JOIN vs implicit join using WHERE — differences in readability and behavior

Aggregate and filter grouped data correctly — a concept interviewers test in almost every round.

• GROUP BY rules — which columns must appear in SELECT and why

• Single column grouping to summarize data by one category

• Multi-column grouping to create more granular breakdowns

• HAVING clause — filtering groups after aggregation has been applied

• HAVING vs WHERE — the exact difference and when each one is required

• How GROUP BY treats NULL values — all NULLs are grouped together as one group

• Combining WHERE, GROUP BY, and HAVING in a single query in the correct order

• Complex HAVING conditions using multiple aggregate functions

Calculate summaries, counts, and statistics across rows and groups with SQL's built-in functions.

• COUNT(*) vs COUNT(column) — why they return different results when NULLs are present

• SUM and AVG — how both functions silently ignore NULL values in calculations

• MIN and MAX on numeric, string, and date columns

• Using multiple aggregate functions together in a single SELECT

• Per-group calculations by combining aggregate functions with GROUP BY

• Finding earliest and latest dates using MIN and MAX on date columns

• Calculating date differences and filtering results by computed date ranges

• NULL handling across all aggregate functions — what gets counted and what gets skipped

Understand how indexes work under the hood — the topic that separates junior from senior candidates.

• Clustered vs non-clustered indexes — how data is physically stored differently in each

• Composite indexes — creating indexes on multiple columns and column order importance

• Unique indexes — enforcing uniqueness at the index level vs constraint level

• Index seek vs index scan — when the optimizer uses each and which is faster

• Why functions in WHERE clauses (UPPER, LOWER, SUBSTRING) prevent index usage

• How INSERT, UPDATE, and DELETE operations affect index maintenance overhead

• When to rebuild or drop an index — fragmentation and maintenance considerations

• Covering indexes — when an index alone can satisfy a query without touching the table

Manipulate, format, and filter text and date data using SQL's built-in function library.

• LENGTH / LEN to measure string length across MySQL, PostgreSQL, and SQL Server

• UPPER and LOWER for case conversion — and why using them in WHERE breaks indexes

• Pattern matching with LIKE combined with string functions for flexible searches

• DATEDIFF and equivalent functions to calculate the gap between two dates

• Filtering rows by date ranges using BETWEEN, >= and <= on date columns

• Extracting date parts — year, month, day — using YEAR(), MONTH(), DAY() or EXTRACT()

• DECIMAL precision in numeric calculations and handling rounding in discount or price queries

• Type conversion and CAST / CONVERT for mixed data type operations

Write cleaner, more precise queries using sorting, deduplication, and aliasing techniques.

• SELECT DISTINCT to eliminate duplicate rows from query results

• Column aliases with AS to rename output columns for readability

• Table aliases to shorten long table names in multi-table queries

• ORDER BY ascending (ASC) and descending (DESC) on single columns

• Multi-column ORDER BY — sorting by a primary column then breaking ties with a secondary

• Combining AND, OR, and IN for multi-condition filtering without redundancy

• LIMIT and TOP / FETCH FIRST for returning a fixed number of rows

• Using subqueries in WHERE clauses to filter against dynamic result sets

Understand the structural decisions behind well-designed relational databases.

• PRIMARY KEY — uniquely identifying each row and why every table should have one

• UNIQUE KEY vs PRIMARY KEY — allowing NULLs, multiple unique keys per table

• FOREIGN KEY relationships — enforcing referential integrity between tables

• NOT NULL constraint — preventing missing values in critical columns

• CHECK constraint — validating that column values meet a specific condition

• DEFAULT constraint — automatically assigning a value when none is provided

• NULL vs 0 vs empty string — three distinct states and how each behaves in queries

• AUTO_INCREMENT (MySQL) and IDENTITY (SQL Server) for auto-generating primary key values