mengenal transaksi

Concurrency control

Tujuan utama dalam pengembangan database adalah membuat banyak pengguna bisa mengakses data secara bersamaan. Pengaksesan data ini tidak bermasalah jika semua pengguna hanya membaca data dan mereka tidak mengganggu satu sama lain. Tapi ketika dua pengguna atau lebih mengakses database yang sama secara bersamaan dan salah satu melakukan perubahan terhadap data, maka hal ini akan dapat menimbulkan adanya data yang tidak konsisten (inconsistency data).

STUDY KASUS:

1.      Transaksi Lost-Update

-          Jika transaksi tidak Lost-Update

time	Petugas1 (pet1)	Petugas2 (pet2)	Hasil
1		Begin_transaksi	10
2		Read(hasil_transaksi)	10
3		Hasil = hasil +100	10
4		Write(hasil)	110
5		Commit	110
6	Begin_transaction
7	Read (hasil)		110
8	Hasil= hasil - 1		109
9	Write(hasil)		109
10	commit		109

-          jika transaksi Lost-Update

time	Petugas1 (pet1)	Petugas2 (pet2)	Hasil
1		Begin_transaksi	10
2	Begin_transaction	Read(hasil_transaksi)	10
3	Read (hasil)	Hasil = hasil +10	10
4	Hasil= hasil - 1	Write(hasil)	20
5	Write(hasil)	Commit	9
6	commit		9

Penjelasan :

Transaksi pet1 dan pet2 mulai pada waktu yang hampir bersamaan, dan keduanya membaca saldo $10. Pet2 menambah hasil $10 menjadi $20 dan menyimpan hasil perubahannya dalam database. Di sisi lain, transaksi pet1 mengurangi copy dari hasil $10 menjadi $9 dan menyimpan nilai ini dalam database, menimpa hasil update sebelumnya dan akhirnya menghilangkan $10 yang telah ditambahkan sebelumnya ke dalam saldo. Kehilangan update transaksi pet2 dapat dihindari dengan mencegah pet1 membaca nilai dari hasil sampai update pet2 telah selesai.

2.      Uncommited Dependency (dirty read)

-          jika transaksi tidak uncommitted Dependency (dirty read)

time	transaksi	Petugas1 (pet1)	Petugas2 (pet2)	Hasil
1	Pet1		Begin_transaksi	10
2	Pet1		Read(hasil_transaksi)	10
3	Pet1		Hasil = hasil +100	10
4	Pet1		Write(hasil)	110
6	Pet1		ROLLBACK	50
6	Pet2	Begin_transaction
7	Pet2	Read (hasil)		50
8	Pet2	Hasil= hasil - 1		49
9	Pet2	Write(hasil)		49

-          jika transaksi uncommitted Dependency (dirty read)

time	transaksi	Petugas1 (pet1)	Petugas2 (pet2)	Hasil
1	Pet1		Begin_transaksi	10
2	Pet2	Begin_transaction	Read(hasil_transaksi)	10
3	Pet1		Hasil = hasil +100
4	Pet1		Write(hasil)	110
5	Pet2
6	Pet1	Hasil= hasil – 1	ROLLBACK	10
7	Pet1	Write(hasil)	Commit	9
8	Pet2	commit		9

3.      Inconsistent Analysis

Time	T5	T6	Balx	Baly	Balz	sum
T1		Begin_tran	100	50	25
T2	Begin_tran	Sum=0	100	50	25	0
T3	Read(Balz)	Read(Balz)	100	50	25	0
T4	Balz = Balz – 10	Sum = sum + Balz	100	50	25	100
T5	Write(Balz)	Read(Baly)	90	50	25	100
T6	Read(Balz)	Sum = sum + Baly	90	50	25	150
T7	Balz = Balz – 10		90	50	25	150
T8	Write(Balz)		90	50	25	150
T9	COMMIT	Read(Balz)	90	50	25	150
T10		Sum = sum + Balz	90	50	25	180
T11		COMMIT	90	50	25	180

Penjelasan:

Masalah inconsistent analysis muncul ketika sebuah transaksi membaca beberapa nilai dari database tapi transaksi kedua mengubah beberapa darinya ketika eksekusi transaksi yang pertama. Contohnya, sebuah transaksi yang meringkas data pada sebuah database(contohnya, saldo total) akan mendapat hasil yang tidak akurat jika, ketika berjalan, transaksi lain sedang mengubah database. Pada contoh diatas, ringkasan transaksi T6 sedang berjalan secara bersamaan dengan transaksi T5. Transaksi T6 sedang menjumlahkan saldo rekening x ($100), rekening y ($50), dan rekening z($25). Namun, di tengah jalan, transaksi T5 telah mentransfer $10 dari balx ke bal­z, sehingga T6 sekarang mempunyai hasil yang salah (lebih besar $10).