[JPA] 페치 조인

 

 

 

 

 

 

페치 조인(fetch join)

 

페치 조인이란 SQL 조인의 종류가 아니며, JPQL에서 성능 최적화를 위해서 제공해주는 기능입니다.

 

페치 조인은 엔티티를 조회할 때 연관된 엔티티나 컬렉션을 한번의 SQL로 함께 조회하는 기능을 제공함으로써 N+1문제를 해결할 수 있게 도와줍니다.

 

일반 조인은 실행 시 연관된 엔티티를 함께 조회하지 않습니다.

단지 데이터베이스 상에서 테이블간의 탐색을 위해 사용되는 것입니다.

 

 

 

 

 

 

 

 

 

기존 조인의 문제

@Entity
class Member(
    @Id @Column(name = "member_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long = 0,

    var username: String,

    var age: Int,

    @Embedded
    var address: Address,

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "team_id")
    var team: Team? = null,
) {
    override fun toString(): String {
        return "Member(id=$id, username='$username', age=$age, address=$address, team=$team)"
    }
}

@Entity
class Team(
    @Id @Column(name = "team_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long = 0,

    var name: String,

    @OneToMany(mappedBy = "team")
    var members: MutableList<Member> = ArrayList()

) {}

 

 

 

위와 같이 Team과 Member 클래스가 있다고 하겠습니다.

 

 

 

val teamA = Team(name = "TEAM A")
val teamB = Team(name = "TEAM B")
val teamC = Team(name = "TEAM C")

val member = Member(username = "user 1", age = 10, address = Address("1", "1", "1"), team = teamA)
val member1 = Member(username = "user 2", age = 10, address = Address("1", "1", "1"), team = teamA)
val member2 = Member(username = "user 3", age = 10, address = Address("1", "1", "1"), team = teamB)
val member3 = Member(username = "user 4", age = 10, address = Address("1", "1", "1"), team = teamC)
em.persist(teamA)
em.persist(teamB)
em.persist(teamC)
em.persist(member)
em.persist(member1)
em.persist(member2)
em.persist(member3)
em.flush()
em.clear()


val resultList = em.createQuery("select m from Member m", Member::class.java).resultList
resultList.forEach{ println("${it.username} + ${it.team?.name}" ) }

 

위 코드의 결과는 다음과 같습니다.

 

 

N + 1 문제가 발생합니다.

 

 

 

 

 

 

 

페치 조인 사용 예시

 

JPQL 부분을 제외하고는 똑같은 코드입니다.

val teamA = Team(name = "TEAM A")
val teamB = Team(name = "TEAM B")
val teamC = Team(name = "TEAM C")

val member = Member(username = "user 1", age = 10, address = Address("1", "1", "1"), team = teamA)
val member1 = Member(username = "user 2", age = 10, address = Address("1", "1", "1"), team = teamA)
val member2 = Member(username = "user 3", age = 10, address = Address("1", "1", "1"), team = teamB)
val member3 = Member(username = "user 4", age = 10, address = Address("1", "1", "1"), team = teamC)
em.persist(teamA)
em.persist(teamB)
em.persist(teamC)
em.persist(member)
em.persist(member1)
em.persist(member2)
em.persist(member3)
em.flush()
em.clear()


val resultList = em.createQuery("select m from Member m join fetch m.team", Member::class.java).resultList
resultList.forEach{ println("${it.username} + ${it.team?.name}" ) }

 

실행 결과는 다음과 같습니다.

 

 

 

 

 

 

 

 

 

 

 

사용법

[ LEFT [OUTER] | INNER ] JOIN FETCH 조인경로

 

일반 join 뒤에 fetch를 붙여주면 사용할 수 있습니다.

 

페치 조인은 엔티티를 대상으로 할 수 있고, 컬렉션을 대상으로 할 수 있습니다.

 

 

 

 

 

 

 

 

 

 

 

엔티티 페치 조인

페치 조인을 사용해서 회원 엔티티를 조회하면서 연관된 팀 엔티티도 함께 조회해보겠습니다.

SELECT m FROM Member m join fetch m.team

 

 

 

실행되는 쿼리는 다음과 같습니다.

 

 

 

 

 

 

 

 

 

 

 

 

컬렉션 페치 조인

이번에는 팀에서 회원들의 리스트를 함께 조회해보겠습니다.

SELECT t FROMTeam t join fetch t.members where t.name = '팀A'

 

 

실행되는 쿼리는 다음과 같습니다.

 

 

 

 

 

 

 

 

 

 

주의점

데이터베이스는 컬렉션을 조인하면 데이터가 늘어납니다.

(2023-1월 7일 추가 - 하이버네이트6 부터는 distinct 명령어를 사용하지 않아도 엔티티의 중복을 제거하도록 변경되었습니다.)
따라서 아래 내용은 이전 버전에 해당됩니다.

이전 버전에서 발생했던 오류가 관심 없으시다면 주의점을 건너뛰시면 됩니다. :)

