[JPA] JPQL과 페치 조인

JPQL (Java Persistence Query Language)

JPQL란?

테이블이 아닌 객체를 검색하는 객체지향 쿼리

--SQL: 테이블 대상
SELECT * FROM MEMBER WHERE USERNAME = 'kim';

--JPQL: 엔티티 객체 대상
SELECT m FROM Member m WHERE m.username = 'kim';

• SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않음
• 엔티티와 속성은 대소문자를 구분함 (Member, username)
• JPQL 키워드는 대소문자를 구분하지 않음 (SELECT, FROM, WHERE)
• 엔티티 이름을 사용 (테이블 이름이 아님)
• 별칭(alias)은 필수 (member m)

단점

동적 쿼리를 만들기 어렵다.

// 동적 쿼리 만들기 어려움
String jpql = "select m from Member m where";
if (username != null) {
    jpql += " m.username = :username";
}
if (age != null) {
    jpql += " and m.age = :age";
}

---

객체지향 쿼리 언어 종류

JPQL

String jpql = "select m from Member m where m.username = :username";
List<Member> result = em.createQuery(jpql, Member.class)
    .setParameter("username", "kim")
    .getResultList();

Criteria

자바 코드로 JPQL을 작성할 수 있지만 복잡하고 실용성이 없음

QueryDSL - 오픈소스 라이브러리

자바 코드로 JPQL을 작성, 동적 쿼리 작성이 편리

// QueryDSL 사용 (간결하고 직관적!)
JPAQueryFactory queryFactory = new JPAQueryFactory(em);
QMember m = QMember.member;

List<Member> result = queryFactory
    .selectFrom(m)
    .where(m.username.eq("kim"))
    .fetch();

• 문자가 아닌 자바 코드로 작성해 컴파일 시점에 문법 오류 발견
• 동적 쿼리 작성이 편리
• 단순하고 쉬워 실무에서 가장 많이 사용
• JPQL을 알면 쉽게 사용 가능

JDBC

JDBC 커넥션 직접 사용 또는 Spring JdbcTemplate, MyBatis 등과 함께 사용 가능

em.flush();  // 플러시로 DB 동기화
// 네이티브 SQL 실행

• 영속성 컨텍스트를 적절한 시점에 수동으로 플러시(flush) 필요

---

경로 표현식

. 을 찍어 그래프를 탐색

상태 필드 (State Field)

• 값을 저장하기 위한 필드
• 경로 탐색의 끝 더이상 탐색 불가

연관 필드 (Association Field)

• 연관관계를 위한 필드

단일 값 연관 필드

select m.team from Member m
// m.team은 단일 값 연관 필드
// 묵시적 조인 발생: SELECT * FROM MEMBER M INNER JOIN TEAM T ...

select m.team.name from Member m  // 계속 탐색 가능!

• @ManyToOne, OneToOne
• 대상이 엔티티
• 묵시적 내부 조인 발생
• 탐색 O

컬렉션 값 연관 필드

select t.members from Team t
// t.members는 컬렉션 값 연관 필드
// 묵시적 조인 발생

select t.members.username from Team t  // 오류 컬렉션에서 탐색 불가

컬렉션에서 탐색하려면 명시적 조인 사용

select m.username from Team t
join t.members m  // 명시적 조인으로 별칭 부여

• @OneToMany , @ManyToMany
• 대상이 컬렉션
• 묵시적 내부 조인 발생
• 탐색 X (더 이상 탐색 불가)

---

명시적 조인 VS 묵시적 조인

명시적 조인

JOIN 키워드를 직접 사용

select m from Member m join m.team t

묵시적 조인

경로 표현식에 의해 묵시적으로 SQL 조인 발생(내부 조인만 가능)

select m.team from Member m  // team 접근 시 자동으로 조인 발생실무에서 묵시적 조인은 가급적 사용하지 말자 명시적 조인만 사용하자

실무 권장사항

묵시적 조인은 가급적 사용하지 말고, 명시적 조인만 사용하자

• 묵시적 조인은 조인이 일어나는 상황을 한눈에 파악하기 어려움
• 성능 튜닝이 어려움
• 명시적 조인을 사용하면 쿼리를 예측하기 쉬움

---

페치 조인 (Fetch Join)

JPQL에서 성능 최적화를 위해 제공하는 기능

연관된 엔티티나 컬렉션을 SQL 한번에 조회하는 기능

// 일반 조인
select m from Member m join m.team t

// 페치 조인
select m from Member m join fetch m.team

엔티티 페치 조인

회원을 조회하면서 연관된 팀도 함께 조회(SQL 한 번에)

String jpql = "select m from Member m join fetch m.team";
List<Member> members = em.createQuery(jpql, Member.class)
    .getResultList();

for (Member member : members) {
    // 페치 조인으로 회원과 팀을 함께 조회해서 지연 로딩 X
    System.out.println("username = " + member.getUsername() 
        + ", teamname = " + member.getTeam().getName());
}

SELECT M.*, T.* 
FROM MEMBER M
INNER JOIN TEAM T ON M.TEAM_ID = T.ID

• 페치 조인으로 Member와 Team을 함께 조회
• 지연 로딩 설정이 있어도 페치 조인이 우선 (LAZY 무시)
• 실제 엔티티를 조회(프록시 아님)

---

컬렉션 패치 조인

일대다 관계에서 컬렉션 페치 조인

String jpql = "select t from Team t join fetch t.members";
List<Team> teams = em.createQuery(jpql, Team.class)
    .getResultList();

for (Team team : teams) {
    System.out.println("team = " + team.getName() 
        + " | members = " + team.getMembers().size());
    
    for (Member member : team.getMembers()) {
        System.out.println("-> member = " + member);
    }
}

• 일대다 조인은 결과가 증가할 수 있다.

---

페치 조인과 DISTINT

JPQL의 DISTINCT는 2가지 기능 제공

• SQL에 DISTINCT 추가
• 애플레케이션에서 엔티티 중복제거

String jpql = "select distinct t from Team t join fetch t.members";
List<Team> teams = em.createQuery(jpql, Team.class)
    .getResultList();

SELECT DISTINCT T.*, M.* 
FROM TEAM T
INNER JOIN MEMBER M ON T.ID = M.TEAM_ID

• SQL의 DISTINCT는 데이터가 완전히 같아야 중복 제거
• JPQL의 DISTINCT는 SQL + 애플리케이션에서 같은 식별자를 가진 엔티티 중복 제거

---

페치조인과 일반조인의 차이

일반조인

select t from Team t join t.members m

• 일반 조인 실행 시 연관된 엔티티를 함께 조회하지 않음
• SELECT 절에 지정한 엔티티만 조회

SELECT T.* FROM TEAM T
INNER JOIN MEMBER M ON T.ID = M.TEAM_ID

• Team만 조회, Member는 조회안됨 (지연 로딩)

페치 조인

select t from Team t join fetch t.members

• 연관된 엔티티를 함께 조회(즉시로딩)
• 페치조인은 객체 그래프를 SQL 한번에 조회하는 개념

SELECT T.*, M.* FROM TEAM T
INNER JOIN MEMBER M ON T.ID = M.TEAM_ID

→ Team과 Member 모두 조회

페치조인의 한계

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

--안됨
select t from Team t join fetch t.members m where m.age > 10

--이렇게 해야 함
select m from Member m where m.age > 10 and m.team = :team

둘 이상의 컬렉션은 페치 조인할 수 없다

--안됨
select t from Team t 
join fetch t.members 
join fetch t.orders

• 데이터 정합성 문제 발생 가능
• 카테시안 곱으로 데이터 폭발

컬렉션을 패치조인하면 페이징 API를 사용할 수 없다

--경고 발생 (메모리에서 페이징)
String jpql = "select t from Team t join fetch t.members";
List<Team> result = em.createQuery(jpql, Team.class)
    .setFirstResult(0)
    .setMaxResults(10)
    .getResultList();

• 일대다 페치 조인에서 페이징하면 메모리에서 페이징 처리
• 데이터가 많으면 메모리 초과 위험

해결방법 →

• BatchSize 사용
• 다대일로 방향 전환

--단일 값 연관 필드는 페이징 가능 (1:1, N:1)
String jpql = "select m from Member m join fetch m.team";
List<Member> result = em.createQuery(jpql, Member.class)
    .setFirstResult(0)
    .setMaxResults(10)
    .getResultList();

페치 조인 사용 전략

페치 조인 사용처

• 객체 그래프를 유지할 때 효과적
• 최적화가 필요한 곳에 적용

일반 조인 사용처

• 여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야 할 때
• 필요한 데이터만 조회해서 DTO로 반환하는 것이 효과적

--DTO로 직접 조회
select new com.example.MemberTeamDto(m.username, t.name)
from Member m join m.team t

---

Named 쿼리 - 정적쿼리

미리 정의해서 이름을 부여해두고 사용하는 JPQL

@Entity
@NamedQuery(
    name = "Member.findByUsername",
    query = "select m from Member m where m.username = :username"
)
public class Member {
    ...
}

// 사용
List<Member> result = em.createNamedQuery("Member.findByUsername", Member.class)
    .setParameter("username", "kim")
    .getResultList();

• 정적 쿼리만 가능
• 애플리케이션 로딩 시점에 초기화 후 재사용 (성능 이점)
• 애플리케이션 로딩 시점에 쿼리 검증 (오류를 미리 잡음)
• 어노테이션 또는 XML에 정의 가능

장점→

• 로딩 시점에 JPQL 문법을 체크하고 파싱해둠
• 오류를 빨리 확인 가능
• 미리 파싱해두므로 성능 이점

---

벌크 연산

쿼리 한 번으로 여러 테이블 로우를 변경하는 연산

// 변경 감지(Dirty Checking)로 하면?
List<Member> members = em.createQuery("select m from Member m")
    .getResultList();

for (Member member : members) {
    member.setAge(member.getAge() + 1);  // 각각 UPDATE 쿼리
}
// 100명이면 100번의 UPDATE 쿼리 실행

UPDATE 벌크 연산

String qlString = "update Member m set m.age = m.age + 1";
int resultCount = em.createQuery(qlString)
    .executeUpdate();

System.out.println("resultCount = " + resultCount);
// 한 번의 쿼리로 모든 Member의 age 증가!

DELETE 벌크 연산

String qlString = "delete from Member m where m.age < 18";
int resultCount = em.createQuery(qlString)
    .executeUpdate();

벌크 연산 주의 사항

영속성 컨텍스트를 무시하고 DB에 직접 쿼리

Member member = new Member();
member.setUsername("kim");
member.setAge(20);
em.persist(member);

// 벌크 연산 실행
em.createQuery("update Member m set m.age = 30")
    .executeUpdate();

System.out.println(member.getAge());  // 20 (영속성 컨텍스트 값)
// DB에는 30, 영속성 컨텍스트에는 20 → 불일치

해결 방법

벌크연산을 먼저 실행

// 벌크 연산 먼저
em.createQuery("update Member m set m.age = 30")
    .executeUpdate();

// 그 다음 조회
Member member = em.find(Member.class, 1L);
System.out.println(member.getAge());  // 30

벌크연산 수행 후(flush()) 영속성 컨텍스트 초기화(clear)

Member member = em.find(Member.class, 1L);

// 벌크 연산
em.createQuery("update Member m set m.age = 30")
    .executeUpdate();

em.clear();  // 영속성 컨텍스트 초기화

Member findMember = em.find(Member.class, 1L);  // DB에서 다시 조회
System.out.println(findMember.getAge());  // 30

Spring Data JPA @Modifying

@Modifying(clearAutomatically = true)  // 자동으로 clear
@Query("update Member m set m.age = :age where m.id = :id")
int bulkAgeUpdate(@Param("age") int age, @Param("id") Long id);