JPQL(Java Persistence Query Language) - 2

JPQL 경로 표현식

경로 표현식이란

"."을 통해 객체 그래프를 탐색하는 것

상태 필드(state field): 단순히 값을 저장하기 위한 필드


ex> u.username

연관 필드(association field): 연관관계를 위한 필드

• 단일 값 연관 필드에 대한 탐색
  
  단일 값 연관 필드란?
  @ManyToOne, @OneToOne, 대상이 엔티티
  ex> user 와 user의 team
  
  단일 값 연관 필드 조회 시에는 묵시적 내부 조인(inner join) 발생한다.
  ex> u.team.name
  또한 대상 엔티티의 속성에 대한 탐색이 가능하다.
  ex> u.team.name

List<Team> usersTeam = entityManager.createQuery("select u.team from User as u", Team.class).getResultList();
usersTeam.stream().forEach(t -> System.out.println(t.toString()));

List<String> usersTeamsName = entityManager.createQuery("select u.team.name from User as u").getResultList();
usersTeamsName.stream().forEach(teamname -> System.out.println(teamname));

• 컬렉션 값 연관 필드
  
  컬렉션 값 연관 필드란?
  @OneToMany, @ManyToMany, 대상이 컬렉션인 값
  ex> team 와 team의 users
  
  컬렉션 값인 연관 필드 조회 시에도 묵시적 내부 조인 발생한다.
  그러나, 반환 값이 컬렉션이기 때문에 값에 대한 추가  탐색이 불가능하다.
  
  컬렉션의 사이즈 정도 확인할 수 있다.

List<Integer> teamsUserCount = entityManager.createQuery("select t.users.size from Team as t").getResultList();
teamsUserCount.stream().forEach(teamSize -> System.out.println("teamSize = " + teamSize));

서브쿼리를 이용해 팀의 유저 수 가져오는 쿼리

컬렉션 값인 연관 필드 조회 시에는 FROM 절에서 명시적 조인을 통해 별칭을 얻어야 별칭을 통해 추가 탐색 가능하다.

List<String> teamsUserName = entityManager.createQuery("select u.name from Team as t inner join t.users as u").getResultList();
teamsUserName.stream().forEach(userName -> System.out.println("userName = " + userName));

경로 탐색을 사용한 묵시적 조인시 주의사항

• 항상 내부 조인이다.
• 컬렉션 경로 탐색의 경우 그 속성 값에 대한 추가 탐색이 되지 않는다. 명시적 조인을 통해 별칭을 얻어야함.
• 경로 탐색은 주로 SELECT, WHERE 절에서 사용하지만 묵시 적 조인으로 인해 SQL의 FROM (JOIN) 절에 영향을 준다.
• 묵시적 조인은 조인이 일어나는 상황을 한눈에 파악하기 어렵다.

조인은 SQL 튜닝에 중요 포인트이다.

그러므로 가급적 묵시적 조인 대신에 명시적 조인 사용할 것!

Fetch 조인

페치 조인(fetch join) 이란?

• SQL 조인 종류가 아닌 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

만약 지연로딩 (LAZY) 혹은 즉시로딩 (EAGER) 로 셋팅되어 있다면, 다음 코드를 실행할 경우 어떤 일이 발생할까?

String queryStr = "select u from User as u";
List<User> users = entityManager.createQuery(queryStr).getResultList();
users.stream().forEach(u -> System.out.println("userName = " + u.getName() + " usersTeamName = " + u.getTeam().getName()));

 u.getTeam().은 프록시 객체로 u.getTeam().getName()을 조회할 때마다 데이터베이스에 team을 조회하는 쿼리가 발생한다.

만약, 이전 유저에서 이미 검색한 팀이라면 영속성 컨택스트의 1차 캐시에서 가져옴. => N + 1

String queryStr = "select u from User as u join fetch u.team";
List<User> users = entityManager.createQuery(queryStr).getResultList();
users.stream().forEach(u -> System.out.println("userName = " + u.getName() + " usersTeamName = " + u.getTeam().getName()));

컬렉션 페치 조인

 

String queryStr2 = "select t from Team as t join fetch t.users";
List<Team> teams = entityManager.createQuery(queryStr2).getResultList();
teams.stream().forEach(t -> System.out.println("team name = " + t.getName() + " user size = " + t.getUsers().size()));

우리가 원한 팀 데이터는 가져왔지만, 중복이 발생

팀은 하나지만, 그의 유저 수는 2 이기 때문에..

같은 팀 객체는 같은 주소값을 가진다.

 

DB의 user / team table이 다음과 같을 때, 

user table

team table

실제, 페치 조인 결과 데이터가 중복되어 나오는 것을 확인할 수 있다.

select t from Team as t

select t from Team as t join fetch t.users

페치 조인과 DISTINCT

이와 같이 페치 조인 시 발생하는 중복된 데이터를 제거하고 싶다면?

