# DBMS Interview Questions: 174 Questions Across 43 Topics

> DBMS interview questions grouped by topic: 174 questions from 43 notes on normalization, SQL, transactions and ACID properties.

Canonical: https://devsunite.com/resources/core-subjects/dbms
Last updated: 2026-11-22

Database fundamentals: transactions, normalization, SQL, and the ACID guarantees that keep real data trustworthy.

43 topics across 6 categories, 174 interview questions

## Top 10 DBMS interview questions with answers

1. **What problems does a DBMS solve that a plain file system doesn't?** Expect a clear list: concurrency control, structure enforcement, efficient search via indexing, and crash recovery. [What Is a DBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-dbms)
2. **What's the difference between a candidate key and a primary key?** A table can have multiple candidate keys (each independently sufficient to uniquely identify a row); the primary key is the one officially chosen from among them. [Keys in the Relational Model](https://devsunite.com/resources/core-subjects/dbms/keys-in-relational-model)
3. **What is normalization, and why does it matter?** The process of restructuring a schema through defined stages (normal forms) to eliminate redundancy and the anomalies it causes. [Understanding Normalization](https://devsunite.com/resources/core-subjects/dbms/understand-normalisation)
4. **What's the difference between 3NF and BCNF?** BCNF requires the left side of every functional dependency to be a superkey, with no exception; 3NF allows a narrow exception when the right side is part of some candidate key. [Boyce-Codd Normal Form (BCNF)](https://devsunite.com/resources/core-subjects/dbms/boyce-codd-normal-form-bcnf)
5. **Name and briefly explain all four ACID properties.** Atomicity (all-or-nothing), Consistency (valid state to valid state), Isolation (concurrent transactions don't interfere), Durability (committed changes survive crashes). [ACID Properties: Complete Overview](https://devsunite.com/resources/core-subjects/dbms/complete-overview)
6. **Name the four standard isolation levels, from weakest to strongest.** Read Uncommitted, Read Committed, Repeatable Read, Serializable. [Isolation in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/isolation)
7. **What's the difference between INNER JOIN and LEFT JOIN?** INNER JOIN only returns rows with a match in both tables; LEFT JOIN returns every row from the left table regardless, with NULLs where there's no match on the right. [SQL Joins](https://devsunite.com/resources/core-subjects/dbms/sql-joins)
8. **What is an index, and why does it help?** A separate sorted data structure that lets the database find matching rows without scanning the entire table. [SQL Indexes](https://devsunite.com/resources/core-subjects/dbms/sql-indexes)
9. **What's the difference between DELETE, TRUNCATE, and DROP?** DELETE removes matching rows one at a time and keeps the table; TRUNCATE removes all rows at once (faster) and keeps the table; DROP removes the table entirely, structure and all. [Other SQL Commands](https://devsunite.com/resources/core-subjects/dbms/other-sql-commands)
10. **What is a dirty read?** Reading another transaction's uncommitted changes, which might later be rolled back and never actually take effect. [Problems in Concurrency Control](https://devsunite.com/resources/core-subjects/dbms/problems-in-concurrency-control)

## ACID Properties

- [What Is a Transaction in a Database?](https://devsunite.com/resources/core-subjects/dbms/what-is-a-transaction) - A transaction is a group of one or more database operations that are executed as a single logical unit of work, either all of them succeed or none of them do.
- [Atomicity in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/atomicity) - Atomicity guarantees a database transaction either completes entirely or has no effect at all, with no partial updates ever left visible.
- [Consistency in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/consistency) - Consistency guarantees a transaction only ever moves a database from one valid state to another, never leaving behind data that breaks a defined rule or constraint.
- [Isolation in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/isolation) - Isolation controls how much one transaction's in-progress changes are visible to other transactions running at the same time, so concurrent transactions don't interfere with each other's results.
- [Durability in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/durability) - Durability guarantees that once a transaction commits, its changes survive permanently, even through a crash, power loss, or system restart immediately afterward.
- [ACID Properties: Complete Overview](https://devsunite.com/resources/core-subjects/dbms/complete-overview) - Atomicity, Consistency, Isolation, and Durability together define what makes a database transaction trustworthy, each guarding a different way a transaction could otherwise go wrong.

## Introduction

- [What Is a DBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-dbms) - A DBMS is software that lets you create, store, query, and manage data reliably, instead of handling raw files yourself.
- [DBA (Database Administrator) and Functions](https://devsunite.com/resources/core-subjects/dbms/dba-and-functions) - A DBA is the person responsible for keeping a database running, secure, performant, and recoverable, a role that spans design, tuning, security, and backups.
- [DBMS Architecture (1-Tier, 2-Tier, 3-Tier)](https://devsunite.com/resources/core-subjects/dbms/dbms-architecture) - DBMS architecture describes how many separate layers sit between a user and the actual database, which affects scalability, security, and maintainability.
- [Database Languages (DDL, DML, DCL, TCL)](https://devsunite.com/resources/core-subjects/dbms/database-languages) - SQL is really four sub-languages in one: DDL defines structure, DML manipulates data, DCL controls access, and TCL manages transactions.
- [Data Abstraction (Physical, Logical, View Levels)](https://devsunite.com/resources/core-subjects/dbms/data-abstraction) - Data abstraction hides the messy details of how data is physically stored, presenting users and applications with a simpler, more usable view instead.
- [Important DBMS Terms](https://devsunite.com/resources/core-subjects/dbms/important-terms) - A quick-reference glossary of the core DBMS vocabulary, schema, instance, data model, metadata, and more, that every other topic in this section builds on.

## RDBMS

- [What Is an RDBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-rdbms) - An RDBMS is a DBMS built specifically around the relational model: data stored in tables, related to each other through shared keys.
- [Introduction to the ER Model](https://devsunite.com/resources/core-subjects/dbms/introduction-to-er-model) - The ER model is a way to plan a database's structure visually, before writing any SQL, by mapping out entities, their attributes, and how they relate.
- [How to Draw an ER Diagram](https://devsunite.com/resources/core-subjects/dbms/how-to-draw-an-er-diagram) - A practical, step-by-step process for turning a set of requirements into a real ER diagram, from listing entities to marking cardinality.
- [Introduction to the Relational Model](https://devsunite.com/resources/core-subjects/dbms/introduction-to-relational-model) - The relational model represents all data as tables of rows and columns, with a small set of formal rules about what makes a table valid.
- [Keys in the Relational Model](https://devsunite.com/resources/core-subjects/dbms/keys-in-relational-model) - Keys are how the relational model uniquely identifies rows and connects tables together, and there are several distinct kinds worth knowing apart.

## RDBMS Design

- [Features of a Good Relational Database Design](https://devsunite.com/resources/core-subjects/dbms/features-of-good-design) - A well-designed relational schema minimizes redundancy, preserves data integrity, and avoids the update/insert/delete anomalies that come from a poor structure.
- [Functional Dependencies and Their Types](https://devsunite.com/resources/core-subjects/dbms/functional-dependencies-and-types) - A functional dependency describes when one column's value determines another's, and it's the mathematical foundation every normal form is built on.
- [Introduction to Decomposition](https://devsunite.com/resources/core-subjects/dbms/introduction-to-decomposition) - Decomposition splits one table into several smaller, better-structured tables, and it must be done carefully to avoid losing or corrupting data.
- [Understanding Normalization](https://devsunite.com/resources/core-subjects/dbms/understand-normalisation) - Normalization is the step-by-step process of restructuring a schema through a series of normal forms, each eliminating a specific kind of redundancy.
- [First Normal Form (1NF)](https://devsunite.com/resources/core-subjects/dbms/first-normal-form-1nf) - 1NF requires every cell in a table to hold a single, atomic value, with no lists, sets, or repeating groups packed into one column.
- [Second Normal Form (2NF)](https://devsunite.com/resources/core-subjects/dbms/second-normal-form-2nf) - 2NF builds on 1NF by requiring every non-key column to depend on the entire primary key, not just part of it, relevant only when the key is composite.
- [Third Normal Form (3NF)](https://devsunite.com/resources/core-subjects/dbms/third-normal-form-3nf) - 3NF builds on 2NF by requiring every non-key column to depend directly on the key, not indirectly through another non-key column.
- [Boyce-Codd Normal Form (BCNF)](https://devsunite.com/resources/core-subjects/dbms/boyce-codd-normal-form-bcnf) - BCNF tightens 3NF further: for every functional dependency in a table, the determining side must be a superkey, closing a narrow edge case 3NF can miss.

## SQL

- [Introduction to SQL](https://devsunite.com/resources/core-subjects/dbms/introduction-to-sql) - SQL is the standard language for defining, querying, and modifying data in a relational database, built around a small set of commands that read like structured English.
- [SQL Data Types](https://devsunite.com/resources/core-subjects/dbms/sql-datatypes) - SQL data types define what kind of value a column can hold, and choosing the right one affects both correctness (what values are even allowed) and storage efficiency.
- [Basic SQL Commands](https://devsunite.com/resources/core-subjects/dbms/basic-sql-commands) - SELECT, INSERT, UPDATE, DELETE, and CREATE are the five commands that cover the large majority of everyday SQL work: reading, adding, changing, removing, and defining data.
- [Other SQL Commands](https://devsunite.com/resources/core-subjects/dbms/other-sql-commands) - Beyond the core CRUD commands, SQL includes ALTER, DROP, and TRUNCATE for changing or removing structure and data at a larger scale, each with real, different consequences.
- [SQL Aggregate Functions](https://devsunite.com/resources/core-subjects/dbms/aggregate-functions) - Aggregate functions like COUNT, SUM, AVG, MIN, and MAX collapse many rows into a single summary value, often combined with GROUP BY to summarize data per category.
- [SQL Joins](https://devsunite.com/resources/core-subjects/dbms/sql-joins) - Joins combine rows from two or more tables based on a related column, letting you query across normalized tables as if they were one, without duplicating data.
- [SQL Views](https://devsunite.com/resources/core-subjects/dbms/sql-views) - A view is a saved, named SQL query that behaves like a virtual table, letting you reuse a complex query and control what underlying data is exposed.
- [SQL Indexes](https://devsunite.com/resources/core-subjects/dbms/sql-indexes) - An index is a separate data structure that lets the database find matching rows quickly, without scanning the entire table, at the cost of extra storage and slower writes.
- [SQL Subqueries](https://devsunite.com/resources/core-subjects/dbms/sql-subqueries) - A subquery is a query nested inside another query, used to compute an intermediate result that the outer query then filters on, joins against, or selects from.
- [SQL Stored Procedures](https://devsunite.com/resources/core-subjects/dbms/sql-stored-procedures) - A stored procedure is a named, reusable block of SQL logic saved inside the database itself, which can be called by name instead of re-sending the full logic every time.

## Transaction Processing

- [What Is Transaction Processing?](https://devsunite.com/resources/core-subjects/dbms/what-is-transaction-processing) - Transaction processing is how a system records each business event, like a payment or a booking, as an all-or-nothing transaction, and how the database runs many of them at once correctly.
- [Schedules and Their Types](https://devsunite.com/resources/core-subjects/dbms/schedules-and-types) - A schedule is the actual order in which operations from multiple concurrent transactions get executed, and whether that order is safe depends on whether it's serial, serializable, or neither.
- [Serializability](https://devsunite.com/resources/core-subjects/dbms/serializability) - Serializability is the property of a concurrent schedule producing exactly the same result as some serial execution of the same transactions, checked in practice via conflict or view equivalence.
- [What Is Concurrency Control?](https://devsunite.com/resources/core-subjects/dbms/what-is-concurrency-control) - Concurrency control is the set of techniques a database uses to let multiple transactions run at the same time while still guaranteeing a correct, serializable result.
- [Problems in Concurrency Control](https://devsunite.com/resources/core-subjects/dbms/problems-in-concurrency-control) - Without proper concurrency control, running transactions at the same time can produce dirty reads, lost updates, and unrepeatable reads, three distinct, well-known failure modes.
- [Locking Protocols](https://devsunite.com/resources/core-subjects/dbms/locking-protocols) - Locking protocols, especially Two-Phase Locking, are rules that govern when a transaction can acquire and release locks, specifically designed to guarantee serializable schedules.
- [Deadlocks in Transaction Processing](https://devsunite.com/resources/core-subjects/dbms/deadlocks) - A deadlock happens when two or more transactions each hold a lock the other needs, and all of them wait forever unless the database steps in to break the cycle.
- [Recoverability of Schedules](https://devsunite.com/resources/core-subjects/dbms/recoverability) - A schedule is recoverable if no transaction commits before every other transaction whose changes it read has already committed, avoiding a rollback that would be impossible to undo cleanly.

## All 174 DBMS interview questions

### ACID Properties

- [What Is a Transaction in a Database?](https://devsunite.com/resources/core-subjects/dbms/what-is-a-transaction)

1. What is a transaction, in one sentence?
2. What do BEGIN, COMMIT, and ROLLBACK each do?
3. Why wrap multiple statements in one transaction instead of running them separately?
4. What happens if the application crashes mid-transaction, before COMMIT?

- [Atomicity in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/atomicity)

1. What does atomicity actually guarantee, in one sentence?
2. How does a database implement atomicity under the hood?
3. What happens if the database crashes in the middle of a transaction?
4. Give a real example of why atomicity matters.
5. How is atomicity different from consistency?

- [Consistency in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/consistency)

1. What does consistency actually guarantee?
2. How is consistency different from atomicity?
3. Who enforces consistency, the application or the database?
4. Give an example of a consistency violation the database would block.

- [Isolation in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/isolation)

1. Name the four standard isolation levels, from weakest to strongest.
2. What's a dirty read, and which isolation level allows it?
3. What's the difference between a non-repeatable read and a phantom read?
4. What's the tradeoff of using Serializable everywhere?

- [Durability in ACID Transactions](https://devsunite.com/resources/core-subjects/dbms/durability)

1. What does durability guarantee?
2. How is durability implemented?
3. How is durability different from atomicity?
4. Why can't a database just keep committed data in memory for speed?

- [ACID Properties: Complete Overview](https://devsunite.com/resources/core-subjects/dbms/complete-overview)

1. Name and briefly explain all four ACID properties.
2. Which ACID property would fail if two people booked the last item in stock at the same time and both succeeded?
3. Give an example of one transaction that would test all four properties at once.
4. Why do some databases intentionally relax ACID guarantees?

### Introduction

- [What Is a DBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-dbms)

1. What problems does a DBMS solve that a plain file system doesn't?
2. What's the difference between a database and a DBMS?
3. Name some real DBMS software you've used.
4. What's a schema?

- [DBA (Database Administrator) and Functions](https://devsunite.com/resources/core-subjects/dbms/dba-and-functions)

1. What are the main responsibilities of a DBA?
2. How would you investigate a slow query?
3. Why is testing backups important, not just taking them?
4. What's the principle of least privilege, and why does it matter for database security?

- [DBMS Architecture (1-Tier, 2-Tier, 3-Tier)](https://devsunite.com/resources/core-subjects/dbms/dbms-architecture)

1. What's the difference between 2-tier and 3-tier architecture?
2. Why is 3-tier architecture considered more secure?
3. Give a real example of each architecture.
4. What are the advantages of separating the application tier from the database tier?

- [Database Languages (DDL, DML, DCL, TCL)](https://devsunite.com/resources/core-subjects/dbms/database-languages)

1. What's the difference between DDL and DML?
2. Is `TRUNCATE` DDL or DML, and why does that matter?
3. What do `GRANT` and `REVOKE` do?
4. Why would you wrap multiple DML statements in a transaction?

- [Data Abstraction (Physical, Logical, View Levels)](https://devsunite.com/resources/core-subjects/dbms/data-abstraction)

1. What are the three levels of data abstraction in a DBMS?
2. What's the difference between physical and logical data independence?
3. Why does this separation matter in practice?
4. How does a SQL `VIEW` relate to this concept?

- [Important DBMS Terms](https://devsunite.com/resources/core-subjects/dbms/important-terms)

1. What's the difference between a schema and an instance?
2. What is metadata, and where is it stored?
3. What's a tuple, in relational database terms?
4. Name some data models other than the relational model.

### RDBMS

- [What Is an RDBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-rdbms)

1. What makes a database 'relational'?
2. Is every DBMS an RDBMS?
3. What's the role of a foreign key in an RDBMS?
4. Why use multiple related tables instead of one big table?

- [Introduction to the ER Model](https://devsunite.com/resources/core-subjects/dbms/introduction-to-er-model)

1. What are the three core components of an ER model?
2. What's the difference between one-to-many and many-to-many relationships?
3. Why can't a many-to-many relationship be represented with a single foreign key?
4. Walk me through modeling a real-world scenario as an ER diagram.

- [How to Draw an ER Diagram](https://devsunite.com/resources/core-subjects/dbms/how-to-draw-an-er-diagram)

1. Walk me through how you'd design a schema for [some scenario].
2. How do you represent a many-to-many relationship in an actual database?
3. What notation do you use for ER diagrams?
4. What do you do after identifying a many-to-many relationship?

- [Introduction to the Relational Model](https://devsunite.com/resources/core-subjects/dbms/introduction-to-relational-model)

1. Who proposed the relational model, and roughly when?
2. What does it mean for a value to be atomic in the relational model?
3. What's the difference between degree and cardinality of a relation?
4. Why does every row in a relation need to be unique?

- [Keys in the Relational Model](https://devsunite.com/resources/core-subjects/dbms/keys-in-relational-model)

1. What's the difference between a candidate key and a primary key?
2. What's the difference between a super key and a candidate key?
3. What is a foreign key, and what can it reference?
4. When would you use a composite key?
5. Why might a surrogate key be preferred over a natural key as a primary key?

### RDBMS Design

- [Features of a Good Relational Database Design](https://devsunite.com/resources/core-subjects/dbms/features-of-good-design)

1. What are the three classic anomalies a poor schema design can cause?
2. Give an example of an update anomaly.
3. What does 'lossless decomposition' mean?
4. How does normalization relate to avoiding these anomalies?

- [Functional Dependencies and Their Types](https://devsunite.com/resources/core-subjects/dbms/functional-dependencies-and-types)

1. What is a functional dependency, in your own words?
2. What's the difference between a partial and a full functional dependency?
3. What's a transitive dependency, and why does it matter?
4. Identify the functional dependencies in this table.

- [Introduction to Decomposition](https://devsunite.com/resources/core-subjects/dbms/introduction-to-decomposition)

1. What does it mean for a decomposition to be lossless?
2. What does dependency preservation mean, and why does it matter?
3. How do you know if a decomposition is lossless?
4. Can a decomposition be lossless but not dependency-preserving?

- [Understanding Normalization](https://devsunite.com/resources/core-subjects/dbms/understand-normalisation)

1. What is normalization, and why does it matter?
2. Walk me through normalizing this table.
3. What's the tradeoff of normalizing a schema?
4. What normal form do most production schemas target?

- [First Normal Form (1NF)](https://devsunite.com/resources/core-subjects/dbms/first-normal-form-1nf)

1. What does First Normal Form require?
2. Is a table with a `phone1`, `phone2`, `phone3` column set in 1NF?
3. How do you fix a 1NF violation?
4. Why does 1NF matter for querying?

- [Second Normal Form (2NF)](https://devsunite.com/resources/core-subjects/dbms/second-normal-form-2nf)

1. What does Second Normal Form require, beyond 1NF?
2. When is 2NF automatically satisfied?
3. Identify the 2NF violation in this table.
4. How do you fix a partial dependency?

- [Third Normal Form (3NF)](https://devsunite.com/resources/core-subjects/dbms/third-normal-form-3nf)

1. What does Third Normal Form require, beyond 2NF?
2. Identify the transitive dependency in this table.
3. What's the difference between 2NF and 3NF?
4. Why is 3NF often considered the practical target for real schemas?

- [Boyce-Codd Normal Form (BCNF)](https://devsunite.com/resources/core-subjects/dbms/boyce-codd-normal-form-bcnf)

1. What's the difference between 3NF and BCNF?
2. Give an example of a table in 3NF but not BCNF.
3. Is BCNF always achievable without losing dependency preservation?
4. Why do many real schemas stop at 3NF instead of going to BCNF?

### SQL

- [Introduction to SQL](https://devsunite.com/resources/core-subjects/dbms/introduction-to-sql)

1. What does SQL stand for, and what is it used for?
2. What are DDL, DML, DCL, and TCL?
3. Is SQL the same across every database?
4. What's the difference between DELETE and DROP?

- [SQL Data Types](https://devsunite.com/resources/core-subjects/dbms/sql-datatypes)

1. Why shouldn't you store money in a FLOAT column?
2. What's the difference between CHAR and VARCHAR?
3. What's DECIMAL(10, 2) mean?
4. When would you use TEXT instead of VARCHAR?

- [Basic SQL Commands](https://devsunite.com/resources/core-subjects/dbms/basic-sql-commands)

1. What are the five most commonly used SQL commands?
2. What happens if you run UPDATE or DELETE without a WHERE clause?
3. How would you safely test a DELETE before running it?
4. What's the difference between DELETE and UPDATE?

- [Other SQL Commands](https://devsunite.com/resources/core-subjects/dbms/other-sql-commands)

1. What's the difference between DELETE, TRUNCATE, and DROP?
2. Why is TRUNCATE usually faster than DELETE with no condition?
3. Can TRUNCATE be rolled back?
4. When would you use ALTER TABLE?

- [SQL Aggregate Functions](https://devsunite.com/resources/core-subjects/dbms/aggregate-functions)

1. Name the five common aggregate functions.
2. What's the difference between WHERE and HAVING?
3. Why can't you use an aggregate function in a WHERE clause?
4. How would you find the customer with the highest total spend?

- [SQL Joins](https://devsunite.com/resources/core-subjects/dbms/sql-joins)

1. What's the difference between INNER JOIN and LEFT JOIN?
2. How would you find customers who have never placed an order?
3. What does a FULL JOIN return?
4. Why use joins instead of storing all the data in one big table?

- [SQL Views](https://devsunite.com/resources/core-subjects/dbms/sql-views)

1. What is a view?
2. Does a view store data?
3. Why would you use a view instead of just running the full query every time?
4. What's the tradeoff of a materialized view versus a regular view?

- [SQL Indexes](https://devsunite.com/resources/core-subjects/dbms/sql-indexes)

1. What is an index, and why does it help?
2. What's the tradeoff of adding an index?
3. When would you NOT want to add an index?
4. How would you check if a slow query is missing an index?

- [SQL Subqueries](https://devsunite.com/resources/core-subjects/dbms/sql-subqueries)

1. What is a subquery?
2. What's a correlated subquery?
3. Can every subquery be rewritten as a JOIN?
4. Give an example of when you'd need a correlated subquery instead of a simple one.

- [SQL Stored Procedures](https://devsunite.com/resources/core-subjects/dbms/sql-stored-procedures)

1. What is a stored procedure?
2. What's a real benefit of using a stored procedure?
3. What's a real downside?
4. When might a team deliberately avoid stored procedures?

### Transaction Processing

- [What Is Transaction Processing?](https://devsunite.com/resources/core-subjects/dbms/what-is-transaction-processing)

1. What is transaction processing responsible for?
2. What's a lost update, and how do you prevent it?
3. What is the difference between OLTP and OLAP?
4. What are the states of a transaction?

- [Schedules and Their Types](https://devsunite.com/resources/core-subjects/dbms/schedules-and-types)

1. What is a schedule?
2. What's the difference between a serial and a serializable schedule?
3. Why not just always use serial schedules to guarantee correctness?
4. How would you recognize a non-serializable schedule?

- [Serializability](https://devsunite.com/resources/core-subjects/dbms/serializability)

1. What does it mean for a schedule to be serializable?
2. What's the difference between conflict serializability and view serializability?
3. Which one do real databases actually use?
4. How do you check if two operations conflict?

- [What Is Concurrency Control?](https://devsunite.com/resources/core-subjects/dbms/what-is-concurrency-control)

1. What is concurrency control?
2. What's the difference between pessimistic and optimistic concurrency control?
3. When would you choose optimistic over pessimistic concurrency control?
4. What happens when an optimistic concurrency check fails at commit time?

- [Problems in Concurrency Control](https://devsunite.com/resources/core-subjects/dbms/problems-in-concurrency-control)

1. What is a dirty read?
2. What is a lost update, concretely?
3. What is an unrepeatable read?
4. Which isolation level would you need to prevent lost updates entirely?

- [Locking Protocols](https://devsunite.com/resources/core-subjects/dbms/locking-protocols)

1. What are the two phases in Two-Phase Locking?
2. What does 2PL guarantee, and why?
3. What's the difference between basic 2PL and strict 2PL?
4. How can 2PL lead to a deadlock?

- [Deadlocks in Transaction Processing](https://devsunite.com/resources/core-subjects/dbms/deadlocks)

1. What is a deadlock?
2. How does a database detect a deadlock?
3. How does a database resolve a detected deadlock?
4. What's a practical way application code can reduce deadlock frequency?

- [Recoverability of Schedules](https://devsunite.com/resources/core-subjects/dbms/recoverability)

1. What does it mean for a schedule to be recoverable?
2. What goes wrong in an unrecoverable schedule?
3. What's a cascading rollback?
4. How is recoverability different from serializability?

## Frequently asked questions

### Where do these dbms interview questions come from?

Each of the 174 questions comes from the "What interviewers actually ask" section of one of 43 DBMS topic notes. Every question links to its topic page, where it is answered next to the explanation it tests.

### What does the DBMS section cover?

43 topics across 6 categories: Database fundamentals: transactions, normalization, SQL, and the ACID guarantees that keep real data trustworthy.

### Is it free to read?

Yes. Every article is free to read with no account required. Creating a free DevsUnite account lets you mark topics as read and track your progress across every Core Subjects article.

## Related

- [Operating Systems](https://devsunite.com/resources/core-subjects/operating-systems)
- [Computer Networks](https://devsunite.com/resources/core-subjects/computer-networks)
- [OOP](https://devsunite.com/resources/core-subjects/oop)
- [Core Subjects](https://devsunite.com/resources/core-subjects)