참고 - https://github.com/hibernate/hibernate-orm/blob/6.0/migration-guide.adoc#distinct

 

예시 코드와 함께 살펴보겠습니다.

val teamA = Team(name = "TEAM A")
val teamB = Team(name = "TEAM B")
val teamC = Team(name = "TEAM C")

val member = Member(username = "user 1", age = 10, address = Address("1", "1", "1"), team = teamA)
val member1 = Member(username = "user 2", age = 10, address = Address("1", "1", "1"), team = teamA)
val member2 = Member(username = "user 3", age = 10, address = Address("1", "1", "1"), team = teamB)
val member3 = Member(username = "user 4", age = 10, address = Address("1", "1", "1"), team = teamC)
em.persist(teamA)
em.persist(teamB)
em.persist(teamC)
em.persist(member)
em.persist(member1)
em.persist(member2)
em.persist(member3)
em.flush()
em.clear()


val resultList = em.createQuery("select t from Team t join fetch t.members", Team::class.java).resultList
resultList.forEach{ println("${it.name} + ${it.members.size}" ) }

 

위 코드의 결과는 다음과 같습니다.

 

 

 

 

원인

출처 [인프런 - 자바 ORM 표준 JPA 프로그래밍 ]

 

 

팀 A에 소속되어 있는 회원이 2명일 때, TEAM과 MEMBER를 조인해서 가져오면 row가 2줄로 늘어나게 됩니다.

 

JPA는 그럼 2줄을 모두 가져오기 때문에, 팀A를 2개 가지고 오게 됩니다.

 

따라서  SELECT t FROM Team t join fetch t.members where t.name = '팀A' 과 같은 쿼리를 수행한 결과의 List의 size는 2개가 되어버리는 것입니다.

 

 

 

 

 

 

 

 

 

 

 

DISTINCT

JPQL에서는 SQL에서 제공하는 DISTINCT라는 명령어를 제공합니다.

 

SQL의 DISTINCT 명령어는 중복된 결과를 제거하는 명령이지만, JPQL의 DISTINCT는 한가지 기능이 더 있습니다.

 

• SQL에 DISTINCT를 추가합니다.
• 애플리케이션에서 엔티티의 중복을 제거합니다.

 

왜 기능을 하나 더 추가한 것일까요? 

 

 

SQL의 DISTINCT는 ROW의 모든 속성이 같아야만 제거가 됩니만, 해당 기능으로는 해결되지 않는 부분이 있습니다.

 

 

ID와 NAME이 다르기 때문에 SQL의 DISTINCT로는 제거가 되지 않습니다.

 

따라서 JPQL의 DISTINCT는 이를 해결하기 위해 엔티티의 중복을 제거하는 기능을 추가로 넣어준 것입니다.

 

JOIN한 Member의 데이터는 제거되지 않고 1차캐시에 보관됩니다.

 

제거되는 것은 중복된 팀A 라는 이름의 Team 엔티티 뿐입니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

페치 조인의 특징과 한계

페치 조인 대상에는 별칭을 줄 수 없습니다.

JPA표준에서는 페치 조인 대상에 별칭을 주는 것을 지원하지 않으나, 하이버네이트를 포함한 몇몇 구현체들은 별칭을 지원합니다.

 

그러나 별칭을 사용하면 자칫 연관된 데이터 수가 달라져서 데이터 무결성이 깨질 수 있으므로 주의하여야 합니다.

 

특히 2차 캐시와 함께 사용할 때 조심해야 합니다.

연관된 데이터 수가 달라진 상태에서 2차 캐시에 저장된다면 다른 곳에서 조회할 때도 연관된 데이터의 수가 달라지는 문제가 발생할 수 있습니다.

 

 

 

 

 

 

 

