[데이터베이스시스템] 트랜잭션

트랜잭션의 이해

데이터 동시 접근의 문제

동일 데이터에 다수 사용자의 접근 허용시 일관성이 훼손

트랜잭션의 개념

• 데이터 베이스를 조작하기 위한 하나의 논리적 단위를 이루는 일련의 연산의 집합

→ 예시) 예금 인출

• 작업 단위 : 예금 1000원 인출
• 일련의 연산 : Read(A) , A= A-1000, Write(A)
• 데이터베이스를 사용하여 처리하는 작업을 하나의 묶음으로 인식하여 묶음 단위로 실행되도록 정의한 개념

트랜잭션의 특징

• 다수의 연산으로 구성된 트랜잭션이 사용자에게 단일 작업처럼 다뤄지도록 ACID 특징을 준수
• ACID 특성

→ 원자성(atomicity) : 하나의 트랜잭션에 포함된 모든 연산은 완전히 수행되거나 전혀 수행되지 않음

→ 일관성(consistency) : 특정 트랜잭션이 수행되기 전과 후에 데이터 베이스가 일관된 상태를 유지

→ 고립성(isolation) : 특정 트랜잭션이 데이터베이스를 갱신하는 동안 다른 트랜잭션에 의해 방해받지 않음

→ 지속성(durability) : 완료된 트랜잭션의 결과는 어떠한 시스템의 장애에도 데이터베이스에 반영

트랜잭션 읽기와 쓰기

• 트랜잭션의 두 연산

→ Read(X) : 데이터베이스에서 데이터 X를 읽고, 트랜잭션이 실행되는 메모리의 변수 X에 값을 저장하는 연산

→ Write(X) : 트랜잭션이 실행되는 메모리에 있는 변수 X의 값을 데이터베이스에 저장하는 연산

• 계좌 A에서 B로 1000원을 이체하는 트랜잭션

Read(A)
A := A - 1000
Write(A)
Read(B)
B := B + 1000
Write(B)

트랜잭션 연산자

• 트랜잭션의 연산

→ Read(X) : 데이터베이스에서 데이터 X를 읽고, 트랜잭션이 실행되는 메모리의 변수 X에 값을 저장하는 연산

→ Write(X) : 트랜잭션이 실행되는 메모리에 있는 변수 X의 값을 데이터 베이스에 저장하는 연산

• 트랜잭션 실행의 연산

→ Commit : 트랜잭션 연산에 의해 갱신된 데이터 항목의 값을 데이터베이스에 반영 시키고 지속성을 확보하는 연산

→ Rollback : 트랜잭션이 중단되기 이전까지 수행한 연산에 의해 갱신된 모든 데이터 항목의 값을 무효화하여 일관성을 확보하는 연산

트랜잭션의 5가지의 상태변화

동작 → 부분커밋(실패로 갈 수 있음) → 커밋

동작 → 실패 → 중단

1. 동작 : 트랜잭션이 시작을 준비 또는 실행 중인 상태
2. 부분 커밋 : 마지막 연산을 실행한 직후의 상태
3. 커밋 : 모든 실행이 성공적으로 완료된 후의 상태
4. 실패 : 실행이 정상적으로 진행될 수 없는 상태
5. 중단 : 실행 실패로 롤백 되고 시작 이전의 상태로 환원된 상태

트랜잭션의 동시성

동시성 고려

• DBMS는 다수의 사용자가 데이터베이스를 공용으로 사용하기 위한 목적으로 도입
• 트랜잭션 동시 실행의 이점

→ 트랜잭션 처리율과 자원 이용률을 향상

→ 트랜잭션의 대기 시간을 감소

• 다중 사용자 환경에서 트랜잭션의 동시 실행으로 데이터 갱신 시, 일관성 훼손 문제가 발생
• 동시성 제어(concurrency control)

→ 다수의 트랜잭션이 성공적으로 동시에 실행되어도 일관성을 유지할 수 있도록 지원하는 기법

적용 트랜잭션

1. A와 B에 각각 10,000 과 20,000원 잔액
2. T : 1000원을 계좌 A에서 B로 이체
3. T : 계좌 A의 잔고에서 20%를 B로 이체

1. T
Read(A)
A := A - 1000
Write(A)
Read(B)
B := B + 1000
Write(B)

2. T
Read(A)
temp := A * 0.2
A := A - temp
Write(A)
Read(B)
B := B + temp
Write(B)

• 스케줄(schedulte)

→ 다수의 트랜잭션에 포함된 연산의 실행 순서를 명시한 것

직렬 스케줄

• T와 T가 순차적으로 실행되는 스케줄
• 각 트랜직션에 속한 모든 연산이 순차적으로 실행되는 스케줄

스케줄 1

1. T
Read(A) // 10000
A := A - 1000 // 9000
Write(A) 
Read(B) // 20000
B := B + 1000 // 21000
Write(B)
Commit // a - 9000 , b - 21000 db 저장 total : 30000

2. T
Read(A)//9000
temp := A * 0.2 // 1800
A := A - temp //7200
Write(A) 
Read(B) // 21000
B := B + temp //22800
Write(B)
Commit // a - 7200 , b - 22800 db 저장 total : 30000

스케줄 2

