chapter 1: introductioncarme.cs.trinity.edu/thicks/3343/lectures/... · atomicity failure...
TRANSCRIPT
![Page 1: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/1.jpg)
Dr. Tom HicksComputer Science Department
Transaction Management
Database SystemsCSCI-3343
1
![Page 2: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/2.jpg)
Transaction
2
![Page 3: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/3.jpg)
Transaction
Transaction : a collection of operations that form a single
logical unit of work.
Transactions have two main issues to deal with:
Failures of various kinds, such as hardware failures
and system crashes
Concurrent execution of multiple transactions
3
![Page 4: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/4.jpg)
Atomicity
4
![Page 5: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/5.jpg)
Atomicity Property
Atomicity Property: Either all of the actions of a
transaction be executed properly, or that in the case of
some failure, the partial effects of each incomplete
transaction be undone.
Atomicity requires that each transaction is "all or
nothing": if one part of the transaction fails, the entire
transaction fails, and the database state is left unchanged.
An atomic system must guarantee atomicity in each
and every situation, including power failures, errors, and
crashes. To the outside world, a committed transaction
appears (by its effects on the database) to be indivisible
("atomic"), and an aborted transaction does not happen. 5
![Page 6: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/6.jpg)
Atomicity Failure
Constraint (A + B = 100);
Assume that a transaction attempts to subtract 10 from A
and add 10 to B.
This is a valid transaction, since the data continue to
satisfy the constraint after it has executed.
However, assume that after removing 10 from A, the
transaction is unable to modify B (for whatever reason). If
the database retained A's new value, atomicity and the
constraint would both be violated.
Atomicity requires that both parts of this transaction, or
neither, be complete. 6
![Page 7: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/7.jpg)
MySQL
Later In These Slides:
All transactions must meet the ACID test Atomicity, Consistency,
Isolation, & Durability.
![Page 8: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/8.jpg)
Consistency
8
![Page 9: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/9.jpg)
Consistency Property
Consistency Property: Execution of a transaction in
isolation preserves the consistency of the database.
The Consistency Property ensures that any
transaction will bring the database from one valid
state to another. Any data written to the database
must be valid according to all defined rules, including
but not limited to constraints, cascades, triggers, and
any combination thereof.
Consistency does not guarantee correctness of
the transaction in all ways the application programmer
might have wanted (that is the responsibility of
application-level code) but merely that any
programming errors do not violate any defined rules. 9
![Page 10: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/10.jpg)
Consistency Failure - 1
Constraint (A + B = 100);
Data must meet all validation rules.
If there is a requirement that A + B = 100. Also, it may be
inferred that both A and B must be integers. A valid range
for A and B may also be inferred. All validation rules must
be checked to ensure consistency.
Assume that a transaction attempts to subtract 10 from
A without altering B. Because consistency is checked
after each transaction, it is known that A + B = 100 before
the transaction begins.
10
![Page 11: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/11.jpg)
Consistency Failure - 2
If the transaction removes 10 from A successfully,
atomicity will be achieved. However, a validation check will
show that A + B = 90, which is inconsistent with the rules
of the database.
The entire transaction must be cancelled and the
affected rows rolled back to their pre-transaction state.
If there had been other constraints, triggers, or
cascades, every single change operation would have
been checked in the same way as above before the
transaction was committed.
11
![Page 12: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/12.jpg)
MySQL
Later In These Slides:
All transactions must meet the ACID test Atomicity, Consistency,
Isolation, & Durability.
![Page 13: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/13.jpg)
Isolation
13
![Page 14: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/14.jpg)
Isolation Property Isolation Property: Since a Transaction is a single unit, it’s
actions cannot appear to be separated by other database actions
“that are not part of this transaction”.
Although multiple transactions may execute concurrently
each transaction must be unaware of other concurrently
executing transactions.
Intermediate transaction results must be hidden from other
concurrently executed transactions.
That is, for every pair of transactions Ti and Tj, it appears to Ti
that either Tj, finished execution before Ti started, or Tj started
execution after Ti finished.
The Database Must Take Special Precautions to make sure
that this transaction operates properly without interference form
concurrently operating database statements! 14
![Page 15: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/15.jpg)
Isolation Property
The Isolation Property ensures that the
concurrent execution of transactions results in a system
state that would be obtained if transactions were
executed serially, i.e. one after the other.
Providing Isolation is the main goal of concurrency
control. Depending on concurrency control method, the
effects of an incomplete transaction might not even be
visible to another transaction
15
![Page 16: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/16.jpg)
MySQL
Later In These Slides:
All transactions must meet the ACID test Atomicity, Consistency,
Isolation, & Durability.
![Page 17: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/17.jpg)
Durability
17
![Page 18: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/18.jpg)
Durability Property
Durability Property: Once a transaction has
been committed, the changes it has made to the
database persist, even if there are system failures.
In a relational database, for instance, once a group of SQL
statements execute, the results need to be stored
permanently (even if the database crashes immediately
thereafter).
To defend against power loss, Transactions (or their
effects) Must be Recorded in a Non-Volatile Memory.
18
![Page 19: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/19.jpg)
MySQL
Later In These Slides:
All transactions must meet the ACID test Atomicity, Consistency,
Isolation, & Durability.
![Page 20: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/20.jpg)
Microsoft SQL Server
![Page 21: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/21.jpg)
http://searchsqlserver.techtarget.com/tip/The-ACID-test-for-T-SQL-batch-statements
Read This!
![Page 22: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/22.jpg)
Example
22
![Page 23: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/23.jpg)
Transaction Concept
A transaction is a unit of program execution that accesses
and possibly updates various data items.
E.g. transaction to transfer $50 from account A to account
B:
1. read(A)
2. A := A – 50
3. write(A)
4. read(B)
5. B := B + 50
6. write(B)
All transactions must meet the ACID test Atomicity,
Consistency, Isolation, & Durability.
23
![Page 24: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/24.jpg)
Example of Fund Transfer
SQL is a Powerful & Complex Language
Begin with a simple transaction that moves data from disk to memory & from memory to
disk.
We are going to ignore Insert & Delete for the moment.
Data Members A & B
read(A) transfers data from database into memory variable A
write(A) transfers data from memory variable A back to disk
Reality information written to disk is often buffered & may not happen immediately
Conceptual Assumption For The Moment we are going to assume that write is
immediate!
Transaction to transfer $50 from account A to account B:
1. read(A)
2. A := A – 50
3. write(A)
4. read(B)
5. B := B + 50
6. write(B)24
![Page 25: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/25.jpg)
Fund Transfer - Atomicity
Transaction to transfer $50 from account A to account B:
1. read(A)
2. A := A – 50
3. write(A)
4. read(B)
5. B := B + 50
6. write(B)
Atomicity requirement
if the transaction fails after step 3 and before step 6,
money will be “lost” leading to an inconsistent database
state
Failure could be due to software or hardware
the system should ensure that updates of a partially
executed transaction are not reflected in the database
25
![Page 26: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/26.jpg)
Fund Transfer - Durability
Transaction to transfer $50 from account A to account B:
1. read(A)
2. A := A – 50
3. write(A)
4. read(B)
5. B := B + 50
6. write(B)
Durability requirement — once the user has been notified that the transaction
has completed (i.e., the transfer of the $50 has taken place), the updates to
the database by the transaction must persist even if there are software or hardware
failures.
26
![Page 27: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/27.jpg)
Fund Transfer – Isolation
Isolation requirement — if between steps 3 and 6, another transaction T2 is allowed to access the partially updated database, it will see an inconsistent database (the sum A + B will be less than it should be).
T1 T2
1. read(A)
2. A := A – 50
3. write(A)read(A), read(B), print(A+B)
4. read(B)
5. B := B + 50
6. write(B)
Isolation can be ensured trivially by running transactions serially
that is, one after the other.
However, executing multiple transactions concurrently has significant benefits, as we will see later.
The Database Concurrency Control Module takes care of this!
27
![Page 28: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/28.jpg)
Fund Transfer - Consistency Transaction to transfer $50 from account A to account B:
1. read(A)
2. A := A – 50
3. write(A)
4. read(B)
5. B := B + 50
6. write(B)
Consistency requirement in above example:
the sum of A and B is unchanged by the execution of the transaction
In general, consistency requirements include
Explicitly specified integrity constraints such as primary keys and foreign keys
Implicit integrity constraints
– e.g. sum of balances of all accounts, minus sum of loan amounts must equal value of cash-in-hand
A transaction must see a consistent database.
During transaction execution the database may be temporarily inconsistent.
When the transaction completes successfully the database must be consistent
Erroneous transaction logic can lead to inconsistency
28
![Page 29: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/29.jpg)
ACID
29
![Page 30: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/30.jpg)
ACID Properties
Atomicity. Either all operations of the transaction are properly reflected
in the database or none are.
Consistency. Execution of a transaction in isolation preserves the
consistency of the database.
Isolation. Although multiple transactions may execute concurrently,
each transaction must be unaware of other concurrently executing
transactions. Intermediate transaction results must be hidden from other
concurrently executed transactions.
That is, for every pair of transactions Ti and Tj, it appears to Ti that
either Tj, finished execution before Ti started, or Tj started execution
after Ti finished.
Durability. Once a transaction has been committed, the changes it has
made to the database persist, even if there are system failures.
A transaction is a unit of program execution that accesses and possibly
updates various data items.To preserve the integrity of data the database
system must ensure:
30
![Page 31: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/31.jpg)
Storage
Structure
31
![Page 32: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/32.jpg)
Storage Structures
Volatile Storage Info in Volatile Storage does not generally survive a system
crash (RAM, CACHE, etc.) really fast access.
Nonvolatile Storage survives a system crash. (Magnetic Disk, Flash
Storage, Optical Media, Magnetic Tape, etc.) slower access.
Stable Storage to say that information stored in nonvolatile storage is never
lost must be taken with a grain of salt!
Black Hole that swallows up all data
Flash flood, etc
We can take steps to approximate stable storage that reduces the probability of
losing data.
Duplicate the data in several non-volatile storage media (generally disk)
with independent failure modes (RAID, etc.)
Steps must be taken to make sure that this duplicate data remains updated
accordingly. Transactions written to logs!
Hardware fixes include Battery Backup, etc.32
![Page 33: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/33.jpg)
Transaction
State
33
![Page 34: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/34.jpg)
MySQL autocommit
34
To Disable The Autocommit Mode,
SET autocommit = 0;
Changes Application To Transaction-Safe
Tables Where Changes Are Not Made
Permanent Until You Commit.
![Page 35: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/35.jpg)
MSSQL autocommit
35
To Disable The Autocommit Mode,
SET IMPLICIT_TRANSACTIONS OFF;
Changes Application To Transaction-Safe
Tables Where Changes Are Not Made
Permanent Until You Commit.
COMMIT TRANSACTION;
ROLLBACK TRANSACTION;
![Page 36: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/36.jpg)
Transaction Terminology
Each database modification, made by a transaction is first recorded into a log.
begin transaction;
end transaction;
---------- MySQL ----------
START TRANSACTION;
COMMIT;
Rollback is a process of undoing the aborted transactions. This is part of the recovery
scheme.
Once a transaction is completed correctly, it is said to be Committed.
Once a transaction is committed, it can not be undone, but a Compensating
Transaction could be designed to undo the effects.
36
![Page 37: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/37.jpg)
Transaction State Active – the initial state; the transaction stays in this state while it is executing
Partially committed – after the final statement has been executed.
Failed -- after the discovery that normal execution can no longer proceed.
Aborted – after the transaction has been rolled back and the database restored
to its state prior to the start of the transaction. Two options after it has been
aborted:
restart the transaction
can be done only if no internal logical error
kill the transaction
Committed – after successful completion.
37
![Page 38: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/38.jpg)
Transaction State Flow Diagram
38
![Page 39: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/39.jpg)
Concurrent
Transactions
39
![Page 40: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/40.jpg)
Concurrent Executions
We could force the system to process all transactions serially
one at a time.
We generally allow multiple transactions to be run concurrently in the system.
Advantages are:
Increased Processor and Disk Utilization, leading to better
transaction throughput
E.g. one transaction can be using the CPU while another is reading from
or writing to the disk optimizing multiple processors.
Reduced Average Response Time for transactions: short transactions
need not wait behind long ones.
40
![Page 41: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/41.jpg)
Concurrent Executions
When multiple transactions are processed concurrently, the data isolation
principle may be violated resulting in database consistency being destroyed
despite the correctness of each transaction!
Concurrency control schemes – mechanisms to achieve isolation
that is, to control the interaction among the concurrent transactions in order
to prevent them from destroying the consistency of the database
Will study in Chapter 16, after studying notion of correctness of
concurrent executions.
41
![Page 42: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/42.jpg)
Database Challenges
Multiple Processors with multiple cores are increasing the
opportunities for parallel transaction processing.
Researchers are
Trying to figure out ways to parallel process within a transaction
Trying to process more transaction
42
![Page 43: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/43.jpg)
Schedules
43
![Page 44: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/44.jpg)
Schedules
Schedule – a sequences of instructions that specify the
chronological order in which instructions of concurrent
transactions are executed
a schedule for a set of transactions must consist of all instructions of those
transactions
must preserve the order in which the instructions appear in each individual
transaction.
A transaction that successfully completes its execution will have a commit
instructions as the last statement
by default transaction assumed to execute commit instruction as its last
step
A transaction that fails to successfully complete its execution will have an abort
instruction as the last statement
44
![Page 45: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/45.jpg)
Schedule 1
Let T1 transfer $50 from A to B, and T2 transfer 10% of the balance from A to B.
A serial schedule in which T1 is followed by T2 :
45
![Page 46: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/46.jpg)
Schedule 2
• A serial schedule where T2 is followed by T1
46
![Page 47: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/47.jpg)
Schedule 3 Let T1 and T2 be the transactions defined previously. The following schedule
is not a serial schedule, but it is equivalent to Schedule 1.
In Schedules 1, 2 and 3, the sum A + B is preserved.
When we can ensure consistency of the database under concurrent execution schedule that is equivalent to the serial execution it is Serializable.
47
![Page 48: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/48.jpg)
Schedule 4
The following concurrent schedule does not preserve the
value of (A + B ).
48
![Page 49: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/49.jpg)
Serializability
49
![Page 50: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/50.jpg)
Serializability
Basic Assumption – Each transaction preserves database
consistency.
Thus serial execution of a set of transactions preserves database
consistency.
A (possibly concurrent) schedule is serializable if it is equivalent to a
serial schedule. Different forms of schedule equivalence give rise to
the notions of:
1. conflict serializability
2. view serializability
50
![Page 51: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/51.jpg)
Simplified view of transactions
We ignore operations other than read and write instructions
We assume that transactions may perform arbitrary computations
on data in local buffers in between reads and writes.
Our simplified schedules consist of only read and write
instructions.
51
![Page 52: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/52.jpg)
Conflicting Instructions
Instructions li and lj of transactions Ti and Tj respectively, conflict if and
only if there exists some item Q accessed by both li and lj, and at least
one of these instructions wrote Q.
1. li = read(Q), lj = read(Q). li and lj don’t conflict.
2. li = read(Q), lj = write(Q). They conflict.
3. li = write(Q), lj = read(Q). They conflict
4. li = write(Q), lj = write(Q). They conflict
Intuitively, a conflict between li and lj forces a (logical) temporal order
between them.
If li and lj are consecutive in a schedule and they do not conflict,
their results would remain the same even if they had been
interchanged in the schedule.
52
![Page 53: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/53.jpg)
Conflict Serializability
If a schedule S can be transformed into a schedule S´ by a
series of swaps of non-conflicting instructions, we say that
S and S´ are conflict equivalent.
We say that a schedule S is conflict serializable if it is
conflict equivalent to a serial schedule
53
![Page 54: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/54.jpg)
Conflict Serializability (Cont.)
Schedule 3 can be transformed into Schedule 6, a serial
schedule where T2 follows T1, by series of swaps of non-
conflicting instructions. Therefore Schedule 3 is conflict
serializable.
Schedule 3 Schedule 6
54
![Page 55: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/55.jpg)
Conflict Serializability (Cont.)
Example of a schedule that is not conflict serializable:
We are unable to swap instructions in the above schedule to
obtain either the serial schedule < T3, T4 >, or the serial
schedule < T4, T3 >.
55
![Page 56: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/56.jpg)
View Serializability
Let S and S´ be two schedules with the same set of transactions. S
and S´ are view equivalent if the following three conditions are met,
for each data item Q,
1. If in schedule S, transaction Ti reads the initial value of Q, then in
schedule S’ also transaction Ti must read the initial value of Q.
2. If in schedule S transaction Ti executes read(Q), and that value
was produced by transaction Tj (if any), then in schedule S’ also
transaction Ti must read the value of Q that was produced by the
same write(Q) operation of transaction Tj .
3. The transaction (if any) that performs the final write(Q) operation
in schedule S must also perform the final write(Q) operation in
schedule S’.
As can be seen, view equivalence is also based purely on reads and
writes alone.
56
![Page 57: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/57.jpg)
Serializability
In concurrency control of databases, transaction processing of an transaction
schedule is serializable if its outcome (e.g., the resulting database state) is
equal to the outcome of its transactions executed serially;
Transactions are normally executed concurrently (they overlap), since this is
the most efficient way.
Serializability is the major correctness criterion for concurrent transactions'
executions.
Serializability is considered the highest level of isolation between transactions,
and plays an essential role in concurrency control. As such it is supported in all
general purpose database systems.
Strong strict two-phase locking (SS2PL) is a popular serializability mechanism
utilized in most of the database systems (in various variants) since their early
days in the 1970s.
57
![Page 58: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/58.jpg)
View Serializability (Cont.)
A schedule S is view serializable if it is view equivalent to a serial
schedule.
Every conflict serializable schedule is also view serializable.
Below is a schedule which is view-serializable but not conflict
serializable.
What serial schedule is above equivalent to?
Every view serializable schedule that is not conflict serializable has
blind writes.
58
![Page 59: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/59.jpg)
Other Notions of Serializability
The schedule below produces same outcome as the serial
schedule < T1, T5 >, yet is not conflict equivalent or view
equivalent to it.
Determining such equivalence requires analysis of operations
other than read and write.
59
![Page 60: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/60.jpg)
Precedence
Graphs
60
![Page 61: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/61.jpg)
Precedence Graph
Consider some schedule of a set of transactions T1, T2, ..., Tn
A Precedence Graph, also named conflict graph and serializability
graph, is used in the context of concurrency control in databases.
The precedence graph for a schedule S contains:
A node for each committed transaction in S
An arc from Ti to Tj if an action of Ti precedes and conflicts with one
of Tj's actions
We draw an arc from Ti to Tj if the two transaction conflict, and Ti accessed
the data item on which the conflict arose earlier.
We may label the arc by the item that was accessed.
61
![Page 62: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/62.jpg)
Schedule 1 Precedence Graph
62
![Page 63: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/63.jpg)
Schedule 2 Precedence Graph
63
![Page 64: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/64.jpg)
Schedule 3 Precedence Graph
64
![Page 65: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/65.jpg)
Precedence Graph
Graph G = (V,E)
V set of Vertices all the transactions participating in the schedule.
E set of Edges all of the edges Ti Tj for which these three conditions
hold:
1. Ti executes Write(Q) before Tj executes Read(Q)
2. Ti executes Read(Q) before Tj executes Write(Q)
3. Ti executes Write(Q) before Tj executes Write(Q)
If an edge Ti Tj exists in the Precedence Graph, then in any serial schedule
S’ that is equivalent to S it must follow that T1 must appear before Tj
65
![Page 66: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/66.jpg)
Cyclic able Precedence Graph
If the Precedence graph has a cycle, it is not parallelizable.
66
![Page 67: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/67.jpg)
Testing For
Serializability
67
![Page 68: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/68.jpg)
Test for Conflict Serializability
A schedule is conflict serializable if and only
if its precedence graph is acyclic.
Cycle-detection algorithms exist which take
order n2 time, where n is the number of
vertices in the graph.
(Better algorithms take order n + e
where e is the number of edges.)
If precedence graph is acyclic, the
serializability order can be obtained by a
topological sorting of the graph.
This is a linear order consistent with the
partial order of the graph.
For example, a serializability order for
Schedule A would be
T5 T1 T3 T2 T4
68
![Page 69: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/69.jpg)
Test for View Serializability
The precedence graph test for conflict serializability cannot be used
directly to test for view serializability.
Extension to test for view serializability has cost exponential in the
size of the precedence graph.
The problem of checking if a schedule is view serializable falls in the
class of NP-complete problems.
Thus existence of an efficient algorithm is extremely unlikely.
However practical algorithms that just check some sufficient
conditions for view serializability can still be used.
69
![Page 70: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/70.jpg)
Recovery
Schedules
70
![Page 71: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/71.jpg)
Recoverable Schedules
Recoverable schedule — if a transaction Tj reads a data item previously
written by a transaction Ti , then the commit operation of Ti appears before the
commit operation of Tj.
The following schedule is not recoverable if T9 commits immediately after the
read
If T8 should abort, T9 would have read (and possibly shown to the user) an
inconsistent database state. Hence, database must ensure that schedules are
recoverable.
Need to address the effect of transaction failures on concurrently
running transactions.
71
![Page 72: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/72.jpg)
Cascading
Rollbacks
72
![Page 73: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/73.jpg)
Cascading Rollbacks
Cascading rollback – a single transaction failure leads to a series of
transaction rollbacks. Consider the following schedule where none of the
transactions has yet committed (so the schedule is recoverable)
If T10 fails, T11 and T12 must also be rolled back.
Can lead to the undoing of a significant amount of work
73
![Page 74: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/74.jpg)
Cascadeless
Rollbacks
74
![Page 75: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/75.jpg)
Cascadeless Schedules
Cascadeless schedules — cascading rollbacks cannot occur; for
each pair of transactions Ti and Tj such that Tj reads a data item
previously written by Ti, the commit operation of Ti appears before the
read operation of Tj.
Every cascadeless schedule is also recoverable
It is desirable to restrict the schedules to those that are cascadeless
75
![Page 76: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/76.jpg)
Concurrency
Control
76
![Page 77: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/77.jpg)
Concurrency Control
A database must provide a mechanism that will ensure that all possible
schedules are
either conflict or view serializable
AND
are recoverable preferably cascadeless
A policy in which only one transaction can execute at a time generates serial
schedules, but provides a poor degree of concurrency
Are serial schedules recoverable/cascadeless?
Testing a schedule for serializability after it has executed is a little too late!
Goal – to develop concurrency control protocols that will assure serializability.
77
![Page 78: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/78.jpg)
Concurrency Control (Cont.)
Schedules must be conflict or view serializable, and recoverable, for the sake of
database consistency, and preferably cascadeless.
A policy in which only one transaction can execute at a time generates serial
schedules, but provides a poor degree of concurrency.
Concurrency-control schemes tradeoff between the amount of concurrency
they allow and the amount of overhead that they incur.
Some schemes allow only conflict-serializable schedules to be generated, while
others allow view-serializable schedules that are not conflict-serializable.
78
![Page 79: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/79.jpg)
Concurrency Control vs. Serializability Tests
Concurrency-control protocols allow concurrent schedules, but ensure that the
schedules are conflict/view serializable, and are recoverable and cascadeless .
Concurrency control protocols generally do not examine the precedence graph
as it is being created
Instead a protocol imposes a discipline that avoids nonseralizable
schedules.
Different concurrency control protocols provide different tradeoffs between the
amount of concurrency they allow and the amount of overhead that they incur.
Tests for serializability help us understand why a concurrency control protocol
is correct.
79
![Page 80: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/80.jpg)
Weak Levels of Consistency
Some applications are willing to live with weak levels of consistency, allowing
schedules that are not serializable
E.g. a read-only transaction that wants to get an approximate total balance
of all accounts
E.g. database statistics computed for query optimization can be
approximate (why?)
Such transactions need not be serializable with respect to other
transactions
Tradeoff accuracy for performance
80
![Page 81: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/81.jpg)
Levels of Consistency in SQL-92
Serializable — default
Repeatable read — only committed records to be read, repeated reads of same
record must return same value. However, a transaction may not be serializable
– it may find some records inserted by a transaction but not find others.
Read committed — only committed records can be read, but successive reads
of record may return different (but committed) values.
Read uncommitted — even uncommitted records may be read.
Lower degrees of consistency useful for gathering approximate
information about the database
Warning: some database systems do not ensure serializable schedules by
default
E.g. Oracle and PostgreSQL by default support a level of consistency
called snapshot isolation (not part of the SQL standard)
81
![Page 82: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/82.jpg)
Transaction Definition in SQL
Data manipulation language must include a construct for specifying
the set of actions that comprise a transaction.
In SQL, a transaction begins implicitly.
A transaction in SQL ends by:
Commit work commits current transaction and begins a new one.
Rollback work causes current transaction to abort.
In almost all database systems, by default, every SQL statement also
commits implicitly if it executes successfully
Implicit commit can be turned off by a database directive
82
![Page 83: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/83.jpg)
Database Systems
CSCI 3343
Dr. Thomas E. HicksComputer Science Department
Trinity University
83
![Page 84: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/84.jpg)
MySQL Transactions
Create Database Query-Problem-1
Import Query-Problem-1.sql to MySQL on your computer
84
Use LibraryTH;
START TRANSACTION;
COMMIT;
![Page 85: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/85.jpg)
MySQL Transactions - 2
85
Use LibraryTH;
START TRANSACTION;
SET @Month = (SELECT MONTH(Now()));
COMMIT;
![Page 86: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/86.jpg)
MySQL Transactions - 3
Create Database Query-Problem-1
Import Query-Problem-1.sql to MySQL on your computer
86
Use LibraryTH;
START TRANSACTION;
SET @MyMonth = (SELECT MONTH(Now()));
SET @MyDay = (SELECT DAY(Now()));
SET @MyYear = (SELECT YEAR(Now()));
INSERT INTO CheckOut(UserID, Month, Day, Year)
VALUES (21, @MyMonth, @MyDay, @MyYear);
COMMIT;
![Page 87: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/87.jpg)
MySQL Transactions - 4
Create Database Query-Problem-1
Import Query-Problem-1.sql to MySQL on your computer
87
Use LibraryTH;
START TRANSACTION;
SET @MyMonth = (SELECT MONTH(Now()));
SET @MyDay = (SELECT DAY(Now()));
SET @MyYear = (SELECT YEAR(Now()));
SET @NextID = (SELECT MAX(ID) FROM CheckOut) + 1;
INSERT INTO CheckOut(ID, UserID, Month, Day, Year)
VALUES (@NextID, 21, @MyMonth, @MyDay, @MyYear);
COMMIT;
![Page 88: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/88.jpg)
MySQL Transactions - 5
88
Use LibraryTH;
START TRANSACTION;
SET @MyMonth = (SELECT MONTH(Now()));
SET @MyDay = (SELECT DAY(Now()));
SET @MyYear = (SELECT YEAR(Now()));
SET @NextID = (SELECT MAX(ID) FROM CheckOut) + 1;
INSERT INTO CheckOut(ID, UserID, Month, Day, Year)
VALUES (@NextID, 21, @MyMonth, @MyDay, @MyYear);
INSERT INTO CODetail (BookID, CheckOutID)
VALUES (@NextID, 1);
INSERT INTO CODetail (BookID, CheckOutID)
VALUES (@NextID, 10);
COMMIT;
![Page 89: Chapter 1: Introductioncarme.cs.trinity.edu/thicks/3343/Lectures/... · Atomicity Failure Constraint (A + B = 100); Assume that a transaction attempts to subtract 10 from A and add](https://reader030.vdocuments.net/reader030/viewer/2022040921/5e99df3a06ede7746f632fe7/html5/thumbnails/89.jpg)
MySQL Stored Procedures
CREATE PROCEDURE test_transaction()
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION ROLLBACK;
START TRANSACTION;
-- whatever DML operations and SELECT statements you want to
perform go here
IF (1=1) THEN
COMMIT;
ELSE
ROLLBACK;
END IF;
END
89