둘 이상의 컬렉션을 페치할 수 없습니다

 

구현체에 따라 되기도 하지만, 컬렉션 * 컬렉션의 카테시안 곱이 만들어지므로 주의해야 합니다.

하이버네이트 사용 시에는 오류가 발생합니다.

 

사용하지 않는 것을 권장합니다.

 

 

 

 

 

 

컬렉션을 페치 조인하면 페이징 API (setFirstResult, setMaxResult)를 사용할 수 없습니다.

 

컬렉션이 아닌 단일 값 연관 필드를 페치 조인하면 사용할 수 있으나, 컬렉션을 페치 조인한 경우에는 사용할 수 없습니다.

 

하이버네이트의 경우에는 해주긴 하지만, 경고 로그를 남기고 메모리에서 페이징 처리를 하는데, 이는 데이터가 많을 경우 성능 이슈와 메모리 초과 예외가 발생할 수 있기에 매우 위험합니다.

 

 

 

 

 

 

 

 

 

 

 

페치 조인 시 왜 별칭을 줄 수 없게 만든 이유

 

페치조인은 한 엔티티와 연관된 다른 엔티티를 모두 조회하겠다는 의미로 사용됩니다.

 

그러나 패치 조인에 별칭을 사용하여 특정 조건에 부합하는 결과만 가져고오 싶을 수 있습니다.

그러나 페치조인은 절대 그렇게 사용해서는 안됩니다.

 

필터링이 필요하다면, 페치 조인이 아니라 따로 따로 엔티티를 조회해야 합니다.

 

그 이유는 데이터 무결성 때문입니다.

조금 쉽게 이해하기 위해 예시를 들어 설명하겠습니다.

 

 

팀A가 있고, 팀A에는 회원이 5명 있습니다.

회원1은 나이가 10살 입니다.
회원2은 나이가 20살 입니다.
회원3은 나이가 30살 입니다.
회원4은 나이가 40살 입니다.
회원5은 나이가 50살 입니다.


저는 팀을 조회하면서, 연관된 회원을 같이 조회하고 싶습니다.
그런데 연관된 회원들 중 회원의 나이가 20살 이하인 회원만 조회하고 싶습니다.

그래서 다음과 같은 쿼리를 작성하였습니다.
"select t from Team t join fetch t.members m where m.age <= 20"


해당 결과의 teamA.getMembers()의 size는 2입니다.
이는 teamA의 Members에 회원1과 회원2만 들어있기 때문입니다.


여기서 문제가 발생합니다.
데이터베이스에는 TeamA와 연관된 회원이 5명입니다.
그러나 영속성 컨텍스트에는 TeamA와 연관된 회원이 2명밖에 없는 것입니다.

데이터베이스와 객체의 데이터 개수가 달라져서
데이터의 무결성이 깨져버리는 결과를 초래하기에, 이를 방지하고자 페치조인에는 별칭을 줄 수 없게 만든 것입니다.

 

 

참고로 별칭을 준 대상을 where 절에서 사용하면 예외를 발생시키지는 않으나, on 절에서 사용 시 예외를 발생시킵니다.

on 절에서 사용 시 예외 발생

 

 

 

 

 

따라서 가급적 페치 조인의 대상에는 별칭을 사용하지 않도록 하고,

별칭을 준다고 하더라도 절대로 where, on 절의 필터링 대상으로는 사용하지 않아야 합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

별칭을 사용하는 경우

"select t from Team t join fetch t.members m join fetch m.xxx" 

 

위처럼 페치 조인을 여러 단계로 하는 경우에는 사용해도 괜찮습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

정리

• 모든 최적화 문제를 페치 조인으로 해결할 수는 없습니다.
• 여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야 하면, 페치조인 보다는 일반 조인을 사용하고, 필요한 데이터들만 조회해서 DTO로 반환하는 것이 효과적입니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

Reference

자바 ORM 표준 JPA 프로그래밍 - 기본편 - 인프런 | 강의

[자바 ORM 표준 JPA 프로그래밍 - 김영한]

 

fetch join 시 별칭관련 질문입니다 - 인프런 | 질문 & 답변

 

fetch join 관련 질문 드립니다!! - 인프런 | 질문 & 답변