JPA(10)

7 minute read

JPQL 중급 문법

경로 표현식

.(점)을 찍어 객체 그래프를 탐색하는 것

select m.username -> 상태 필드
 from Member m 
 join m.team t -> 단일 값 연관 필드
 join m.orders o -> 컬렉션 값 연관 필드
where t.name = '팀A'

경로 표현식 용어 정리

상태 필드(state field): 단순히 값을 저장하기 위한 필드 (ex: m.username)
연관 필드(association field): 연관관계를 위한 필드
단일 값 연관 필드:
- @ManyToOne, @OneToOne, 대상이 엔티티(ex: m.team)
컬렉션 값 연관 필드:
- @OneToMany, @ManyToMany, 대상이 컬렉션(ex: m.orders)

경로 표현식 특징

상태 필드(state field): 경로 탐색의 끝, 탐색X
단일 값 연관 경로: 묵시적 내부 조인(inner join) 발생, 탐색O
컬렉션 값 연관 경로: 묵시적 내부 조인 발생, 탐색X
- FROM 절에서 명시적 조인을 통해 별칭을 얻으면 별칭을 통해 탐색 가능
- m.orders에 점을 찍어도 값이 나타나지 않음

-> 권장하는 방법은 묵시적 조인말고 쿼리에 조인관계를 나타낸 명시적 조인이 유지보수 측면에서 좋다.

명시적 조인, 묵시적 조인

명시적 조인: join 키워드 직접 사용
- select m from Member m join m.team t
묵시적 조인: 경로 표현식에 의해 묵시적으로 SQL 조인 발생 (내부 조인만 가능)
- select m.team from Member m

주의 사항

항상 내부 조인(명시적 조인 사용하기)
컬렉션은 경로 탐색의 끝, 명시적 조인을 통해 별칭을 얻어야함
경로 탐색은 주로 SELECT, WHERE 절에서 사용하지만 묵시적 조인으로 인해 SQL의 FROM (JOIN) 절에 영향을 줌

Fetch Join

성능 최적화 관점과 실무에서 매우 중요한 방법이다.

페치 조인

SQL 조인 종류X
JPQL에서 성능 최적화를 위해 제공하는 기능
연관된 엔티티나 컬렉션을 SQL 한 번에 함께 조회하는 기능
join fetch 명령어 사용
페치 조인 ::= [ LEFT [OUTER] INNER ] JOIN FETCH 조인경로
지연 로딩으로 설정했지만 즉시 로딩처럼 한번에 가져와야 할 일이 필요할 때 사용하면 유용하다.

엔티티 페치 조인

회원을 조회하면서 연관된 팀도 함께 조회(SQL 한 번에)
SQL을 보면 회원 뿐만 아니라 팀(T.*)도 함께 SELECT
[JPQL] select m from Member m join fetch m.team
[SQL] SELECT M., T. FROM MEMBER M INNER JOIN TEAM T ON M.TEAM_ID=T.ID

GitHub Logo

예시

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().name()); 
} 

결과값

username = 회원1, teamname = 팀A 
username = 회원2, teamname = 팀A 
username = 회원3, teamname = 팀B

컬렉션 페치 조인

일대다 관계
[JPQL] select t from Team t join fetch t.members where t.name = ‘팀A’
[SQL] SELECT T., M. FROM TEAM T INNER JOIN MEMBER M ON T.ID=M.TEAM_ID WHERE T.NAME = ‘팀A’

GitHub Logo

예시

String jpql = "select t from Team t join fetch t.members where t.name = '팀A'" 
List<Team> teams = em.createQuery(jpql, Team.class).getResultList(); 
for(Team team : teams) { 
    System.out.println("teamname = " + team.getName() + ", team = " + team); 
    for (Member member : team.getMembers()) { 
        //페치 조인으로 팀과 회원을 함께 조회해서 지연 로딩 발생 안함
        System.out.println(“-> username = " + member.getUsername()+ ", member = " + member"); 
    } 
}

페치 조인과 DISTINCT

SQL의 DISTINCT는 중복된 결과를 제거하는 명령
JPQL의 DISTINCT 2가지 기능 제공
- SQL에 DISTINCT를 추가
- 애플리케이션에서 엔티티 중복 제거

예시

String query1 = "select t from Team t join fetch t.members where t.name='teamA'";
List<Team> resultList = em.createQuery(query1, Team.class)
    .getResultList();
for (Team t: resultList) {
	System.out.println("t = " + t.getId() + ": " + t.getName());
	for (Member m: t.getMembers()) {
		System.out.println("    m = " + m.getName());
	}
}
// 각 team에 속한 member 수만큼 반복해서 결과 출력

GitHub Logo

-> 일대다 관계에서 페치 조인을 하면 조인으로 인해 팀A의 튜플수가 두개가 생긴다.

결과 : 팀A의 정보가 두 번 출력되게 된다.

teamname = 팀A, team = Team@0x100 
-> username = 회원1, member = Member@0x200 
-> username = 회원2, member = Member@0x300
teamname = 팀A, team = Team@0x100 
-> username = 회원1, member = Member@0x200 
-> username = 회원2, member = Member@0x300

distinct 사용시

String query2 = "select distinct t from Team t join fetch t.members where t.name='teamA'";
List<Team> resultList = em.createQuery(query2, Team.class)
    .getResultList();
for (Team t: resultList) {
	System.out.println("t = " + t.getId() + ": " + t.getName());
	for (Member m: t.getMembers()) {
		System.out.println("    m = " + m.getName());
	}
}

결과

teamname = 팀A, team = Team@0x100 
-> username = 회원1, member = Member@0x200 
-> username = 회원2, member = Member@0x300

DISTINCT가 추가로 애플리케이션에서 중복 제거 시도
같은 식별자를 가진 Team 엔티티 제거

GitHub Logo

페치 조인의 특징과 한계

페치 조인 대상에는 별칭을 줄 수 없다.
- 하이버네이트는 가능, 가급적 사용X
둘 이상의 컬렉션은 페치 조인 할 수 없다.
컬렉션을 페치 조인하면 페이징 API(setFirstResult, setMaxResults)를 사용할 수 없다.
- 일대일, 다대일 같은 단일 값 연관 필드들은 페치 조인해도 페이징 가능
- 하이버네이트는 경고 로그를 남기고 메모리에서 페이징(매우 위험)

컬렉션 페치 조인 해결 방법

String query  = "select t From Team t";
List<Team> result =  em.createQuery(query,Team.class)
    .setFirstResult(0)
    .setMaxResults(2)
    .getResultList();

for (Team team : result){
    for (Member member : team.getMembers()){
        System.out.println("-> member = "+ member);
    }
}

-> 팀별 마다 회원의 목록을 출력하는 코드이다. 일대다 컬렉션 이므로 fetch join을 사용할 수 없어서 팀마다 멤버 조회 쿼리가 발생하는 N+1문제가 발생한다.

해결방법

@BatchSize(size = 100)
@OntToMany(mappedBy="team")
private List<Member> members = new ArrayList<>(); // members는 지연 로딩으로 설정한 상태

팀이 2개 등록되어있다면 보내지는 쿼리

select T.*
From Member
where members_TEAM_ID in)
?,?
)

-> 배치 사이즈 설정으로 인해 한 번에 두팀에 연관된 멤버를 모두 가져온다. -> 지연 로딩상태에서 멤버를 가져오라는 요청이 들어올 때 한 번에 배치사이즈만큼 가져온다.(만약 팀이 150개면 100개를 가져온후 그 다음 요청때 50개)

페치 조인 정리

연관된 엔티티들을 SQL 한 번으로 조회 - 성능 최적화
엔티티에 직접 적용하는 글로벌 로딩 전략보다 우선함
- @OneToMany(fetch = FetchType.LAZY) //글로벌 로딩 전략
실무에서 글로벌 로딩 전략은 모두 지연 로딩
최적화가 필요한 곳은 페치 조인 적용
모든 것을 페치 조인으로 해결할 수 는 없음
페치 조인은 객체 그래프를 유지할 때 사용하면 효과적
여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야 하면, 페치 조인 보다는 일반 조인을 사용하고 필요한 데이터들만 조회해서 DTO로 반환하는 것이 효과적

다형성 쿼리

Type : 조회 대상을 특정 자식으로 한정할 때 사용한다.

아래 코드는 Item중에 Book과 Movie를 조회하는 예시 JPQL이다.

String query = "select i from Item i where type(i) IN (Book, Movie)";

위 코드는 아래의 sql코드와 같다

select i from i
where i.DTYPE in (‘B’, ‘M’)

Treat : 자바의 TypeCasting과 유사한 개념으로, 상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용

아래는 부모인 Item과 자식인 Book에 대한 예시이다.

String query = "select i from Item i where treat(i as Book).author = 'kim'";

위 코드는 아래의 sql코드와 같다

select i.* from Item i
where i.DTYPE = ‘B’ and i.auther = ‘kim’

JPQL - 엔티티 직접 사용

엔티티 직접 사용 - 기본 키 값

JPQL에서 엔티티를 직접 사용하면 SQL에서 해당 엔티티의 기본 키 값을 사용

예시1 - 엔티티를 파라미터로 전달

String jpql = “select m from Member m where m = :member”; 
List resultList = em.createQuery(jpql) 
 .setParameter("member", member) 
 .getResultList(); 

예시2 - 식별자를 직접 전달

String jpql = “select m from Member m where m.id = :memberId”; 
List resultList = em.createQuery(jpql) 
 .setParameter("memberId", memberId) 
 .getResultList();

-> 위 두가지 예시의 실행된 결과는 아래와 동일하다.

select m.* from Member m where m.id=?

엔티티 직접 사용 - 외래키 값

예시1 - 엔티티를 파라미터로 전달

Team team = em.find(Team.class, 1L); 
String qlString = “select m from Member m where m.team = :team”; 
List resultList = em.createQuery(qlString) 
 .setParameter("team", team) 
 .getResultList();

예시2 - 식별자를 직접 전달

String qlString = “select m from Member m where m.team.id = :teamId”; 
List resultList = em.createQuery(qlString) 
 .setParameter("teamId", teamId) 
 .getResultList();

-> 위 두가지 예시의 실행된 결과는 아래와 동일하다.

select m.* from Member m where m.team_id=?

Named 쿼리

미리 정의해서 이름을 부여해두고 사용하는 JPQL
정적 쿼리
어노테이션, XML에 정의
애플리케이션 로딩 시점에 초기화 후 재사용
애플리케이션 로딩 시점에 쿼리를 검증

Named 쿼리 등록 예시

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

Named 쿼리 사용 예시

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

벌크 연산

재고가 10개 미만인 모든 상품의 가격을 10% 상승하려면?
JPA 변경 감지 기능으로 실행하려면 너무 많은 SQL 실행
- 재고가 10개 미만인 상품을 리스트로 조회한다.
- 상품 엔티티의 가격을 10% 증가한다 하자
- 트랜잭션 커밋 시점에 변경감지가 동작한다. -> 변경된 데이터가 100건이라면 100번의 update sql이 실행된다.

벌크 연산 예제

쿼리 한 번으로 여러 테이블 로우 변경(엔티티)
executeUpdate()의 결과는 영향받은 엔티티 수 반환
UPDATE, DELETE 지원
INSERT(insert into .. select, 하이버네이트 지원)

String query = "update Member m " +
	"set m.age = age * 2 " +
	"where m.age > 0";
int resultCount = em.createQuery(query)
	.executeUpdate()

벌크 연산 주의

벌크 연산은 영속성 컨텍스트를 무시하고 데이터베이스에 직접 쿼리
- 벌크 연산을 먼저 실행
- 벌크 연산 수행 후 영속성 컨텍스트 초기화 : 초기화 하지 않으면 영속성 컨텍스트의 내용은 변경되지 않고 db내용만 변경되었으므로 변경되지 않은 데이터가 조회된다. 벌크 연산 후 em.clear()수행 하기
출처 : 김영한의 자바 ORM 표준 JPA 프로그래밍 - 기본편

Share on

Twitter Facebook LinkedIn

Lee ChangMin

JPA(10)

JPQL 중급 문법

경로 표현식

Fetch Join

엔티티 페치 조인

컬렉션 페치 조인

페치 조인과 DISTINCT

페치 조인의 특징과 한계

다형성 쿼리

JPQL - 엔티티 직접 사용

엔티티 직접 사용 - 기본 키 값

엔티티 직접 사용 - 외래키 값

Named 쿼리

벌크 연산

Share on

Leave a comment

You may also enjoy

Error getting access token for service account

개인정보처리방침

플러터(2)

플러터(1)