JPA - JPQL 기본 문법 2

Spring/JPA

JPA - JPQL 기본 문법 2

jddng 2022. 3. 11. 17:56

728x90

기본 문법 2

경로 표현식
- 용어
- 특징
- 탐색
- 명시적 조인과 묵시적 조인
페치 조인(fetch join)
- 엔티티 페치 조인
- 컬렉션 페치 조인
- 페치 조인과 일반 조인의 차이
- 페치 조인의 한계
다형성 쿼리
쿼리에 엔티티 직접 사용
벌크 연산

경로 표현식

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

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

경로 표현식 용어

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

경로 표현식 특징

상태 필드 : 경로 탐색의 끝, 탐색X
단일 값 연관 경로 : 묵시적 내부 조인(inner join) 발생, 탐색 O
컬렉션 값 연관 경로 : 묵시적 내부 조인 발생(inner join) 발생, 탐색 X
FROM 절에서 명시적 조인을 통해 별칭을 얻으면 별칭을 통해 탐색 가능!

-- 명시적 조인을 이용하여 탐색이 가능
select m.username form Team t join t.members m;

탐색을 위해서는 묵시적 조인을 쓰지말고
명시적 조인을 써야한다

경로 탐색

상태 필드 경로 탐색

--JPQL
select m.username, m.age from Member m 

--SQL
select m.username, m.age from Member m

단일 값 연관 경로 탐색(묵시적 조인으로 인해 성능이 저하된다. N + 1 문제)

--JPQL
select o.member from Order o 

--SQL
select 
    m.* 
from 
    Orders o inner join Member m 
    on o.member_id = m.id

명시적 조인, 묵시적 조인

명시적 조인 : join 키워드 직접 사용
- select m from Member m join m.team t
묵시적 조인 : 경로 표현식에 의해 묵시적으로 SQL 조인 발생(내부 조인만 가능)
항상 내부 조인이 일어난다.
- select m.team from Member m
가급적 묵시적 조인 대신에 명시적 조인을 사용해야 한다
조인은 SQL 튜닝에 중요 포인트, 묵시적 조인은 N + 1 문제를 야기

페치 조인(fetch join)

SQL 조인 종류가 아니다.
JPQL에서 성능 최적화를 위해 제공하는 기능(N + 1 문제 해결)
연관된 엔티티나 컬렉션을 SQL 한 번에 함께 조회하는 기능이다.
엔티티에 직접 적용하는 글로벌 로딩 전략보다 우선함
- 예시 : @OneToMany(fetch = FetchType.LAZY)가 무시된다
join fetch 명령어 사용
페치 조인 ::= [LEFT [OUTER] | INNER]] JOIN FETCH
최적화가 필요한 곳은 페치 조인 적용

엔티티 페치 조인

주 엔티티를 조회하면서 참조하는 엔티티도 함께 조회(SQL 한 번에)
페치 조인을 이용하면 SQL을 보면 주 엔티티뿐만 아니라 참조 엔티티도 함께 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

// 페치 조인 사용 예시 코드
String jpql = "select m from Member m join fetch m.team"; 
List<Member> members = em.createQuery(jpql, Member.class) 
		.getResultList(); 
for (Member member : members) {
    //페치 조인으로 회원과 팀을 함께 조회해서 지연 로딩되지 않는다
    System.out.println("username = " + member.getUsername() + ", " + 
                    "teamName = " + member.getTeam().name()); 		
}

컬렉션 페치 조인

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

--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'

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); 
    } 
}


/* 결과
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를 사용한다.

SQL의 DISTINCT는 중복된 결과를 제거하는 명령어
JPQL의 DISTINCT는 2가지 기능을 제공(DISTINCT는 모든 속성이 같아야 하므로)
- SQL의 DISTINCT 기능
- 애플리케이션에서 엔티티 중복 제거 기능

SQL의 DISTINCT 기능으로는 중복된 결과를 제거할 수 없다.(데이터가 다르므로)

때문에 JPQL에서는 추가 기능을 제공하는데 같은 식별자를 가진 엔티티를 제거해준다.

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

일반 조인 실행시 연관된 엔티티를 함께 조회하지 않는다
- 따라서 연관된 엔티티를 조회할 때마다 쿼리가 실행
- 단지 SELECT 절에 지정한 엔티티만 조회할 뿐이다.
페치 조인 실행시 연관된 엔티티도 함꼐 조회해 온다(즉시 로딩
- 따라서 쿼리는 1번만 실행
- 페치 조인은 객체 그래프를 SQL 한번에 조회하는 개념

페치 조인의 한계

페치 조인 대상에는 별칭을 줄 수 없다.
- 정합성 이슈 때문에 사용 X
둘 이상의 컬렉션은 페치 조인 할 수 없다.
컬렉션을 페치 조인하면 페이징 API(setFirstResult, setMaxResults)를 사용할 수 없다.
(일대일, 다대일 같은 단일 값 연관 필드들은 페치 조인해도 페이징 가능)

다형성 쿼리

type

조회 대상을 특정 자식으로 한정
예) Item 중에 Book, Movie를 조회해라

-- JPQL
select i from Item i
where type(i) IN (Book, Movie) 

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

treat(부모 as 자식)

자바의 타입 캐스팅과 유사
상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용

-- JPQL
select i from Item i
where treat(i as Book).auther = 'kim'

-- SQL
select i.* from Item i
where i.DTYPE = 'B' and i.auther = 'kim'

쿼리에 엔티티 직접 사용

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

예시1) 기본 키

-- JPQL
select count(m.id) from Member m //엔티티의 아이디를 사용
select count(m) from Member m //엔티티를 직접 사용 

-- SQL (JPQL 둘다 같은 SQL 실행)
select count(m.id) as cnt from Member m

예시2) 기본 키

// 엔티티를 파라미터로 전달
String jpql = "select m from Member m where m = :member"; 
List resultList = em.createQuery(jpql) 
        .setParameter("member", member) 
        .getResultList(); 
        
// 식별자를 직접 전달
String jpql = "select m from Member m where m.id = :memberId"; 
List resultList = em.createQuery(jpql) 
        .setParameter("memberId", memberId) 
        .getResultList();

-- 실행된 SQL
select m.* from Member m where m.id=?

예시3) 외래 키

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(); 
        
// 식별자를 직접 전달    
String qlString = "select m from Member m where m.team.id = :teamId"; 
List resultList = em.createQuery(qlString) 
 .setParameter("teamId", teamId) 
 .getResultList();

-- 실행된 SQL
select m.* from Member m where m.team_id=?

벌크 연산

executeUpdate()

쿼리 한 번으로 여러 테이블 인스턴스 값 변경(엔티티)
반환 값은 영향받은 엔티티 수
UPDATE, DELETE 지원
INSERT(하이버네이트에서 지원)

예시)

String qlString = "update Product p " +
                    "set p.price = p.price * 1.1 " + 
                    "where p.stockAmount < :stockAmount";
                    
int resultCount = em.createQuery(qlString) 
                    .setParameter("stockAmount", 10) 
                    .executeUpdate();

벌크 연산 주의 사항

벌크 연산은 영속성 컨텍스트를 무시하고 데이터베이스에 직접 쿼리를 전달한다. 때문에 DB에는 변경된 값들이 저장이 되지만 영속성 컨텍스트에는 변경된 값들이 저장이 안되는데 이러한 문제 때문에 벌크 연산을 수행 한 후 컨텍스트 초기화 해주어야 한다.

728x90

저작자표시 비영리 변경금지 (새창열림)