2. T
Read(A) // 10000
temp := A * 0.2 // 2000
A := A - temp // 8000
Write(A)
Read(B) // 20000
B := B + temp // 22000
Write(B)
Commit // a - 8000 , b - 22000 db 저장 total 30000

1. T
Read(A) // 8000
A := A - 1000 // 7000
Write(A)
Read(B) // 22000
B := B + 1000 // 23000
Write(B)
Commit // a - 7000 , b - 23000 db 저장 total 30000

→ 스케줄1 과 스케줄 2의 결과가 30,000원 으로 같다 일관성 유지

병렬 스케줄

• T1 과 T2의 비 순차적 실행되는 스케줄
• 하나의 트랜잭션이 완료되기 전에 다른 트랜잭션이 실행되는 스케줄
• 병렬 스케줄의 순서로 연산을 수행할 경우 일관성의 훼손이 발생 가능

스케줄3

1. T1              2.T2
Read(A) // 10000
A := A - 1000 // 9000
Write(A) // 9000 db 저장
									 Read(A) // 9000
									 temp := A * 0.2 // 1800 
									 A := A - temp // 7200
									 Write(A) // 7200 db 저장
Read(B) // 20000
B := B + 1000 // 21000
Write(B) 
Commit // a - 7200 , b - 21000 db저장 total 28200 
								   Read(B) // 21000
								   B := B + temp // 22800
								   Write(B) 
								   Commit // a - 7200 , b - 22800 db저장 total : 30000

스케줄4

1. T1              2.T2
Read(A) // 10000
A := A - 1000 // 9000
									 Read(A) // 10000
									 temp := A * 0.2 // 2000
									 A := A - temp // 8000
									 Write(A) // 8000 db 저장
									 Read(B) // 20000
Write(A) // 9000 db 저장 (이전 t2 저장을 무시)
Read(B) // 20000
B := B + 1000 // 21000
Write(B) // 21000 db 저장
Commit

								   B := B + temp // 22000
								   Write(B) // 22000 db 저장 (이전 t1 저장을 무시)
								   Commit // a - 9000 , b - 22000 db저장 : 31000

→ 스케줄 4번은 일관성 훼손

직렬 가능 스케줄

• 복수개의 트랜잭션이 동시에 수행된 결과가 직렬 스케줄의 결과와 동일한 스케줄

스케줄5

	1. T1             2. T2
	Read(A)
	Write(A)
									  Read(A)
									 	Write(A)
  Read(B)
  Write(B)
  									Read(B)
  									Write(B)

직렬 가능 스케줄의 정의

• 트랜잭션 간 연산 순서를 교환하여 트랜잭션을 직렬 스케줄과 동등하게 변환이 가능한 스케줄
• 사용된 Read와 Write 연산 교환 시 상황에 따라 실행 결과에 일관성이 훼손되는 현상(충돌)이 발생
• 연산 순서의 교환 ( 단 I1은 T1의 연산 )

I1 = Read(Q) I2 = Read(Q) → Read에서 Read만 충돌을 일으키지 않음

I1 = Read(Q) I2 = Write(Q)

I1 = Write(Q) I2 = Read(Q)

Ii = Write(Q) I2 = Write(Q)

충돌 동등

• 특정 스케줄 S에서 충돌이 일어나지 않는 연산의 순서를 바꿔 스케줄 S`로 변환이 가능한 상태

충돌 직렬성

• 순서 교환이 가능한 연산을 교환하여 직렬 스케줄의 연산과 동등하게 변환이 가능한 스케줄

[위 코드에서 아래코드로 변경]

	1. T1             2. T2
	Read(A)
	Write(A)
									  Read(A)
									 	Write(A)
  Read(B)
  Write(B)
  									Read(B)
  									Write(B)

	1. T1             2. T2
	Read(A)
	Write(A)
  Read(B)
  Write(B)
									  Read(A)
									  Write(A)
									  Read(B)
									  Write(B)

트랜잭션 회복

회복의 개념

• 원자성을 보장하기 위해 트랜잭션 실패 시 실행된 모든 연산을 실행 이전 상태로 복원하는 기법

회복 불가능한 스케줄

→ T6가 T5가 기록한 A를 읽고 커밋한 상태

→ 커밋한 T6은 롤백 불가능

T5         T6
Read(A)
Write(A)
					Read(A)
					Commit
Read(B)//error

회복이 가능한 스케줄

• T1와 T2에 대해, T1가 기록한 데이터를 T2가 읽을 때, T1의 커밋이 T2보다 먼저 나타나는 스케줄
• 연쇄적 롤백 유발 가능

→ T7의 롤백으로 인하여 연쇄적으로 다른 트랜잭션도 롤백 되는 현상

T7       T8      T9
Read(A)
Write(A)
				Read(A)
				Write(A)
								Read(A)
Abort

비연쇄적 스케줄

• 연쇄적 롤백으로 발생할 수 있는 대량의 회복 연산을 방지하기 위해 연쇄적이지 않은 스케줄로 구성된 스케줄
• T1가 기록한 데이터를 읽을 때, T1의 커밋이 T2의 읽기 연산보다 먼저 나타나는 스케줄

T7       T8      T9
Read(A)
Write(A)
Commit
				Read(A)
				Write(A)
				Commit
								Read(A)