Transaction-ACID

1. Transaction란?👀

=> 작업의 단위!!

예시)
1) PointTransaction 테이블에 충전했다고 1줄 작성(insert)
2) User 테이블에서 철수 데이터를 가져옴(select)
3) 기존 500원에 충전 3000원을 더한 3500원으로 업데이트 (update)

[Case1]
1번은 성공 2,3번은 실패 => 차라리 전체 다 실패하고 다시 시도하는 것이 좋음
하나로 묶기(3개모두 성공해야 완전 성공, 하나라도 실패하면 rollback)

❗❗서비스에서 가장 큰 문제점 ==> 데이터의 오염❗❗
=> transaction-commit-rollback 으로 데이터의 오염을 방지 가능

typeOrm-queryRunner사용
=> 사용하기위해서는 typeOrm,mysql연결 필요
import { Connection } from ''typeorm'을 통해 의존성 주입가능
의존성을 토대로 createQueryRunner()함수를 이용하여 Transaction Manager수행 가능

전체적인 로직은 try-catch-finally로 감싸주고 Transction을 처리하는 save Method는 queryRunner.manager를 이용

🔎모든 코드가 Error없이 로직을 수행하면 Transaction이 완료되어 commitTransction()을 호출을 통해 최종적으로 성공 확정하고 finally에서 release()함수를 통해 Transaction종료!
❗중간에 Error가 발생했다면 catch에서 잡아내서 rollbackTransaction()을 통해 rollack수행!

[Transaction 예시 코드]

import { HttpException, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { throws } from 'assert';
import { Connection, Repository } from 'typeorm';
import { User } from '../users/entities/user.entity';
import {
  PointTransaction,
  POINT_TRANSACTION_STATUS_ENUM,
} from './entities/pointTransaction.entity';

@Injectable()
export class PointTransactionService {
  constructor(
    @InjectRepository(PointTransaction)
    private readonly pointTransacrionRepository: Repository<PointTransaction>,
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,

    private readonly connection: Connection,
  ) {}

  // 결제 정보 저장
  async create({ impUid, amount, currentUser }) {
    const queryRunner = await this.connection.createQueryRunner();
    await queryRunner.connect();

    // transaction 시작!!
    await queryRunner.startTransaction();
    try {
      // 1. pointTransaction 테이블에 거래기록만 1줄 생성(아직 실제 포인트는 변동X)
      const pointTransaction = await this.pointTransacrionRepository.create({
        impUid: impUid,
        amount: amount,
        user: currentUser,
        status: POINT_TRANSACTION_STATUS_ENUM.PAYMENT,
      });

      //  queryRunner를 통해 save!
      await queryRunner.manager.save(pointTransaction); // === await this.pointTransacrionRepository.save(pointTransaction);

  
      // 유저의 기존 포인트 찾아오기
      const user = await this.userRepository.findOne({ id: currentUser.id });

      // await this.userRepository.update(
      //   { id: user.id },
      //   { point: user.point + amount },
      // );

      //  queryRunner를 통해 save!
      const updatedUser = this.userRepository.create({
        ...user, // 기존 유저
        point: user.point + amount, // 포인트만 변경
      });
      await queryRunner.manager.save(updatedUser); // === this.userRepository.save(updatedUser)

      // commit 성공 확정!!!
      await queryRunner.commitTransaction();

      //save는 실제 저장 결과 반환 가능 update는 과정만 출력
      // 3. 최종 결과 프론트엔드에 돌려주기
      return pointTransaction;
    } catch (error) {
      // rollback 되돌리기!!
      await queryRunner.rollbackTransaction();
    } finally {
      // 성공해도 실패해도 모두 실행되어야함
      // queryRunner 연결 해제!
      await queryRunner.release();
    }
  }
}

2. Transaction의 속성(ACID)🤔

Atomicity(원자성) : 모두 성공할거 아니면 다 실패하기 해줘! 오염은 싫어!
Consistency(일관성) : 똑같은 쿼리는 조회할 때 마다 동일해야돼!
Isolation(격리성) : 철수꺼 처리하는 동안 영희는 기다려줄래?
Durability(지속성) : 한 번 성공했으면 장애가 발생해도 살아있어야돼!

3. Transaction-isolation

isolation은 Transaction의 격리 수준❗

📌 read-uncommitted => commit되지 않은 것도 조회 가능
==> dirty-read(더러운 읽기) - Transaction작업이 완료되지 않았는데도 다른 Transaction에서 볼 수 있게 되는 현상

[read-uncommitted 적용 예시]

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Connection, Repository } from 'typeorm';
import { Payment } from './entities/payment.entity';

@Injectable()
export class PaymentService {
constructor(
 @InjectRepository(Payment)
 private readonly paymentRepository: Repository<Payment>,

 private readonly connection: Connection,
) {}

async create({ amount }) {
 const queryRunner = await this.connection.createQueryRunner();
 await queryRunner.connect();
 await queryRunner.startTransaction('READ UNCOMMITTED');
 try {
   const payment = await this.paymentRepository.create({ amount });
   await queryRunner.manager.save(payment);

   // 5초 뒤에 특정 이유로 실패함!!!
   setTimeout(async () => {
     await queryRunner.rollbackTransaction();
   }, 5000);
   //   await queryRunner.commitTransaction();
 } catch (error) {
   await queryRunner.rollbackTransaction();
 }
}

async findAll() {
 const queryRunner = await this.connection.createQueryRunner();
 await queryRunner.connect();
 await queryRunner.startTransaction('READ UNCOMMITTED');
 try {
   // 만약 5초 이내에 조회하면, 위에서 등록한 금액(커밋되지 않은 금액)이 조회됨
   const payment = await queryRunner.manager.find(Payment);
   await queryRunner.commitTransaction();
   return payment;
 } catch (error) {
   await queryRunner.rollbackTransaction();
 }
}
}

📌 Read-committed => commite된 것만 조회 가능
==> Non-Repeatable-Read(반복적이지 않은 조회)
Transaction-1이 commit전 Transaction-2가 테이블 값을 읽으면 기존 값 출력
Transaction-1이 commit후 아직 끝나지 않은 Transaction-2가 다시 테이블 값을 읽으면 변경된 값이 출력
*MySQL에서는 Transaction마다 TransactionID를 부여하여 TransactionID보다 작은 Transaction번호에서 변경한 것만 읽음
=> Undo 공간에 백업해두고 실제 레코드 값을 변경

• 백업된 데이터는 불필요하다고 판단하는 시점에 주기적으로 삭제 필요
• Undo에 백업된 레코드가 많아지면 MySQL 서버의 처리 성능 저하
  ==> 이러한 변경방식은 MVCC(Multi Version Concurrency Control)

[read-committed 적용 예시]

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Connection, Repository } from 'typeorm';
import { Payment } from './entities/payment.entity';

@Injectable()
export class PaymentService {
  constructor(
    @InjectRepository(Payment)
    private readonly paymentRepository: Repository<Payment>,

    private readonly connection: Connection,
  ) {}

  async findAll() {
    const queryRunner = await this.connection.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction('READ COMMITTED');
    try {
      // 하나의 트랜잭션 내에서 500원이 조회됐으면,
      // 해당 트랜잭션이 끝나기 전까지는(커밋 전까지는) 다시 조회하더라도 항상 500원이 조회(Repeatable-Read) 되어야 함
      // 1초간 반복해서 조회하는 중에, 누군가 등록하면(create), Repeatable-Read 보장되지 않음 => Non-Repeatable-Read 문제!!!
      setInterval(async () => {
        const payment = await queryRunner.manager.find(Payment);
        console.log(payment);
      }, 1000);

      //   await queryRunner.commitTransaction()const payment = await queryRunner.manager.find(Payment);;
    } catch (error) {
      await queryRunner.rollbackTransaction();
    }
  }

  async create({ amount }) {
    const queryRunner = await this.connection.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction('READ COMMITTED');
    try {
      // 중간에 돈 추가해보기
      const payment = await this.paymentRepository.create({ amount });
      await queryRunner.manager.save(payment);
      await queryRunner.commitTransaction();
    } catch (error) {
      await queryRunner.rollbackTransaction();
    }
  }
}

📌 Repeatable-Read => 반복적인 조회
==> Phantom-Read(유령 읽기) (= Mysql은 디폴트 차단)
종종 다른 트랜잭션에서 수행한 변경 작업에 의해 레코드가 보였다가 안 보였다가 하는 현상

📌 Seriaizable
성능 측면에서는 동시 처리 성능이 가장 낮으며 가장 단순한 격리 수준이지만 가장 엄격❗❗
DB에서는 거의 사용되지 않음

낙관적락 vs 비관적락
[비관적락의 종류]
공유락(Shared Lock) - 읽기전용 쓰기잠금( pessimistic_read)
베타락(Exclusive Lock) - 읽기쓰기 모두 잠금(pessimistic_write)

[Seriaizable 적용 예시]

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Connection, Repository } from 'typeorm';
import { Payment } from './entities/payment.entity';

@Injectable()
export class PaymentService {
  constructor(
    @InjectRepository(Payment)
    private readonly paymentRepository: Repository<Payment>,

    private readonly connection: Connection,
  ) {}

  async findAll() {
    const queryRunner = await this.connection.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction('SERIALIZABLE');
    try {
      // 조회시 락을 걸고 조회함으로써, 다른 쿼리에서 조회 못하게 막음(대기시킴) => Select ~ For Update
      const payment = await queryRunner.manager.find(Payment, {
        lock: { mode: 'pessimistic_write' },
      });
      console.log(payment);

      // 처리에 5초간의 시간이 걸림을 가정!!
      setTimeout(async () => {
        await queryRunner.commitTransaction();
      }, 5000);
      return payment;

      // await queryRunner.commitTransaction()const payment = await queryRunner.manager.find(Payment);;
    } catch (error) {
      await queryRunner.rollbackTransaction();
    }
  }

  async create({ amount }) {
    const queryRunner = await this.connection.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction('SERIALIZABLE');
    try {
      // 조회를 했을때, 바로 조회되지 않고 락이 풀릴 때 까지 대기
      const payment = await queryRunner.manager.find(Payment);
      console.log('========== 철수가 시도 ==========');
      console.log(payment);
      console.log('==============================');
      await queryRunner.commitTransaction();
      return payment;
    } catch (error) {
      await queryRunner.rollbackTransaction();
    }
  }
}

❗❗❗❗Serializable가 무조건적으로 좋은 건 아님! 속도가 느려질 수 있어서 상황에 맞게 사용해야함❗❗❗❗
🔎 데드락(동시적으로 락이 걸린 상태)
=> 하나를 강제로 rollback필요(가급적이면 피하는게 좋음)

---

공부하며 작성하고 있는 블로그입니다.
잘못된 내용이 있을 수 있으며 혹시 있다면 댓글 달아주시면 감사하겠습니다 😊