Topics Covered:

Query Processing Transaction Management: Introduction

Transaction Processing. Single user & multiuser systems.
Transactions: read & write operations. Need of
concurrency control: The lost update problem, Dirty1read
problem. Types of failures. Transaction states. Desirable
properties (ACID properties) of Transactions. Concurrency
Control Techniques: Locks and Time stamp Ordering.
Deadlock & Starvation.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K
Transactions Processing:

• A transaction is a program including a collection of

database operations, executed as a logical unit of data
processing.
• The operations performed in a transaction include one
or more of database operations like insert, delete,
update or retrieve data.
• It is an atomic process that is either performed into
completion entirely or is not performed at all.
• A transaction involving only data retrieval without any
data update is called read-only transaction.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 2

Difference between Single User and Multi-User Database Systems:

Single User Database Systems Multi-User Database Systems

A DBMS is a multi-user if many/multi-
A DBMS is a single-user if at most one user at a time
users can use the system and hence
can use the system.
access the database concurrently.
Most DBMSs are multi-user, like
Single-User DBMSs are mostly restricted to personal
databases of airline reservation
computer systems.
systems, banking databases, etc.
Multiple users can access databases
Single user databases do not have
and use computer systems
multiprogramming thus, a single CPU can only
simultaneously because of the
execute at most one process at a time.
concept of Multiprogramming.
The data is neither integrated nor shared among any The data is integrated and shared
other user. among other users.
Designed to be accessed by multiple
Designed to be used by only one user at a time
users simultaneously
Typically installed on a network
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 3
Typically installed on a single computer server
 Can be accessed by users
Can only be accessed by the user who
who are logged in to the
installed it or the user who is currently
network
logged in

More complex and requires

Simpler and less expensive than multi- more resources than single-
user systems user systems

Essential for organizations

Not suitable for environments where
where multiple users need
multiple users need to access the same
to access the same data at
data at the same time
the same time
Example: Databases of
Banks, insurance agencies,
Example: Personal Computers.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K
stock exchanges, 4
Operations of Transaction:

The low level operations performed in a transaction are −

•begin_transaction − A marker that specifies start of transaction
execution.
•read_item or write_item − Database operations that may be interleaved
with main memory operations as a part of transaction.
•end_transaction − A marker that specifies end of transaction.
•commit − A signal to specify that the transaction has been successfully
completed in its entirety and will not be undone.
•rollback − A signal to specify that the transaction has been unsuccessful
and so all temporary changes in the database are undone. A committed
transaction cannot be rolled back.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 5

Read(X): Read operation is used to read the value of X from the database and
stores it in a buffer in main memory.
Write(X): Write operation is used to write the value back to the database from
the buffer.
Let's take an example to debit transaction from an account which consists of
following operations:
1. R(X);
2. X = X - 500;
3. W(X);
Let's assume the value of X before starting of the transaction is 4000.
•The first operation reads X's value from database and stores it in a buffer.
•The second operation will decrease the value of X by 500. So buffer will
contain 3500.
•The third operation will write the buffer's value to the database. So X's final
value will be 3500.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 6
 NEED FOR CONCURRENCY CONTROL
Concurrency Control
Concurrency Control is the management procedure that is required for controlling the
concurrent execution of the operations that take place on a database.
Concurrent Execution in DBMS
•In a multi-user system, multiple users can access and use the same database at one
time, which is known as the concurrent execution of the database. It means that the
same database is executed simultaneously on a multi-user system by different users.
•While working on the database transactions, there occurs the requirement of using the
database by multiple users for performing different operations, and in that case,
concurrent execution of the database is performed.
•The thing is that the simultaneous execution that is performed should be done in an
interleaved manner, and no operation should affect the other executing operations, thus
maintaining the consistency of the database. Thus, on making the concurrent execution
of the transaction operations, there occur several challenging problems that need to be
solved.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 7
Problems with Concurrent Execution
• In a database transaction, the two main operations are READ and WRITE operations.

• So, there is a need to manage these two operations in the concurrent execution of
the transactions as if these operations are not performed in an interleaved manner,
and the data may become inconsistent.

• So, the following problems occur with the Concurrent Execution of the operations:

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 8