• SQL의 DISTINCT는 중복된 결과를 제거
  하지만, 이 방법으로는 모든 중복 데이터를 제거할 수는 없음
  SQL에 DISTINCT는 데이터가 온전히 같을 때만 적용 됨
  하지만, 조회된 데이터가 다르므로 SQL 결과 에서 중복을 제거할 수 없다.
  

• JPQL의 DISTINCT가 제공하는 2가지 기능으로 완벽하게 중복을 제거할 수 있다.
  1. SQL에 DISTINCT를 추가하면
  2. JPA는 애플리케이션에서 같은 식별자를 가진 엔티티에 대한 중복을 제거한다.
  
  
  

select distinct t from Team as t join fetch t.users

[정리]

select t from Team as t

// team 만 단순 조회 (LAZY 일 경우) user data 는 proxy 객체

String selectQuery = "select t from Team as t";
teams = entityManager.createQuery(selectQuery).getResultList();
System.out.println("\"" + selectQuery + "\" result size = " + teams.size());

 

// user 데이터 조회 시, user에 대한 select query 팀 데이터 수 만큼 발생

teams.stream().forEach(t -> System.out.println("team name = " + t.getName() + ", team users = " + t.getUsers().toString())); 

 

select t from Team as t join t.users

 // team 만 조회 (LAZY 일 경우) user data 는 proxy 객체, user 수 만큼 team 데이터 중복

String joinQuery = "select t from Team as t join t.users";
teams = entityManager.createQuery(joinQuery).getResultList();
System.out.println(joinQuery + " result size = " + teams.size());

 

// user 데이터 조회 시, user에 대한 select query 팀 데이터 수 만큼 발생

teams.stream().forEach(t -> System.out.println("team name = " + t.getName() + ", team users = " + t.getUsers().toString()));

select t from Team as t join fetch t.users

// user data 까지 조회, user 수 만큼 team 데이터 중복

String fetchJoinQuery = ""; 
teams = entityManager.createQuery(fetchJoinQuery).getResultList();
System.out.println("\"" + fetchJoinQuery + "\" result size = " + teams.size());

 

// user 데이터 조회 시, user에 대한 select query 발생하지 않음

teams.stream().forEach(t -> System.out.println("team name = " + t.getName() + ", team users = " + t.getUsers().toString())); 

 

select distinct t from Team as t join fetch t.users

 // user data 까지 조회, team 데이터 중복 제거

String distinctFetchJoinQuery = "select distinct t from Team as t join fetch t.users";
teams = entityManager.createQuery(distinctFetchJoinQuery).getResultList();
System.out.println("\"" + distinctFetchJoinQuery + "\" result size = " + teams.size());

 

// user 데이터 조회 시, user에 대한 select query 발생하지 않음

teams.stream().forEach(t -> System.out.println("team name = " + t.getName() + ", team users = " + t.getUsers().toString())); 

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

• JPQL은 결과를 반환할 때 연관관계 고려하지 않는다.
  단지, SELECT 절에 지정된 팀 엔티티만 조회하고, 회원 엔티티는 조회하지 않음
• 페치 조인을 사용할 때만, 연관된 엔티티도 함께 조회한다. (즉시 로딩 발생)
• 페치 조인은 객체 그래프를 SQL 한번에 조회하는 개념

페치 조인의 한계

• 페치 조인 대상에는 별칭을 줄 수 없다.
  
  select distinct t from Team as t join fetch t.users u where u.age > 10
  
  하이버네이트는 가능하나 가급적 사용하지 않는 게 관례이다.
  특정 user 에 대한 조작이 필요한 경우에는 user를 직접 조회하는 방식이 적절하다.
  
• 둘 이상의 컬렉션은 페치 조인 할 수 없다.
  데이터 정합성에 문제
  
• 컬렉션을 페치 조인하면 페이징 API(setFirstResult, setMaxResults)를 사용할 수 없다.
  JPA 가 애플리케이션 차원에서 중복을 제거할 수 없기 때문이다.
  페이징은 DB 차원에서 처리되고, JPA 는 애플리케이션 차원에서 DB 결과를 바탕으로 중복을 제거한다.
  만약, 중복 데이터가 두 페이지 이상에 걸쳐있다면, JPA가 중복을 제거할 수 없고, 페이징도 맞지 않게 됨.
  
  • 반면, 중복 데이터가 없는 일대일, 다대일 같은 단일 값 연관필드들은 페치 조인해도 페이징 가능
  • 하이버네이트는 경고 로그를 남기고 메모리에서 페이징 처리 매우 위험

    나는 전현 의도하지 않았지만, JPA 가 페이징을 처리하기 위해 모든 DB에서 데이터를 가져온다.
    
    아래 실행 결과를 보면, 하이버네이트가 firstResult/maxResults specified with collection fetch; applying in memory! 경고를 발생시키며, 실제 쿼리에서는 limit/offset 설정 없이 쿼리가 나간 것을 확인할 수 있다.

String pagingFJoinQuery = "select t from Team as t join fetch t.users";
teams = entityManager.createQuery(pagingFJoinQuery).setFirstResult(0).setMaxResults(1).getResultList();
System.out.println("\"" + pagingFJoinQuery + "\" result size = " + teams.size());
teams.stream().forEach(t -> System.out.println("team name = " + t.getName() + ", team users = " + t.getUsers().toString())); // user에 대한 select query 발생하지 않음

 

 

