Download Database transaction

Database transaction is an important concept to understand while working in database and SQL. Transaction in database is
required to protect data and keep it consistent when multiple users access the database at same time.
What is transaction in database?
Database transaction is collection of SQL queries which forms a logical one task. For transaction to be
completed successfully all SQL queries has to run successfully. Database transaction executes either all or none, so for
example if your database transaction contains 4 SQL queries and one of them fails then change made by other 3 queries will
be rolled back. This way your database always remain consistent whether transaction succeeded or failed. Transaction is
implemented in database using SQL keyword transaction, commit and rollback. Commit writes the changes made by
transaction into database and rollback removes temporary changes logged in transaction log by database transaction.
Why transaction is required in database
Database is used to store data required by real life application e.g. Banking, Healthcare, Finance etc. All your money
stored in banks is stored in database, all your shares of DMAT account is stored in database and many application
constantly work on these data. In order to protect data and keep it consistent any changes in this data needs to be done
in transaction so that even in case of failure data remain in previous state before start of transaction. Consider a Classical
example of ATM (Automated Tailor Machine); we all use to withdraw and transfer money by using ATM. If you break
withdrawal operation into individual steps you will find:
1) Verify account details.
2) Accept withdrawal request
3) Check balance
4) Update balance
4) Dispense money
Suppose your account balance is 1000$ and you make a withdrawal request of 900$. At fourth step your balance is
updated to 900$ and ATM machine stops working due to power outage
Once power comes back and you again tried to withdraw money you surprised by seeing your balance just 100$ instead
of 1000$. This is not acceptable by any person in the world :) so we need transaction to perform such task. If SQL
statements would have been executed inside transaction in database balance would be either 100$ until money has been
dispensed or 1000$ if money has not been dispensed.
ACID Properties of database transaction
There are four important properties of database transactions these are represented by acronym ACID and also
called ACID properties or database transaction where:
A stands for Atomicity, Atom is considered to be smallest particle which can not be broken into further pieces.database
transaction has to be atomic means either all steps of transaction completes or none of them.
C stands for Consistency, transaction must leave database in consistent state even if it succeed or rollback.
I is for Isolation
Two database transactions happening at same time should not affect each other and has consistent view of database.
This is achieved by using isolation levels in database.
D stands for Durability
Data has to be persisted successfully in database once transaction completed successfully and it has to be saved from
power outage or other threats. This is achieved by saving data related to transaction in more than one places along with
database.
When to use database transaction
Whenever any operation falls under ACID criteria you should use transactions. Many real world scenarios require
transaction mostly in banking, finance and trading domain.
How to implement transaction in SQL
Database transaction is implemented in SQL using three keywords start transaction, commit and rollback.once you type
start transaction, database starts a transaction and execute all subsequent SQL statements in transaction and keep
track of all of them to either commit or rollback changes. Commit keywords saves then changes made by transaction
into database and after commit change is normally visible to other transaction though is subject to isolation level. In
case you encountered any error while executing individual sql statements inside database transaction, you can rollback
all your changes by executing "rollback" command.
Database Transaction Example
To understand database transaction better let's see a real life example of transaction in database. For this example we
will assume we have an Account table which represent a Bank Account and we will transfer money from one account to
another account
Request: transfer 900$ from Account 9001 to 9002
start transaction
select balance from Account where Account_Number='9001';
select balance from Account where Account_Number='9002';
update Account set balance=balance-900 here Account_Number='9001' ;
update Account set balance=balance+900 here Account_Number='9002' ;
commit; //if all sql queries succeed
rollback; //if any of Sql queries failed or error
Important point about database transaction
1. Database transaction is nothing but a set of SQL statement.
2. Transaction in database is either all or none means either all SQL statement success or none.
3. Its good practice to execute sql query inside transaction and commit or rollback based on result but you need to be
little careful with transaction log. To faciliate rollback and commit every sql query which executed inside database
transaction is written into transaction log and size of transaction log can grow significantly if don't commit or rollback for
longtime.
4. Effect of two simulteneous database transaction into data is controlled by using Isolation level. Isolation level is used
to separate one database transaction with other and currently there are four databse isolation levels:
1) Read Uncommited
This is lowest level of databse isolation level in this one database transaction can see changes made by other databse
transaction which is not yet commited. This can allow you dirty read so quite dangerous.
2) Read Commited
This is sligltly better where one database transaction only sees commited changes by other database transaction. But this
is also not safe and can lead you to non-repeatable reads problem.
3) Repeatable Reads
4) Serializable
Highest level of database isolation level. In this all database transactions are totally isolated with other database
transaction.though this is safe but this safety can cause significant performance hit.
To set an isolation level and declare a transaction you use the following syntax:
SET TRANSACTION
ISOLATION LEVEL READ UNCOMMITTED
GO
BEGIN TRANSACTION T1
--SQL statements here ...
IF <some condition>
ROLLBACK TRANSACTION T1
ELSE
COMMIT TRANSACTION T1
http://www.sqlteam.com/article/transaction-isolation-and-the-new-snapshot-isolation-level
http://www.c-sharpcorner.com/UploadFile/84c85b/understanding-transactions-in-sql-server/
Create Proc TranTest2
AS
BEGIN TRAN
INSERT INTO [authors]([au_id],
[au_lname],
[au_fname],
[phone],
[contract])
VALUES ('172-32-1176',
'Gates',
'Bill',
'800-BUY-MSFT',
1)
IF @@ERROR <> 0
BEGIN
ROLLBACK TRAN
return 10
END
UPDATE
SET
WHERE
authors
au_fname = 'Johnzzz'
au_id = '172-32-1176'
IF @@ERROR <> 0
BEGIN
ROLLBACK TRAN
return 11
END
COMMIT TRAN
GO
An SQL-transaction (transaction) is a sequence of executions of SQL-statements that is atomic with respect to recovery.
That is to say: either the execution result is completely successful, or it has no effect on any SQLschemas or SQL-data.
At any time, there is at most one current SQL-transaction between the SQL-agent and the SQL-implementation.
If there is no current SQL-transaction, execution of a transaction-initiating statement will initiate one.
Every SQL-transaction is terminated by either a commit statement or a rollback statement. The execution of either of these
statements may be implicit.
An SQL-transaction has a transaction state. Certain properties of the transaction state are set by the execution of SQLstatements. Such SQL-statements may be executed only when there is no SQL-transaction current. On the first occasion, at or
after a transaction is initiated, that the SQL-client connects to, or sets the connection to, an SQL-server, the properties are
sent to that SQL-server.
The access mode of an SQL-transaction indicates whether the transaction is read-only (is not permitted to
change any persistent SQL-data) or read-write (is permitted to change persistent SQL-data).
The isolation level of an SQL-transaction specifies the extent to which the effects of actions by SQL-agents other than in the
SQL-environment, are perceived within that SQL-transaction.
Every isolation level guarantees that every SQL-transaction is executed; SQL-transactions not executing completely fail
completely. Every isolation level guarantees that no update is lost. The highest isolation level SERIALIZABLE, guarantees
serializable execution, meaning that the effect of SQL-transactions that overlap in time is the same as the effect they would
have had, had they not overlapped in time. The other levels of isolation, REPEATABLE READ, READ UNCOMMITTED
and READ COMMITTED, guarantee progressively lower degrees of isolation.
Transactions in SQL:--------------------Definition: A transaction is unit of actions or unit of work performed in database.
Transactions are unit of actions or sequences of work accomplished on database in a logical order, performed
by manually by user or automatically done by some sort of database programming.
a transaction is propagation of one or more changes to database.
That is for example in real terms updating / deleting / inserting a record/s in table/database referred to
transaction.
so it is important to control transactions to ensure the data integrity and handling errors on database.
In practical, we club many sql queries into a group and will execute all of them together as a part of
transaction.
Properties of Transactions:---------------------------Four standards of programming are:
1.Atomicity
2.Consistency
3.Isolation
4.Durability
*1.Atomicity [] :
Ensures that all operations within the "work unit are completed successfully"; otherwise,
the transaction is aborted at the point of failure, and previous operations are rolled back to their former state.
{A transaction must be all-or-nothing. That is, the transaction must either fully happen, or not happen at all. It
must not complete partially.}
*2.Consistency [stable]: Ensures that the "database properly changes states upon a successfully committed
transaction".
{Ensures that only valid data following all rules and constraints is written in the database. When a transaction
results in invalid data, the database reverts to its previous state, which abides by all customary rules and
constraints.}
*3.Isolation [independent] : Enables "transactions to operate independently" of and transparent to each other.
{Ensures that transactions are securely and independently processed at the same time without interference,
but it does not ensure the order of transactions. For example, user A withdraws $100 and user B withdraws
$250 from user Z’s account, which has a balance of $1000. Since both A and B draw from Z’s account, one of
the users is required to wait until the other user transaction is completed, avoiding inconsistent data. If B is
required to wait, then B must wait until A’s transaction is completed, and Z’s account balance changes to
$900. Now, B can withdraw $250 from this $900 balance.}
Levels of Isolation:
A number of isolation levels are defined to control degree of data locking.
A high level of isolation might result in locking overhead for the system creating deadlocks.
/*The four major isolation levels are:*/
[1] Read Uncommitted:
This level deals with dirty reads, where the read data is not consistent with other parts of the table or query
and is not committed. Here data is read directly from table blocks without any verification, validation and
processing. Hence the data is as dirty as it can be.
[2]Read Committed:
In this case, rows that a query returns are rows already committed when the query started. As commit is
completed before the query started, the result is not displayed in the query output.
[3]Repeated Read: The rows returned by a query in this case are committed when the transaction was started.
The changes made are not present in the transaction and hence do not appear in the query result.
[4]Serializable:
In this level, transactions occur in a completely isolated fashion, serially one after another. Databases like
Oracle and Postgre SQL sometimes do not guarantee serial ordering of transactions, but do support snapshot
isolation where all reads in a transaction are consistent snapshots of the database and transaction commits
only if no updates produce conflicts with other concurrent updates made since the snapshot.
All databases permit users to set their default isolation levels. Perfect isolation levels chosen prevent
applications from introducing errors such as
1,Dirty reads,
2,Repeatable reads and
3,Phantom reads
1)Dirty reads:
When the first transaction reads uncommitted changes made by the second transaction, it gives rise to dirty
reads.
2)Repeatable reads:
When a data read remains the same if read again during the same transaction, it is a repeatable read.
3)Phantom reads:
Phantom reads occur when new records added are pointed out by transactions prior to insert.
/*The different database locks isolation levels deal with are: */
<1>Read Locks: Read locks prevents changing data read during a transaction till the transaction ends
eliminating cases of repeatable reads. Other transactions can read this data but no write or change access is
provided.
<2>Write Locks: Write locks prevent other transactions from changing data until the transaction ends.
<3>Exclusive Write Locks: Exclusive write lock prevents other transactions from reading or altering data until
the current transaction ends.
<4>Snapshots: A snapshot is a frozen view of the data when the transaction starts. It prevents dirty reads,
nonrepeatable reads and phantom reads. This definition was written in the context of Databases.
*4.Durability [performance] :
-Ensures that the "result or effect of a committed transaction persists in
case of a system failure".
-Committed data is saved by the system such that, even in the event of a failure and system
restart, the data is available in its correct state.
[********It deals with consistency and completeness of data retrieved by queries unaffecting a user data by other
user actions. A database acquires locks on data to maintain a high level of isolation.*******]
{In the above example, user B may withdraw $100 only after user A’s transaction is completed and is updated
in the database. If the system fails before A’s transaction is logged in the database, A cannot withdraw any
money, and Z’s account returns to its previous consistent state.}