ESTRATEGIAS DE SUSTENTABILIDAD AGROPECUARIA

Partially

committed Committed

Active

Failed Aborted

A transaction must be in one of the following states:

1. Active State: This is the initial state of a transaction, the transaction stays in this state

while it is starting execution.

2. Partially Committed State: This transaction state occurs after the final (last) statement of

the transaction has been executed.

3. Failed State: This transaction state occurs after the discovery that normal execution can no

longer proceed.

4. Aborted State: This transaction state occurs after the transaction has been rolled back and

the database has been restored to its state prior to the start of the transaction.

5. Committed State: This transaction state occurs after the successful completion of the

transaction. The transaction states diagram corresponding to a transaction is shown above. A transaction starts in the active state. When it finishes its final (last) statement, it enters the partially committed state. At this point, the transaction has completed its execution, but there is

Notes still a possibility that it may be aborted, since the actual output may still, be temporarily

residing in main memory, and thus a hardware failure may stop its successful completion. When the database system writes out successfully the output information to disk, then the transaction enters the committed state.

A transaction may also enters the failed state from the active state or from the partially committed state after the system determines that the transaction can no longer proceed with its normal execution because of hardware failure or logical errors. Such a transaction must be rolled back and the database has been restored to its state prior to the start of the transaction. Then, it is known as the aborted state. At this state, the system has two options as follows:

1. Restart the Transaction: It can restart the transaction, but only if the transaction was

aborted as a result of some hardware failure or software error. A restarted transaction is considered to be a new transaction.

2. Kill the Transaction: It can kill the transaction because of some internal logical error that

can be corrected only by rewriting the application program, or because the input was bad.

Task _{When a transaction enter into the failed state?}

9.3 Implementation of Atomicity and Durability

Transactions can be incomplete for three kinds of reasons. First, a transaction can be aborted, or terminated unsuccessfully, by the DBMS because some anomaly arises during execution. If a transaction is aborted by the DBMS for some internal reason, it is automatically restarted and executed anew. Second, the system may crash (e.g., because the power supply is interrupted) while one or more transactions are in progress. Third, a transaction may encounter an unexpected situation (for example, read an unexpected data value or be unable to access some disk) and decide to abort (i.e., terminate itself).

Of course, since users think of transactions as being atomic, a transaction that is interrupted in the middle may leave the database in an inconsistent state. Thus a DBMS must find a way to remove the effects of partial transactions from the database, that is, it must ensure transaction atomicity: either all of a transaction’s actions are carried out, or none are. A DBMS ensures transaction atomicity by undoing the actions of incomplete transactions. This means that users can ignore incomplete transactions in thinking about how the database is modified by transactions over time. To be able to do this, the DBMS maintains a record, called the log, of all writes to the database. The log is also used to ensure durability: If the system crashes before the changes made by a completed transaction are written to disk, the log is used to remember and restore these changes when the system restarts.

The DBMS component that ensures atomicity and durability is called the recovery manager.

9.4 Concurrent Execution

Transaction-processing systems usually allow multiple transactions to run concurrently (at the same time) known as concurrent execution of transactions. The DBMS interleaves (inter changes) the actions of different transactions to improve performance, but not all interleavings should be allowed. Because allowing multiple transactions 16 update data concurrently causes several good reasons as well as several complications with the consistency of the database, which are illustrated as follows:

Notes _{Motivation for Concurrent Execution}

The schedule, involving two transactions shown in the following figure represents an interleaved execution of the two transactions.

T1 T2 R(A) W(A) R(B) W(B) R(C) W(C)

First, while one transaction is waiting for a page to be read in from disk, the CPU can process another transaction This is because I/O activity can be done in parallel with CPU activity in a computer. Overlapping I/O and CPU activity reduces the amount of time and increases system throughput which is the average number of transactions completed in a given time.

Second, interleaved execution of a short transaction with a long transaction usually allows the short transaction to complete quickly. In serial execution, a short transaction could get stuck behind a long transaction, leading to unpredictable delays in response, time, or average time taken to complete a transaction.

9.5 Serializability

A serializable schedule over a set S of committed transactions is a schedule whose effect on any consistent database is guaranteed to be identical to that of some complete serial schedule over S. That is, even-though the actions of transactions are interleaved, the result of executing transactions serially in different orders may produce different results.

9.6 Recoverability

Unfortunately, the timestamp protocol presented above permits schedules that are not recoverable, as illustrated by the schedule in Table below. If TS(T1) = 1 and TS(T2) = 2, this

schedule is permitted by the timestamp protocol (with or without the Thomas Write Rule). The timestamp protocol can be modified to disallow such schedules by buffering all write actions until the transaction commits. In the example, when T1 wants to write A, WTS(A) is updated to

reflect this action, but the change to A is not carried out immediately; instead, it is recorded in a private workspace, or buffer. When T2 wants to read A subsequently, its timestamp is compared

with WTS(A), and the read is seen to be permissible. However, T2 is blocked until T1 completes.

If T1 commits, its change to A is copied from the buffer; otherwise, the changes in the buffer are

discarded. T2 is then allowed to read A.

T1 T2

W(A)

R(A) W(B) Commit

This blocking of T₂ is similar to the effect of T₁ obtaining an exclusive lock on A! Nonetheless, even with this modification the timestamp protocol permits some schedules that are not permitted by 2PL; the two protocols are not quite the same.

Notes Because recoverability is essential, such a modification must be used for the timestamp protocol

to be practical. Given the added overheads this entails, on top of the (considerable) cost of maintaining read and write timestamps, timestamp concurrency control is unlikely to beat lock-based protocols in centralized systems. Indeed, it has mainly been studied in the context of distributed database systems.

Task _{If any transaction encounter unexpected situation then transaction} complete of incomplete.