그렇다면, 컬렉션 조회 시, 어떻게 페이징을 할 수 있을까?

select t from Team as t

실행 시, 한 번의 조회 쿼리와 더불어 팀의 수 만큼 추가적인 쿼리가 발생한 것을 볼 수 있다. (N + 1)

이러한, N + 1 문제를 해결하기 위해, batch 사이즈를 설정하면, 그 수 만큼 연관 엔티티를 함께 조회할 수 있다.

batch 사이즈 설정 방법

• @BatchSize 애노테이션 추가

• 글로벌 설정
  설정 파일에 hibernate.default_batch_fetch_size 추가
  
  <propertyname="hibernate.default_batch_fetch_size"value="100"/>

batch size 설정 후 실행 시, in query 로 user 엔티티를 한 번의 쿼리로 가져오는 모습을 볼 수 있다.

한 번에 모든 팀 연관 엔티티 조회하는 쿼리가 발생

페치 조인의 특징

• 연관된 엔티티들을 SQL 한 번으로 조회 - 성능 최적화 
• 엔티티에 직접 적용하는 글로벌 지연 전략보다 우선함
  • @OneToMany(fetch = FetchType.LAZY) //글로벌 로딩 전략
• 실무에서 글로벌 로딩 전략은 모두 지연 로딩으로 세팅하고, 최적화가 필요한 곳은 페치 조인 적용하도록!

페치 조인 정리

• 모든 것을 페치 조인으로 해결할 수 는 없음
• 페치 조인은 객체 그래프를 유지할 때 사용하면 효과적이다.
  u.team 으로 찾아가야 할 때
• 여러 테이블을 조인해서 엔티티가 가진 모양이 아닌 전혀 다른 결과를 내야 하면,
  페치 조인 보다는 일반 조인을 사용하고 필요 한 데이터들만 조회해서 DTO로 반환하는 것이 효과적이다.

JPQL 다형성 쿼리

TREAT(JPA 2.1)

• 자바의 타입 캐스팅과 유사
• 상속구조에서부모타입을특정자식타입으로다룰때사용
• FROM, WHERE, SELECT(하이버네이트 지원) 사용
  
  EX> 부모인 Item과 자식 Book이 있다.
  • [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’

JPQL 엔티티 직접 사용

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

엔티티의 아이디를 사용
[JPQL]

select count(m.id) from Member m

엔티티를 직접 사용
[JPQL]

select count(m) from Member m  

두 방법 모두 실행되는 쿼리는 같음
[SQL] 
select count(m.id) as cnt from Member m

엔티티를 파라미터로 전달
[JPQL]

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

식별자를 직접 전달
[JPQL]

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=?

엔티티 직접 사용 - 외래 키 값
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=?

JPQL Named 쿼리

Named 쿼리 - 정적 쿼리

• 미리 정의해서 이름을 부여해두고 사용하는 JPQL
• 정적쿼리만 가능
• 어노테이션, XML에 정의할 수 있다.
  
• 애플리케이션 로딩 시점에 초기화 후 재사용
• 따라서, 애플리케이션 로딩 시점에 쿼리를 검증할 수 있다.   PS>  spring-data-jpa의 @Query

List<User> list = entityManager.createNamedQuery("User.findByUserName", User.class)
                               .setParameter("name", "coco")
                               .getResultList();

 

JPQL - 벌크 연산

모든 유저의 age 를 +1 해야한다면?

JPA 변경 감지 기능으로 실행하려면 너무 많은 SQL을 실행해야한다.

• 모든 유저를 조회
• 모든 유저의 age 를 +1
• 트랜잭션 커밋 시점에 변경 감지 기능 동작
• 변경된 데이터가 100건이라면 100번의 UPDATE SQL 실행...

JPA 는 쿼리 한 번으로 여러 테이블 로우 변경(엔티티)하는 기능을 제공한다.

• executeUpdate() 의 결과는 영향받은 엔티티 수 반환한다.
• UPDATE, DELETE 지원
  
• 하이버네이트의 경우 벌크 INSERT도 지원한다.
  insert into .. select

entityManager.createQuery("update User u set u.age = u.age + 1").executeUpdate();

DB 결과

벌크 연산 주의

벌크 연산은 영속성 컨텍스트를 무시하고 데이터베이스에 직접 쿼리한다.
따라서, 벌크 연산으로 적용된 변경사항은 영속성 컨텍스트에 반영되지 않음.

[해결책]

벌크 연산을 먼저 실행하던가

벌크 연산수행 후 영속성 컨텍스트를 초기화 한다.

int resultCount = entityManager.createQuery("update User u set u.age = u.age + 1").executeUpdate();
entityManager.clear();
userList = entityManager.createQuery("select u from User u").getResultList();
System.out.println(userList.stream().map(User::getAge).collect(Collectors.toSet()));