Problem 1: Lost Update Problems (W - W Conflict)
The problem occurs when two different database transactions perform the read/write
operations on the same database items in an interleaved manner (i.e., concurrent
execution) that makes the values of the items incorrect hence making the database
inconsistent.
For example:
Consider the below diagram where two transactions TX and TY, are performed on the
same account A where the balance of account A is $300.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 9

 • At time t1, transaction TX reads the value of account
A, i.e., $300 (only read).
• At time t2, transaction TX deducts $50 from account A
that becomes $250 (only deducted and not
updated/write).
• Alternately, at time t3, transaction TY reads the value
of account A that will be $300 only because TX didn't
update the value yet.
• At time t4, transaction TY adds $100 to account A that
becomes $400 (only added but not updated/write).
• At time t6, transaction TX writes the value of account
A that will be updated as $250 only, as TY didn't
update the value yet.
• Similarly, at time t7, transaction TY writes the values
of account A, so it will write as done at time t4 that
will be $400. It means the value written by TX is lost,
i.e., $250 is lost.
• Hence data becomes incorrect, and database sets to
inconsistent.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 10
 Dirty Read Problem in DBMS
• To maximize efficiency, we process the transactions concurrently. But the
issue arises when more than one transaction performs certain read/write
operations on a particular data.

• As the name suggests, when some dirty data is read from the database it is
known as the Dirty Read.

• More formally, when a transaction (say X) is reading a row that has been
modified by another transaction (say Y) but not committed yet leads to the
condition of Dirty Read.

Example: Dirty Read Problem

Consider two people A and B are trying to book a train ticket from the
IRCTC platform. Let's suppose they perform the following sequence of
events -
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 11
 Now let's say initially (before A and B
started the booking process) 4 seats
were available.
• Then, A came and read SEATS as 4,
then he started the booking process,
and hence he decreased the value of
SEATS to 3.
• Now, B came and read the count of
seats i.e. SEATS to be 3.
• But after some time the transaction
of A got ROLLBACKED (say due to
an issue with the payment gateway).
• Then the value of SEATS will get
updated to its initial value i.e. 4. And
thus, we can say B has read a Dirty
value of SEATS.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 12

Overcome the Dirty Read Concurrency Problem

Lock-Based Protocols - To attain consistency, isolation between the transactions

is the most important tool. Isolation is achieved if we disable the transaction to
perform a read/write operation. This is known as locking an operation in a
transaction. Through lock-based protocols, desired operations are freely allowed
to perform locking the undesired operations.

Time-Based Protocols - According to this protocol, every transaction has a

timestamp attached to it. The timestamp is based on the time in which the
transaction is entered into the system. There are read and write timestamps
associated with every transaction which consist of the time at which the latest
read and write operations are performed respectively.

Validation Based Protocols - In this protocol, we have certain phases i.e.

Reading Phase, Validation Phase, and Validation Test Phase during each of which
we undergo certain commands Prepared
Department of Computer Science, GFGC, Malur
to make sure that the Dirty read problem should
by Dr Hamela K 13
not occur.
 TYPES OF FAILURE
Failure in terms of a database can be defined as its inability to
execute the specified transaction or loss of data from the database.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 14

1. Transaction failure
The transaction failure occurs when it fails to execute or when it reaches a point
from where it can't go any further. If a few transaction or process is hurt, then this is
called as transaction failure.

Reasons for a transaction failure could be -

Logical errors: If a transaction cannot complete due to some code error or an

internal error condition, then the logical error occurs.

Syntax error: It occurs where the DBMS itself terminates an active transaction
because the database system is not able to execute it. For example, The system
aborts an active transaction, in case of deadlock or resource unavailability.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 15

2. System Crash
System failure can occur due to power failure or other hardware or
software failure. Example: Operating system error.
Fail-stop assumption: In the system crash, non-volatile storage is
assumed not to be corrupted.

3. Disk Failure
It occurs where hard-disk drives or storage drives used to fail
frequently. It was a common problem in the early days of technology
evolution.
Disk failure occurs due to the formation of bad sectors, disk head
crash, and unreachability to the disk or any other failure, which destroy
all or part of disk storage.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 16
 Transaction States in DBMS
States through which a transaction goes during its lifetime. These are the states which
tell about the current state of the Transaction and also tell how we will further do the
processing in the transactions. These states govern the rules which decide the fate of
the transaction whether it will commit or abort.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 17

These are different types of Transaction States :

