Slideshow:
The techniques to implement the
ACID properties of transactions
Intro to logging:
the log or
log file
Intro to logging:
writing the log (records)
The primitive system operations used to model transaction processing
The primitive system operations used to model transaction processing
INPUT(X):
The primitive system operations used to model transaction processing
READ(X,t): Copy/transfer the DB element X to the transaction's local variable t
The primitive system operations used to model transaction processing
READ(X,t): Copy/transfer the DB element X to the transaction's local variable t
The primitive system operations used to model transaction processing
WRITE(X, t): Copy/transfer the value in the transaction's local variable t to the DB element X
The primitive system operations used to model transaction processing
WRITE(X, t): Copy/transfer the value in the transaction's local variable t to the DB element X
The primitive system operations used to model transaction processing
OUTPUT(X):
The primitive system operations used to model transaction processing
- summary
Summary:
Size of a database element - assumption
This assumption make it impossible to read a database element partially
Example of primitive operations used by transactions
Example of primitive operations used by transactions
Effect of each primitive operation:
The actions stored in
log records
The action is one of the primitive operations used by the user program:
|
Schematically:
The Transaction Manager
Tasks performed by the Transaction Manager:
|
The Transaction Manager
Maintaining the log file
The Transaction Manager
Concurrency control:
- How the
(different) properties of
the transaction execution are
implemented:
- Atomiticy:
- Implemented by logging
- Consistency:
- This is an intrinsic property of a transaction
- Isolation:
- Implemented by synchronization methods (such as locking)
- Durability:
- Implemented by logging
We will study logging in the next few webpages
- Atomiticy:
- Log:
- Log = a (append only) file containing log records
- Log record:
- Log record =
a record in the
log file that contains
- information needed to undo and/or redo the effects of a transaction
- Log record =
a record in the
log file that contains
- Log record format
- ( TransactionID , Action , DB element , Value )
- Creating and writing:
- Log records are
first created in
main memory
- They are written to
disk when
convenient
-
Sometimes,
the log records are
forced onto
disk !!!!
- We will discuss the log writing protocol soon !!!
- Log records are
first created in
main memory
- At the operating system level,
transactions interact
with the database by using the
following
primitive operations
(provided by the operating system):
- INPUT(X) (X is a database element)
- OUTPUT(X) (X is a database element)
- READ(X, t) (X is a database element, t is a program variable)
- WRITE(X, t) (X is a database element, t is a program variable)
- Meaning of
the primitive database operations
(on DB elements):
- INPUT(X):
- Copy/transfer the
disk block containing the
DB element X
to the
buffer in the
buffer manager
(The buffer manager maintains the available memory buffers in memory)
Graphically:
- Copy/transfer the
disk block containing the
DB element X
to the
buffer in the
buffer manager
- READ(X, t):
- Copy/transfer the
DB element X
to the transaction's
local variable t
- If DB element X is
not
in the buffer manager's buffer,
then an INPUT(X)
is executed and
then the value is
copied to
the local variable t
- If DB element X is
already
in the buffer manager buffer,
then the value is
copied to
the local variable t
- If DB element X is
not
in the buffer manager's buffer,
then an INPUT(X)
is executed and
then the value is
copied to
the local variable t
- Copy/transfer the
DB element X
to the transaction's
local variable t
- WRITE(X, t):
- Copy/transfer the
value
in the transaction's
local variable t to
the
DB element X
- If DB element X is
already
in the buffer manager's buffer,
then the value of
the local variable t
is
copied to the
DB element X
- If DB element X is
not
in the buffer manager's buffer,
then an INPUT(X)
is executed and
then the value is
copied to
the DB element X
- If DB element X is
already
in the buffer manager's buffer,
then the value of
the local variable t
is
copied to the
DB element X
- Copy/transfer the
value
in the transaction's
local variable t to
the
DB element X
- OUTPUT(X):
- Transfer the
block contianing the
DB element X from
memory buffer
(in the buffer manager) to
disk
- Transfer the
block contianing the
DB element X from
memory buffer
(in the buffer manager) to
disk
Summary:
- INPUT(X):
- Assumption:
- The text book assumes that:
- DB element ≤ 1 block
- This means:
- We only need 1 read/write operation to read/write one DB element....
- The text book assumes that:
- Example Transaction:
Database elements: A = 1000 B = 2000
Operations in T: READ(A, x) x = x + 100 WRITE(A, x) READ(B, x) x = x + 100 WRITE(B, x)Effect of the primitive operations:
- Transaction manager:
- Transaction manager = the software sub-system in the DBMS that implements the behavior of a transaction
- Functions performed by
the transaction manager:
-
Write
log records to
the log (file)
when a
transaction performs
one of the
following
operations:
- Start a
transaction
- Writes: <START T> to the log
- Read some
data
- Writes: <READ ...> to the log
- Write (update) some
data
- Writes: <WRITE ...> to the log
- Ends
- Writes: <COMMIT T> or <ABORT T> to the log
- Start a
transaction
- Make sure that
concurrent execution of
transactions does not
interfere with
each other
(which can result in inconsistent database state)
Example:
T1 T2 ============================= read A A = 10 read A A = A + 1 A = A + 2 write A A = 11 write A A = 12 ??? A = 13 is the correct answer !!!Comment:
- Solving the concurrent execution will be discussed later (serializability)
-
Write
log records to
the log (file)
when a
transaction performs
one of the
following
operations: