[TroubleShooting] DB 쿼리 비용

👀 현재 상황 및 배경 설명

현재 가게 사진을 업데이트하는 로직은 모든 기존 사진을 삭제한 후 새로운 사진을 덮어쓰는 방식으로 작동하고 있다.

1. 기존 사진 URL을 데이터베이스에서 모두 조회
2. 기존 사진 URL을 DB에서 모두 삭제
3. 새로운 사진 URL을 DB에 모두 저장

 

▶ 구현 코드

/**
 * 가게 사진을 업데이트합니다.
 */
@Transactional
protected void updateMarketImages(Market market, List<String> imageUrls) {
    // 기존 사진 조회
    List<MarketImage> marketImageList = marketImageRepository.findAllByMarketId(market.getId());

    // DB에서 기존 사진 URL 모두 삭제
    marketImageRepository.deleteAll(marketImageList);

    // DB에 새로운 사진 URL 모두 저장
    for (String imageUrl : imageUrls) {
        MarketImage updateImage = MarketImage.builder()
                .market(market)
                .imageUrl(imageUrl)
                .build();

        marketImageRepository.save(updateImage);
    }
}

 

 

🚨 문제 상황

현재 방식은 사진이 하나만 변경되더라도 기존에 저장된 모든 사진을 삭제하고 새로운 사진을 다시 저장하는 구조이다. 이 방식이 변경할 사진만 비교해서 저장하는 방식보다 효율적인지 의문이 들었고, 이를 검토할 필요가 있다고 느꼈다.

 

 

✏️ 원인 분석

6개의 사진 중 하나만 변경한다고 가정할 경우, 각 방식의 쿼리 비용은 다음과 같다.

• 기존 방식: DELETE 쿼리 6번, INSERT 쿼리 6번 (고정)
• 개선 방식: SELECT 쿼리 6번, DELETE 쿼리 1번, INSERT 쿼리 1번

이를 바탕으로 각 쿼리 비용을 분석할 필요성을 느꼈다.

 

▶ DB 쿼리 비용 분석

각 쿼리는 읽기 비용과 쓰기 비용으로 나눌 수 있다.

• 읽기 비용: 주로 데이터를 조회하거나 검색하는 과정에서 발생하는 자원 사용량
• 쓰기 비용: 데이터를 변경하면서 발생하는 자원 사용량

🔽 SELECT (조회 쿼리)

• 읽기 비용
  • 인덱스 사용 여부: 인덱스를 사용하면 읽기 비용이 줄지만, 인덱스가 없으면 전체 테이블을 스캔하게 되어 읽기 비용이 증가한다.
  • 조인: 여러 테이블을 조인할 경우 디스크에서 데이터를 많이 읽어야 하므로 읽기 비용이 크게 증가한다.
• 쓰기 비용
  • 발생하지 않는다.

🔽 INSERT (삽입 쿼리)

• 읽기 비용
  • 일반적으로 발생하지 않지만, 데이터 중복 확인이 필요할 때 인덱스를 조회하는 과정에서 읽기 비용이 발생할 수 있다.
• 쓰기 비용
  • 데이터 삽입: 데이터를 테이블에 삽입하는 과정에서 쓰기 비용이 발생한다.
  • 인덱스 갱신: 인덱스가 설정된 경우, 삽입된 데이터로 인해 인덱스를 갱신하는 과정에서 쓰기 비용이 발생한다.
  • 트랜잭션 로그 기록: 삽입된 데이터를 트랜잭션 로그에 기록하는 과정에서 쓰기 비용이 발생한다.

🔽 UPDATE (갱신 쿼리)

• 읽기 비용
  • 검색 비용: 갱신하려는 데이터를 먼저 찾아야 하므로 읽기 비용이 발생한다. 인덱스를 사용하면 검색 비용이 줄어든다.
• 쓰기 비용 
  • 데이터 갱신: 변경된 데이터를 디스크에 다시 쓰는 작업에서 쓰기 비용이 발생한다.
  • 인덱스 갱신: 인덱스가 설정된 경우, 갱신된 데이터로 인해 인덱스를 갱신하는 과정에서 쓰기 비용이 발생한다.
  • 트랜잭션 로그 기록: 갱신된 데이터를 트랜잭션 로그에 기록하는 과정에서 쓰기 비용이 발생한다.

🔽 DELETE (삭제 쿼리)

• 읽기 비용
  • 검색 비용: 삭제할 데이터를 찾기 위해 테이블을 검색해야 한다. 인덱스를 사용하면 검색 비용이 줄어든다.
• 쓰기 비용 
  • 데이터 삭제: 삭제된 데이터를 디스크에서 제거하는 작업에서 쓰기 비용이 발생한다.
  • 인덱스 갱신: 인덱스가 설정된 경우, 인덱스를 갱신하는 과정에서 쓰기 비용이 발생한다.
  • 트랜잭션 로그 기록: 삭제된 데이터를 트랜잭션 로그에 기록하는 과정에서 쓰기 비용이 발생한다.
  • 참조 무결성 처리: 외래 키 제약 조건이 있는 경우, 삭제 시 연관된 데이터를 처리해야 하며, 이로 인해 추가적인 쓰기 비용이 발생한다.

 

▶ 쓰기 비용 vs 읽기 비용

일반적으로 쓰기 비용이 읽기 비용보다 더 높다.

🔽 쓰기 비용

• 디스크 I/O 비용: 데이터를 디스크에 저장하는 과정에서 많은 리소스가 필요하다.
• 트랜잭션 관리: 데이터 무결성을 보장하기 위해 트랜잭션 로그가 작성되며, 이로 인해 추가적인 디스크 공간과 쓰기 작업이 발생한다.
• 인덱스 갱신: 쓰기 작업 시 인덱스가 걸린 필드를 갱신해야 하므로 추가적인 쓰기 비용이 발생한다.
• 동시성 제어: 여러 쓰기 작업이 동시에 이루어질 때, 락 관리가 필요해 쓰기 비용이 증가한다.

디스크 I/O 비용: 데이터를 디스크에서 읽고 쓰는 작업과 관련된 시스템 자원 소모를 의미한다. 이 비용은 디스크가 데이터를 물리적으로 읽거나 쓰는 데 필요한 시간과 자원을 나타내며, 데이터베이스 성능에 중요한 영향을 미친다.

🔽 읽기 비용

• 디스크 읽기 비용: 데이터를 디스크에서 읽어오지만, 쓰기 작업보다 비용이 낮다.
• 캐시 사용: 읽기 작업은 메모리 캐시를 사용해 자주 조회되는 데이터에 더 빠르게 접근할 수 있다.
• 트랜잭션 로그 없음: 읽기 작업에는 트랜잭션 로그 기록이 필요 없으므로 비용이 절감된다.

따라서 읽기 작업 최적화를 위해 인덱스를 적절히 사용하고, 쓰기 작업을 최소화하는 방식으로 설계하는 것이 좋다.

 

 

🔨 해결 방법

사진을 업데이트할 때, 변경된 사진만 DB에 반영하도록 로직을 개선했다. 기존 사진과 새로운 사진을 비교해 삭제할 사진과 추가할 사진만 처리하는 방식이다.

/**
 * 가게 사진을 업데이트합니다.
 */
private void updateMarketImages(Market market, List<String> imageUrls) {
    // 기존 사진 List 조회
    List<MarketImage> existingMarketImages = marketImageRepository.findAllByMarketId(market.getId());

    // 기존 사진 URL List 조회
    List<String> existingMarketImageUrls = existingMarketImages.stream()
            .map(MarketImage::getImageUrl)
            .toList();

    // DB에 없는 사진 저장
    for (String imageUrl : imageUrls) {
        if (!existingMarketImageUrls.contains(imageUrl)) {
            MarketImage updateImage = MarketImage.builder()
                    .market(market)
                    .imageUrl(imageUrl)
                    .build();
            marketImageRepository.save(updateImage);
        }
    }

    // 새로 추가된 리스트에 없는 이미지는 삭제
    for (MarketImage existingMarketImage : existingMarketImages) {
        if (!imageUrls.contains(existingMarketImage.getImageUrl())) {
            marketImageRepository.delete(existingMarketImage);
        }
    }
}

 

 

🔍 결과 관찰

개선된 방식은 불필요한 삭제와 삽입을 최소화하여 데이터베이스의 쓰기 작업을 줄이고 전체 성능을 최적화할 수 있었다. 특히, 변경된 사진만 처리함으로써 디스크 I/O와 트랜잭션 처리 비용이 감소했음을 알 수 있다.

🔽 사진 3개 중 1개 변경 시 실행 쿼리

SELECT 쿼리 3번, INSERT 쿼리 1번, DELETE 쿼리 1번이 실행된다.

 

 

💡 고찰

이번 트러블슈팅을 통해 읽기 비용과 쓰기 비용에 대해 알게 되었고, 쓰기 비용이 읽기 비용보다 더 많이 소모된다는 것을 배웠다. 현재는 최대 6개의 사진만 처리하고, 인덱스를 사용하지 않고 있어 큰 성능 차이는 발생하지 않겠지만, 대량의 데이터를 처리하게 될 경우 이번 경험이 유용한 기반 지식이 될 것 같다. 데이터가 많아질수록 쿼리 성능이 중요해지므로, 이를 이해하는 것은 데이터베이스를 다루는 백엔드 개발자에게 필수적인 내용이라고 생각한다.

 

 

📍 참고 자료

• 대규모 읽기 및 쓰기 이해
• 서울시립대학교 데이터베이스 강의 참고