Scribd
Upload
131 views10 pages

Transaction Processing Concepts: Goals

This document discusses transaction processing concepts in database management systems. It defines the key properties of transactions - atomicity, consistency, isolation, and durability. Concurrency control mechanisms like locking are used to maintain isolation while allowing concurrent execution of transactions. Problems like lost updates, dirty reads, and inconsistent analyses can occur without proper concurrency control. The document explains lock-based protocols like two-phase locking that use different types of locks to ensure serializable schedules and avoid anomalies.

Uploaded by

MhackSahu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
131 views10 pages

Transaction Processing Concepts: Goals

This document discusses transaction processing concepts in database management systems. It defines the key properties of transactions - atomicity, consistency, isolation, and durability. Concurrency control mechanisms like locking are used to maintain isolation while allowing concurrent execution of transactions. Problems like lost updates, dirty reads, and inconsistent analyses can occur without proper concurrency control. The document explains lock-based protocols like two-phase locking that use different types of locks to ensure serializable schedules and avoid anomalies.

Uploaded by

MhackSahu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 10

ECS-165A WQ11 164

9. Transaction Processing Concepts


Goals: Understand the basic properties of a transaction and
learn the concepts underlying transaction processing as well as
the concurrent executions of transactions.
A transaction is a unit of a program execution that accesses and
possibly modies various data objects (tuples, relations).
DBMS has to maintain the following properties of transactions:
Atomicity: A transaction is an atomic unit of processing, and
it either has to be performed in its entirety or not at all.
Consistency: A successful execution of a transaction must take
a consistent database state to a (new) consistent database
state. (;integrity constraints)
Isolation: A transaction must not make its modications
visible to other transactions until it is committed, i.e.,
each transaction is unaware of other transactions executing
concurrently in the system. (;concurrency control)
Durability: Once a transaction has committed its changes,
these changes must never get lost due to subsequent (system)
failures. (;recovery)
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 165
Model used for representing database modications of a
transaction:
read(A,x): assign value of database object A to variable x;
write(x,A): write value of variable x to database object A
Example of a Transaction T
read(A,x)
x := x - 200
write(x,A) Transaction Schedule reects
read(B,y) chronological order of operations
y := y + 100
write(y,B)
Main focus here: Maintaining isolation in the presence of
multiple, concurrent user transactions
Goal: Synchronization of transactions; allowing concurrency
(instead of insisting on a strict serial transaction execution,
i.e., process complete T
1
, then T
2
, then T
3
etc.)
;increase the throughput of the system,
;minimize response time for each transaction
Problems that can occur for certain transaction schedules without
appropriate concurrency control mechanisms:
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 166
Lost Update
Time Transaction T
1
Transaction T
2
1 read(A,x)
2 x:=x+200
3 read(A,y)
4 y:=y+100
5 write(x,A)
6 write(y,A)
7 commit
8 commit
The update performed by T
1
gets lost; possible solution: T
1
locks/unlocks database object A
= T
2
cannot read A while A is modied by T
1
Dirty Read
Time Transaction T
1
Transaction T
2
1 read(A,x)
2 x:=x+100
3 write(x,A)
4 read(A,y)
5 write(y,B)
6 rollback
T
1
modies db object, and then the transactionT
1
fails for some
reason. Meanwhile the modied db object, however, has been
accessed by another transaction T
2
. Thus T
2
has read data that
never existed.
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 167
Inconsistent Analysis (Incorrect Summary Problem)
Time Transaction T
1
Transaction T
2
1 read(A,y1)
2 read(A,x1)
3 x1 := x1 - 100
4 write(x1, A)
5 read(C,x2)
6 x2 := x2+x1
7 write(x2,C)
8 commit
9 read(B,y2)
10 read(C,y3)
11 sum := y1 + y2 + y3
12 commit
In this schedule, the total computed by T
1
is wrong (o by 100).
= T
1
must lock/unlock several db objects
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 168
Serializability
DBMS must control concurrent execution of transactions to
ensure read consistency, i.e., to avoid dirty reads etc.
;A (possibly concurrent) schedule S is serializable if it is
equivalent to a serial schedule S

, i.e., S has the same


result database state as S

.
How to ensure serializability of concurrent transactions?
Conicts between operations of two transactions:
T
i
T
j
read(A,x)
read(A,y)
T
i
T
j
read(A,x)
write(y,A)
(order does not matter) (order matters)
T
i
T
j
write(x,A)
read(A,y)
T
i
T
j
write(x,A)
write(y,A)
(order matters) (order matters)
A schedule S is serializable with regard to the above conicts i
S can be transformed into a serial schedule S by a series of swaps
of non-conicting operations.
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 169
Checks for serializability are based on precedence graph that
describes dependencies among concurrent transactions; if the
graph has no cycle, then the transactions are serializable.
;they can be executed concurrently without aecting each
others transaction result.
Concurrency Control: Lock-Based Protocols
One way to ensure serializability is to require that accesses to
data objects must be done in a mutually exclusive manner.
Allow transaction to access data object only if it is currently
holding a lock on that object.
Serializability can be guaranteed using locks in a certain fashion
= Tests for serializability are redundant !
Types of locks that can be used in a transaction T:
slock(X): shared-lock (read-lock); no other transaction than
T can write data object X, but they can read X
xlock(X): exclusive-lock; T can read/write data object X; no
other transaction can read/write X, and
unlock(X): unlock data object X
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 170
Lock-Compatibility Matrix:
requested existing lock
lock slock xlock
slock OK No
xlock No No
E.g., xlock(A) has to wait until all slock(A) have been released.
Using locks in a transaction (lock requirements, LR):
before each read(X) there is either a xlock(X) or a slock(X)
and no unlock(X) in between
before each write(X) there is a xlock(X) and no unlock(X)
in between
a slock(X) can be tightened using a xlock(X)
after a xlock(X) or a slock(X) sometime an unlock(X) must
occur
But: Simply setting locks/unlocks is not sucient
replace each read(X) slock(X); read(X); unlock(X), and
write(X) xlock(X); write(X); unlock(X)
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 171
Two-Phase Locking Protocol (TPLP)
A transaction T satises the TPLP i
after the rst unlock(X) no locks xlock(X) or slock(X) occur
That is, rst T obtains locks, but may not release any lock
(growing phase)
and then T may release locks, but may not obtain new locks
(shrinking phase)
Strict Two-Phase Locking Protocol:
All unlocks at the end of the transaction T = no dirty reads
are possible, i.e., no other transaction can write the (modied)
data objects in case of a rollback of T.
Concurrency Control in PostgreSQL
In PostgreSQL (or Oracle) the user can specify the following locks
on relations and tuples using the command
lock table in <mode> mode;
mode = tuple level relation level
row share = slock intended slock
row exclusive = xlock intended xlock
share = slock
share row exclusive = sixlock
exclusive = xlock
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 172
The following locks are performed automatically by the scheduler:
select no lock
insert/update/delete xlock /row exclusive
select . . . for update slock /row share
commit releases all locks
PostgreSQL (and Oracle) furthermore provide isolation levels that
can be specied before a transaction by using the command
set transaction isolation level <level>;
read committed (default): each query executed by a
transaction sees the data that was committed before the
query (not the transaction!)
(;statement level read consistency)
T
1
T
2
select A from R
old value
update R set A = new
select A from R
old value
commit
select A from R
new value
Non-repeatable reads (same select statement in TA gives
dierent results at dierent times) possible; dirty-reads are
not possible
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts
ECS-165A WQ11 173
serializable: serializable TAs see only those changes that were
committed at the time the TA began, plus own changes.
PostgreSQL generates an error when such a transaction tries to
update or delete data modied by a transaction that commits
after the serializable transaction began.
T
1
T
2
set transaction isolation
level serializable
set transaction . . .
update R set A = new
where B = 1
commit
update R set A = new
where B = 1
ERROR
Dirty-reads and non-repeatable reads are not possible.
Furthermore, this mode guarantees serializability (but does
not provide much parallelism).
Dept. of Computer Science UC Davis 9. Transaction Processing Concepts

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy