course/inflearn

[JPA 프로그래밍 기본편] JPQL - 중급 문법

hjkim0502 2022. 11. 10. 22:20

경로 표현식

  • .(점)을 찍어 객체 그래프 탐색
    • 상태 필드: 단순히 값을 저장하기 위한 필드 
      • 예: m.username
    • 연관 필드: 연관관계를 위한 필드
      • 단일 값 연관 필드: 대상이 엔티티, @ManyToOne, @OneToOne
        • 예: m.team
      • 컬렉션 값 연관 필드: 대상이 컬렉션, @OneToMany, @ManyToMany
        • 예: m.orders
  • 특징
    • 상태 필드: 경로 탐색의 끝, 더 이상 탐색 불가
      • 예: select m.username, m.age from Member m
    • 단일 값 연관 경로: 묵시적 내부 조인 발생, 더 탐색 가능
      • 예: select o.member from Order o
      • 탐색 시 자바로는 .(점)만 찍으면 되기 때문에 편하지만 db에서는 조인이 일어나므로 사용 지양
    • 컬렉션 값 연관 경로: 묵시정 내부 조인 발생, 더 이상 탐색 불가
      • 예:  select t.members from Team t
      • FROM 절에서 명시적 조인을 통해 별칭을 얻으면 별칭을 통해 탐색 가능
        • 예: select m.username from Team t join t.members m
    • 묵시적 조인 대신 명시적 조인 권장
      • 묵시적 조인은 내부 조인만 가능 -> 외부 조인은 명시적 조인 사용
      • 경로 탐색은 주로 select, where 절에서 사용하지만 묵시적 조인으로 인해 SQL의 from (join) 절에 영향을 줌
      • 조인은 SQL 튜닝에 중요한 포인트이기 때문에, 조인이 일어나는 상황을 파악하기 어려운 묵시적 조인 사용 지양

페치 조인(매우 중요!!)

  • SQL 조인 종류가 아님
  • JPQL에서 성능 최적화를 위해 제공하는 기능
  • 연관된 엔티티나 컬렉션을 SQL 한 번에 함께 조회하는 기능
  • join fetch 명령어 사용
  • N + 1 문제 해결
    • 페치 조인 사용하지 않으면 지연로딩이든 즉시로딩이든 N + 1 문제 발생하는 경우가 있음

 

  • 엔티티 페치 조인
    • 회원을 조회하면서 연관된 팀도 SQL 한번에 다같이 조회
    • jpql에서는 m(멤버)만 select했지만 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"
// select 쿼리 3번
// 회원1,2,3 조회
// 팀A 조회
// 팀B 조회

String jpql = "select m from Member m join fetch m.team"
// select 쿼리 1번
// 회원, 팀 모두 조회

List<Member> members = em.createQuery(jpql, Member.class)
     				   .getResultList();		
for (Member member : members) {
    //페치 조인으로 회원과 팀을 함께 조회해서 지연 로딩X
    System.out.println("username = " + member.getUsername() + ", " +
    					"teamName = " + member.getTeam().name());
}

 

  • 컬렉션 페치 조인
    • 일대다 관계
// JPQL
select t 
from Team t join fetch t.members 
where t.name = '팀A'

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);
    }
}
SQL
SELECT T.*, M.* FROM TEAM T
INNER JOIN MEMBER M ON T.ID = M.TEAM_ID
WHERE T.NAME = '팀A'

  • 팀A에 회원이 두명이기 때문에 결과 조인 테이블에 위와 같이 저장되고, 중복된 결과 출력(뻥튀기)
  • select t from Team t 로 날리면 결과 1개

 

  • DISTINCT
    • SQL의 DISTINCT는 중복된 결과를 제거하는 명령
      • 위 테이블에서는 ID와 NAME이 서로 다름 -> 중복 제거 안됨
    • JPQL의 DISTINCT는 2가지 기능 제공
      • 1. SQL에 DISTINCT 추가
      • 2. 애플리케이션에서 엔티티 중복 제거

  • 페치 조인 vs 일반 조인
    • 일반 조인 실행 시 연관된 엔티티를 함께 조회하지 않음
      • JPQL은 결과 반환할 때 SELECT 절에 지정한 엔티티만 조회하고, 연관관계 고려하지 않음
    • 페치 조인을 사용할 때만 연관된 엔티티도 함께 조회(즉시로딩과 같은 효과)
      • 객체 그래프를 SQL 한번에 조회하는 개념
// jpql
// 일반 조인
select t
from Team t join t.members m
where t.name = ‘팀A'
SQL
SELECT T.*
FROM TEAM T
INNER JOIN MEMBER M ON T.ID=M.TEAM_ID
WHERE T.NAME = '팀A'
  • 팀만 조회, 회원은 조회 X

 

  • 특징과 한계
    • 엔티티에 직접 적용하는 글로벌 로딩 전략보다 우선함 
    • 페치 조인 대상에는 별칭을 줄 수 없다
      • hibernate는 가능하지만, 사용 지양
      • 애초에 jpql과 페치 조인은 연관된 것을 다 가져오게끔 설계된 것이기 때문에 별칭을 활용해 조건을 달아서 일부만 가져오는 것은 위험
        • -> 객체 그래프  사상에 맞지 않고, 영속성 컨텍스트 입장에서도 꼬일 수 있음(데이터 정합성)
      • 연관된 것 중 일부만 필요한 경우는 처음부터 그 객체들만 조회하는 쿼리를 따로 작성
    • 둘 이상의 컬렉션은 페치 조인할 수 없다 (-> 컬렉션은 하나만 지정할 수 있다)
    • 컬렉션을 페치 조인하면 페이징 API(setFirstResult, setMaxResults)를 사용할 수 없다.
      • db 중심적으로 row를 기준으로 자르는 것이기 때문에 필요한 데이터가 제외될 수 있다
      • hibernate는 경고 로그를 남기고 데이터를 다 불러온 후 메모리에서 페이징(매우 위험)
      • 해결방안
        • 1. team에서 members를 불러와 페치 조인하지 않고 member에서 team을 불러와 페치 조인 후 페이징
        • 2. 페치 조인 없이 Team 객체의 members 필드에 @BatchSize 어노테이션 활용
          • BatchSize 값이 100이면 한번에 100개의 쿼리를 날림
// 사용 불가
select t from Team t join fetch t.members

// 해결 방안 1
select m from Member m join fetch m.team t

// 해결 방안 2
// Team 객체의 members 필드에 @BatchSize 붙이거나
// 글로벌 설정(persistence.xml)
// -> <property name="hibernate.jdbc.default_batch_fetch_size" value="100" />
select t from Team t

 

  • 정리
    • 상황에 맞게 적절히 사용할 것
      • 페치 조인은 객체 그래프를 유지할 때 사용하면 효과적
      • 여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야하면 다른 방식 고려 
    • 1. 페치 조인을 활용해 필요한 데이터 조회한 후 반환
    • 2. 페치 조인 활용하고 애플리케이션에서 DTO를 사용해 필요한 데이터 반환
    • 3. 일반 조인 활용하고 new로 조회하여 DTO로 스위칭 후 반환

 

다형성 쿼리

  • TYPE: 조회 대상을 특정 자식으로 한정
    • 예) Item 중 Book, Movie 조회
    • select i from Item i where type(i) in (Book, Movie)
  • TREAT(JPA 2.1): 상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용
    • 자바의 타입 캐스팅과 유사
    • FROM, WHERE, SELECT(hibernate 지원) 절에서 사용 
    • 예) 부모인 Item과 자식 Book이 있다
    • select i from Item i where treat(i as Book).author = 'kim'

 

엔티티 직접 사용

  • 기본 키 값
    • JPQL에서 엔티티를 직접 사용하면 SQL에서 해당 엔티티의 기본 키 값을 사용
//jpql
select count(m.id) from Member m //엔티티의 아이디를 사용
select count(m) from Member m //엔티티를 직접 사용

//sql
select count(m.id) as cnt from Member m


// jpql
select m from Member m where m = :member
select m from Member m where m.id = :memberId”;

// sql
select m.* from Member m where m.id=?
  • 외래 키 값
    • Member의 Team에 대한 외래키 이름이 team_id이고, sql에서는 이 외래키 값을 사용
//jpql
select m from Member m where m.team = :team
select m from Member m where m.team.id = :teamId

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

 

Named 쿼리

  • 미리 정의해서 이름을 부여해두고 사용하는 JPQL
  • 정적 쿼리만 가능
  • 애플리케이션 로딩 시점에 초기화 후 재사용(캐싱)
  • 애플리케이션 로딩 시점에 쿼리 검증

 

  • 어노테이션
// Member class
@Entity
@NamedQuery(
        name = "Member.findByUsername",
        query="select m from Member m where m.username = :username")
public class Member {
    ...
}


// JpaMain class
List<Member> resultList =
    em.createNamedQuery("Member.findByUsername", Member.class)
            .setParameter("username", "회원1")
            .getResultList();
  • XML에 정의
[META-INF/persistence.xml]
<persistence-unit name="jpabook" >
	<mapping-file>META-INF/ormMember.xml</mapping-file>


[META-INF/ormMember.xml]
<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://xmlns.jcp.org/xml/ns/persistence/orm" version="2.1">
	<named-query name="Member.findByUsername">
		<query><![CDATA[
			select m
			from Member m
			where m.username = :username
		]]></query>
	</named-query>
	<named-query name="Member.count">
		<query>select count(m) from Member m</query>
	</named-query>
</entity-mappings>
  • XML이 항상 우선권을 가짐
  • 애플리케이션 운영 환경에 따라 다른 XML을 배포할 수 있음
  • 참고: Spring data JPA의 @Query

 

벌크 연산: 쿼리 한번으로 여러 데이터를 변경

  • 상황: 재고가 10개 미만인 모든 상품의 가격을 10% 올리고자 함
  • JPA 변경 감지 기능으로 실행하려면 너무 많은 SQL 실행
    • 1. 재고가 10개 미만인 상품을 리스트로 조회
    • 2. 상품 엔티티의 가격을 10% 증가
    • 3. 트랜잭션 커밋 시점에 변경 감지 동작
    • 위 과정을 변경되어야하는 데이터마다 반복하면서 UPDATE SQL 실행
  • 사용: executeUpdate()
// 영향받은 엔티티의 수 반환
int resultCount = em.createQuery("update Member m set m.age = 20", int)
					.executeUpdate();
  • UPDATE, DELETE, INSERT(insert into ... select, hibernate 지원) 절에서 사용 가능
  • 주의: 벌크 연산은 영속성 컨텍스트를 무시하고 DB에 직접 쿼리
    • 방안 1: 영속성 컨텍스트가 무엇도 관리하지 않는 경우 벌크 연산부터 실행
    • 방안 2: 영속성 컨텍스트가 무엇을 관리하는 경우 벌크 연산 수행 후 영속성 컨텍스트 초기화
  • 참고: Spring data JPA의 @Modifying
// 영속성 컨텍스트가 관리하는 엔티티가 있는 경우
Member member1 = new Member();
member1.setUsername("A");
member1.setAge(10);
em.persist(member1)

Member member2 = new Member();
member2.setUsername("B");
member2.setAge(10);
em.persist(member2)

int resultCount = em.createQuery("update Member m set m.age = 20", int) // flush 됨
        .executeUpdate();
        
// 1. 벌크 연산 이후 초기화 하지 않는 경우    
member1.getAge() // -> 20이 아닌 10이 반환됨

Member findMember = em.find(Member.class, member1.getId())
findMember.getAge() // -> 20이 아닌 10이 반환됨

// 2. 벌크 연산 이후 초기화 했지만, member 객체에서 불러오는 경우  
em.clear();
        
member1.getAge() // -> 20이 아닌 10이 반환됨

// 3. 벌크 연산 이후 초기화하고, 다시 DB에서 조회하는 경우       
em.clear();
        
Member findMember = em.find(Member.class, member1.getId())
findMember.getAge() // -> 20이 반환됨
  • flush 될 때, DB에 먼저 회원의 나이가 10으로 동기화되고, 이후 DB에만 20으로 수정되기 때문에 영속성 컨텍스트를 초기화하지 않고 조회하면 영속성 컨텍스트에서 불러오기 때문에 10으로 조회된다

 

저작자표시 비영리 동일조건