Active State –
When the instructions of the transaction are running then the transaction is in
active state. If all the ‘read and write’ operations are performed without any error
then it goes to the “partially committed state”; if any instruction fails, it goes to the
“failed state”.

Partially Committed –
After completion of all the read and write operation the changes are made in main
memory or local buffer. If the changes are made permanent on the DataBase then
the state will change to “committed state” and in case of failure it will go to the
“failed state”.

Failed State –
When any instruction of the transaction fails, it goes to the “failed state” or if failure
occurs in making a permanent change of data on Data Base.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 18
Aborted State –
After having any type of failure the transaction goes from “failed state” to
“aborted state” and since in previous states, the changes are only made to local
buffer or main memory and hence these changes are deleted or rolled-back.

Committed State –
It is the state when the changes are made permanent on the Data Base and the
transaction is complete and therefore terminated in the “terminated state”.

Terminated State –
If there isn’t any roll-back or the transaction comes from the “committed state”,
then the system is consistent and ready for new transaction and the old
transaction is terminated.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 19

 DESIRABLE PROPERTIES OF TRANSACTION
Transaction property
The transaction has the four properties. These are used to
maintain consistency in a database, before and after the
transaction.

Property of Transaction
• Atomicity
• Consistency
• Isolation
• Durability

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 20

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 21
Atomicity
It states that all operations of the transaction take place at once if
not, the transaction is aborted.
There is no midway, i.e., the transaction cannot occur partially. Each
transaction is treated as one unit and either run to completion or is
not executed at all.
Atomicity involves the following two operations:

Abort: If a transaction aborts then all the changes made are not
visible.

Commit: If a transaction commits then all the changes made are

visible.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 22
Consistency
• The integrity constraints are maintained so that the database is
consistent before and after the transaction.
• The execution of a transaction will leave a database in either its prior
stable state or a new stable state.
• The consistent property of database states that every transaction sees
a consistent database instance.
• The transaction is used to transform the database from one consistent
state to another consistent state.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 23

Isolation
• It shows that the data which is used at the time of
execution of a transaction cannot be used by the
second transaction until the first one is completed.
• In isolation, if the transaction T1 is being executed and
using the data item X, then that data item can't be
accessed by any other transaction T2 until the
transaction T1 ends.
• The concurrency control subsystem of the DBMS
enforced the isolation property.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 24
Durability
• The durability property is used to indicate the
performance of the database's consistent state. It states
that the transaction made the permanent changes.
• They cannot be lost by the erroneous operation of a
faulty transaction or by the system failure. When a
transaction is completed, then the database reaches a
state known as the consistent state. That consistent state
cannot be lost, even in the event of a system's failure.
• The recovery subsystem of the DBMS has the
responsibility of Durability property.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 25
 Concurrency Control
• Concurrency Control in Database Management System is a
procedure of managing simultaneous operations without conflicting
with each other.
• It ensures that Database transactions are performed concurrently and
accurately to produce correct results without violating data integrity
of the respective Database.
• DBMS Concurrency Control is used to address such conflicts, which
mostly occur with a multi-user system.
• Therefore, Concurrency Control is the most important element for
proper functioning of a Database Management System where two or
more database transactions are executed simultaneously, which
require access to the same data.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 26
Various concurrency control techniques are:

1. Locking Based Protocol

2. Time stamp ordering Protocol
3. Multi version concurrency control
4. Validation concurrency control

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 27

Lock-based Protocols

In DBMS Lock based Protocols, there are two modes for locking and unlocking data items Shared Lock
(lock-S) and Exclusive Lock (lock-X). Let's go through the two types of locks in detail:

Shared Lock
• Shared Locks, which are often denoted as lock-S(), is defined
as locks that provide Read-Only access to the information
associated with them.
• Whenever a shared lock is used on a database, it can be read
by several users, but these users who are reading the
information or the data items will not have permission to edit it
or make any changes to the data items.
• A shared lock, also known as a read lock, is solely used to read
data objects. Read integrity is supported via shared locks.
• Shared locks can also be used to prevent records from being
updated.
• S-lock is requested via the Lock-S instruction.
*Source: Scaler Topics
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 28
 Exclusive Lock
•Exclusive Lock allows the data item to be read as
well as written. This is a one-time use mode that
can't be utilized on the exact data item twice. To
obtain X-lock, the user needs to make use of
the lock-x instruction. After finishing the 'write'
step, transactions can unlock the data item.
•By imposing an X lock on a transaction that
needs to update a person's account balance, for
example, you can allow it to proceed. As a result
of the exclusive lock, the second transaction is
unable to read or write.
•The other name for an exclusive lock is write
lock.
•At any given time, the exclusive locks can only be
owned by one transaction.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 29

Lock Compatibility Matrix
• A vital point to remember when using Lock-based protocols in Database Management System
is that a Shared Lock can be held by any amount of transactions.
• On the other hand, an Exclusive Lock can only be held by one transaction in DBMS, this is
because a shared lock only reads data but does not perform any other activities, whereas an
exclusive lock performs read as well as writing activities.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 30

Types of Lock-Based Protocols
There are basically four lock based protocols in DBMS namely Simplistic Lock Protocol, Pre-claiming
Lock Protocol, Two-phase Locking Protocol, and Strict Two-Phase Locking Protocol.

Simplistic Lock Protocol

• The simplistic method is defined as the most fundamental method of
securing data during a transaction.
• Simple lock-based protocols allow all transactions to lock the data before
inserting, deleting, or updating it. After the transaction is completed, the data
item will be unlocked.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 31

Pre-Claiming Lock Protocol
Pre-claiming Lock Protocols are known to assess transactions to determine
which data elements require locks.
Prior to actually starting the transaction, it asks the Database management
system for all of the locks on all of the data items.
The pre-claiming protocol permits the transaction to commence if all of the
locks are obtained. Whenever the transaction is finished, the lock is released.
This protocol permits the transaction to roll back if all of the locks are not
granted and then waits until all of the locks are granted.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 32

Two-phase Locking Protocol
If Locking as well as the Unlocking can be performed in 2 phases, a
transaction is considered to follow the Two-Phase Locking protocol. The two
phases are known as the growing and shrinking phases.

Growing Phase: In this phase, we can acquire new locks on data items, but
none of these locks can be released.
Shrinking Phase: In this phase, the existing locks can be released, but no
new locks can be obtained.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 33

Strict Two-Phase Locking Protocol
In DBMS, Cascaded rollbacks are avoided with the concept of a Strict Two-
Phase Locking Protocol. This protocol necessitates not only two-phase locking
but also the retention of all exclusive locks until the transaction commits or
aborts. The two-phase is with deadlock.

It is responsible for assuring that if 1 transaction modifies data, there can be no

other transaction that will be able to read it until the first transaction commits.
The majority of database systems use a strict two-phase locking protocol.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 34

Timestamp Ordering Protocol
• The main idea for this protocol is to order the transactions based on their
Timestamps.
• A schedule in which the transactions participate is then serializable and the
only equivalent serial schedule permitted has the transactions in the order
of their Timestamp Values.
• Stating simply, the schedule is equivalent to the particular Serial Order
corresponding to the order of the Transaction timestamps.
• An algorithm must ensure that, for each item accessed by Conflicting
Operations in the schedule, the order in which the item is accessed does not
violate the ordering.
• To ensure this, use two Timestamp Values relating to each database item X.

W_TS(X) is the largest timestamp of any transaction that executed write(X)

successfully.
R_TS(X) is the largest timestamp of any transaction that executed read(X)
successfully.
Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 35
Basic Timestamp Ordering –
Every transaction is issued a timestamp based on when it enters the system. Suppose, if an old
transaction Ti has timestamp TS(Ti), a new transaction Tj is assigned timestamp TS(Tj) such
that TS(Ti) < TS(Tj).
Whenever some Transaction T tries to issue a R_item(X) or a W_item(X), the Basic TO algorithm
compares the timestamp of T with R_TS(X) & W_TS(X) to ensure that the Timestamp order is
not violated.

• Whenever a Transaction T issues a W_item(X) operation, check the following conditions:

If R_TS(X) > TS(T) and if W_TS(X) > TS(T), then abort and rollback T and reject the operation.
else,
Execute W_item(X) operation of T and set W_TS(X) to TS(T).

• Whenever a Transaction T issues a R_item(X) operation, check the following conditions:

If W_TS(X) > TS(T), then abort and reject T and reject the operation, else
If W_TS(X) <= TS(T), then execute the R_item(X) operation of T and set R_TS(X) to the larger of
TS(T) and current R_TS(X).

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 36

