- Database elements:
- Database element = the unit of data accessed by the database system
- Database:
- Database = a collection of database elements
- Note:
- Different DBMS uses
different notion
for database element
- Possible units:
- A relation
(kinda large)
- A disk block
(the most commonly used unit)
- A tuple in a relation (kinda small)
- A relation
(kinda large)
- Different DBMS uses
different notion
for database element
- State of a database:
- Database state = the collection of values of all database elements in the database
- Consistent/inconsistent:
- A database state can be:
- Consistent or
- Inconsistent
- A database state can be:
- Theory:
- Assuming that
the database is in a
consistent state.
Then:
- A transaction will
transform the database
into
a (another)
consistent state
if:
- There are no
system failures
- There are no other transactions executing in the database system
- There are no
system failures
- A transaction will
transform the database
into
a (another)
consistent state
if:
- Assuming that
the database is in a
consistent state.
- Schematically:
- Remember that these 2 things
can cause the database to become
inconsistent:
- System failure:
Transaction: transfer $100 from A to B read A A.balance = A.balance - 100 write A ================================== system fails hereread B B.balance = B.balance + 100 write BA has lost his money !!!
- Concurrent execution:
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 !!!
- System failure:
- Therefore:
- In the absence of:
- System failures and
- concurrent execution of transactions
a transaction will transform a consistent DB state into another consistent DB state
- In the absence of:
- Transactions interact
with the database using the
following
primitive operations:
- 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
- READ(X, t):
- Copy/transfer the
DB element X
to the transaction's
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
- If DB element X is already
in the buffer manager buffer,
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
- 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:
- Log:
- Log = a file of log records
- 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 !!!!
- Log records are
first created in
main memory
- Types of
logging:
- Undo logging
- Redo logging
- Undo/redo logging
- Flushing
the log:
- Flush-log = write all log records stored in main memory to disk