Advantages :
High Concurrency: Timestamp-based concurrency control allows for a high degree of concurrency by
ensuring that transactions do not interfere with each other.

Efficient: The technique is efficient and scalable, as it does not require locking and can handle a large number
of transactions.

No Deadlocks: Since there are no locks involved, there is no possibility of deadlocks occurring.

Improved Performance: By allowing transactions to execute concurrently, the overall performance of the
database system can be improved.

Disadvantages:
Limited Granularity: The granularity of timestamp-based concurrency control is limited to the precision of the
timestamp. This can lead to situations where transactions are unnecessarily blocked, even if they do not
conflict with each other.

Timestamp Ordering: In order to ensure that transactions are executed in the correct order, the timestamps
need to be carefully managed. If not managed properly, it can lead to inconsistencies in the database.

Timestamp Synchronization: Timestamp-based concurrency control requires that all transactions have
synchronized clocks. If the clocks are not synchronized, it can lead to incorrect ordering of transactions.

Timestamp Allocation:
Department of ComputerAllocating
Science, GFGC, unique
Malur timestamps for
Prepared by Dr each
Hamela K transaction can be challenging, especially in 37
distributed systems where transactions may be initiated at different locations.
Deadlock in DBMS
A deadlock is a condition where two or more transactions are waiting
indefinitely for one another to give up locks. Deadlock is said to be one of the
most feared complications in DBMS as no task ever gets finished and is in
waiting state forever.

Deadlock in DBMS
• Every process need some resource for its execution and these resources are granted in
sequential order
• First the process request some resource.
• OS grants the resource to the process if it is available or else it places the request in the wait
queue.
• The process uses it and releases on the completion so that it can be granted to another
process
• Deadlock is a situation where two or more transactions are waiting indefinitely for each other
to give up their locks.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 38

 Example:

Transaction T1 is waiting for

transaction T2 to release the lock
and similarly transaction T2 was
waiting for transaction T1 to release
Its lock, as a result, all activities
come to halt state and remain at
standstill .This continues until the
DBMS detects that deadlock has
occurred and abort some of the
transactions.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 39

Necessary conditions for Deadlocks
Mutual Exclusion
It implies if two processes cannot use the same resource at the same time.

Hold and Wait

A process waits for some resources while holding another resource at the same
time.

No pre-emption
The process which once scheduled will be executed till the completion. No other
process can be scheduled by the scheduler meanwhile.

Circular Wait
All the processes must be waiting for the resources in a cyclic manner so that the
last process is waiting for the resource which is being held by the first process.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 40

Starvation in a database management system (DBMS) is when a
transaction or process is repeatedly delayed or stalled because it cannot access
the resources it needs to move forward. When other transactions or processes
take precedence over the one that is starving, this might occur.

Reasons for Starvation –

· If the waiting scheme for locked items is unfair. ( priority queue )

· Victim selection. (the same transaction is selected as a victim repeatedly )

· Resource leak.

· Via denial-of-service attack.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 41

Example:-

Suppose there are 3 transactions namely T1, T2, and T3 in a database that are trying to acquire a lock on
data item ‘ I ‘.

The scheduler grants the lock to T1(maybe due to some priority), and the other two transactions are
waiting for the lock.

As soon as the execution of T1 is over.

Another transaction T4 also come over and request to lock on data item I. Now, this time the scheduler
grants lock to T4, and T2, T3 has to wait again.

In this way, if new transactions keep on requesting the lock, T2 and T3 may have to wait for an indefinite
period of time, which leads to Starvation.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 42

Solutions of Starvation –

1. Increasing Priority –
Starvation occurs when a transaction has to wait for an indefinite time, In In this situation, we can increase the
priority of that particular transaction/s. But the drawback with this solution is that it may happen that the
other transaction may have to wait longer until the highest priority transaction comes and proceeds.

2. Modification in Victim Selection algorithm –

If a transaction has been a victim of repeated selections, then the algorithm can be modified by lowering its
priority over other transactions.

3. First Come First Serve approach –

A fair scheduling approach i.e FCFS can be adopted, In which the transaction can acquire a lock on an item
in the order, in which the requested the lock.

4. Wait for the die and wound wait scheme –

These are the schemes that use the timestamp ordering mechanism of transaction.

Department of Computer Science, GFGC, Malur Prepared by Dr Hamela K 43