객체지향 쿼리 언어2 - 중급 문법

hyyyynjn·2021년 9월 14일
JPA 프로그래밍 - 기본편김영한
0

자바 ORM 표준 JPA 프로그래밍 - 기본편

목록 보기
14/14
post-thumbnail

✅ 경로 표현식

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

경로 표현식 용어 정리

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

경로 표현식 특징

  • 상태 필드(state field): 경로 탐색의 끝, 탐색이 불가능하다
  • 단일 값 연관 경로: ⭐묵시적 내부 조인(inner join) 발생, 탐색O
    • 실무에서 묵시적 내부 조인이 발생하게 짜면 안된다.
-- team에서 경로탐색이 더 가능하다(name)
'JPQL' : select m.team.name from Member m; 
'SQL' : select m.* from Orders o 
inner join Member m on o.member_id = m.id
  • 컬렉션 값 연관 경로: 묵시적 내부 조인 발생, 탐색X
    • FROM 절에서 명시적 조인을 통해 별칭을 얻으면 별칭을 통해 탐색 가능
// t.members에서 경로탐색이 불가능하다 (t.members이 컬랙션이므로)
List<Collection> result = em.createQuery("select t.members from Team t", Collection.class)
.getResultList();
// FROM 절에서 명시적 조인을 통해 별칭을 얻으면 별칭을 통해 탐색 가능하다
em.createQuery("select m.username from Team t join t.members m", String.class);

명시직 조인, 묵시적 조인

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

경로 표현식 - 예제

select o.member.team from Order o -> 성공
select t.members from Team -> 성공
select t.members.username from Team t -> 실패
select m.username from Team t join t.members m -> 성공

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

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

실무 조언

📌 실무에서는 명시적 조인을 사용하도록 하자
📌 묵시적 조인은 조인이 일어나는 상황을 한눈에 파악하기 어려움 (그냥 사용하지 마라)
📌 묵시적 조인은 조인이 일어나는 상황을 한눈에 파악하기 어려움

✅페치 조인(fetch join)

실무에서 정말정말 중요함 ⭐⭐

  • SQL 조인 종류가 아니다.
    JPQL에서 성능 최적화를 위해 제공하는 전용 기능이다.
  • 연관된 엔티티나 컬렉션을 SQL 한 번에 함께 조회하는 기능
  • join fetch 명령어를 사용한다
    • 페치 조인 ::= [ LEFT [OUTER] | INNER ] JOIN FETCH 조인경로

엔티티 페치 조인

  • 회원을 조회하면서 연관된 팀도 함께 조회(SQL 한 번에)
  • SQL을 보면 회원 뿐만 아니라 팀(T.*)도 함께 SELECT한다
  • JPQL : join fetch로 Member, Team을 함께 SELECT할 수 있다. (즉시 로딩과 비슷)
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

페치 조인 사용 코드

회원 정보와 함께 팀 정보도 같이 가져오고 싶다.

@Entity
public class Member {

    @Id @GeneratedValue
    private Long id;
    private String username;
    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "TEAM_ID")
    private Team team;

    @Enumerated(EnumType.STRING)
    private MemberType type;
  ...
}

Member는 private Team team을 지연로딩(FetchType.LAZY)으로 가져온다.

Bad Example

Team teamA = new Team();
teamA.setName("팀A");
em.persist(teamA);

Team teamB = new Team();
teamB.setName("팀B");
em.persist(teamB);

Member member1 = new Member();
member1.setUsername("회원1");
member1.setTeam(teamA);
em.persist(member1);

Member member2 = new Member();
member2.setUsername("회원2");
member2.setTeam(teamA);
em.persist(member2);

Member member3 = new Member();
member3.setUsername("회원3");
member3.setTeam(teamB);
em.persist(member3);

em.flush();
em.clear();

String jpql = "select m from Member m";
List<Member> members = em.createQuery(jpql, Member.class)
        .getResultList();
for (Member member : members) {
    System.out.println("username = " + member.getUsername() + ", " +
            "teamName = " + member.getTeam().getName());
}
tx.commit();

Team 객체는 프록시로 설정되어 있고,
member.getTeam().getName() 가 실행될 때마다 쿼리가 나가 Team의 name 정보를 얻어온다.

  • 회원1 👉 팀A를 SQL을 날려 얻어온다 (1차 캐시에 저장)
  • 회원2 👉 팀A를 1차 캐시에서 얻어온다
  • 회원3 👉 팀B를 SQL을 날려 얻어온다 (1차 캐시에 저장)
    진짜 성능 최악이다 (N+1 문제)

Good Example

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().getName());
}
tx.commit();

select m from Member m join fetch m.team
join으로 한방 쿼리가 나가고 member.getTeam()의 Team은 프록시가 아니라 실제 엔티티다.
👉 Member에서 Team을 지연로딩으로 설정했지만 fetch join의 우선순위 때문에 지연 로딩 없이 가져온다.

컬렉션 페치 조인

  • 일대다 관계, 컬렉션 페치 조인
  • 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'

  • 데이터베이스
    팀A는 Member를 2명 가지고 있을 때,
    Team Join Member하면 튜플이 2개 생긴다.
    (팀A-회원1,팀A-회원2)
  • JPA
    • 첫 번째 튜플(팀A-회원1)에 대해서 팀A를 영속성 컨택스트 1차 캐시에 올려둔다.
    • 두 번째 튜플에도 팀A가 있지만 이미 영속성 컨택스트에 올려져있다.
      👉 조회한 컬랙션 teams에는 같은 주소값 0x100을 가진 결과가 담겨있다.

데이터 중복

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("-> member = " + member);
    }
}

일대다 관계에서 데이터를 가져오면 데이터양이 불어난다.
👉 개발자가 알아서 중복된 데이터를 처리해야한다.
(다대일 관계에서는 데이터가 중복될 일이 없다)

페치 조인과 DISTINCT

페치 조인으로 데이터가 중복된 것을 처리하기 위해 DISTINCT 키워드를 사용한다.

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

1. SQL에 DISTINCT를 추가

select distinct t
from Team t join fetch t.members
where t.name = ‘팀A’
  • SQL에 DISTINCT를 추가하지만 데이터가 다르므로 SQL 결과에서 중복제거 실패
    • 데이터베이스 입장에서 보면, 모든 속성값이 동일한 튜플만 제거하기 때문에 DISTINCT로 원하는 중복제거가 안 된다. (ID(PK) 값과 NAME 값이 다르다)

2. 애플리케이션에서 엔티티 중복 제거

  • DISTINCT가 추가로 애플리케이션에서 중복 제거시도한다.(컬랙션에서 중복을 없애준다)
    • 같은 식별자를 가진 Team 엔티티 제거된다.
String jpql = "select distinct t from Team t join fetch t.members";
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("-> member = " + member);
    }
}

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

  • 일반 조인 실행시 연관된 엔티티를 함께 조회하지 않음
  • 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'
  • JPQL은 결과를 반환할 때 연관관계 고려X
  • 단지 SELECT 절에 지정한 엔티티만 조회할 뿐
  • 여기서는 팀 엔티티만 조회하고, 회원 엔티티는 조회X
  • 페치 조인을 사용할 때만 연관된 엔티티도 함께 조회(즉시 로딩)
  • 페치 조인은 객체 그래프를 SQL 한번에 조회하는 개념

일반 조인 예시

String jpql = "select t from Team t join t.members m";
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("-> member = " + member);
    }
}

select 쿼리를 보면 Team만 가져온다.

페치 조인 실행 예시

  • 페치 조인은 연관된 엔티티를 함께 조회함
  • 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'

페치 조인의 특징과 한계

📌페치 조인 대상에는 별칭을 주지 말아라.

select t from Team t join t.members m where m.age > 10
  • 하이버네이트는 가능, 가급적 사용하지 말아라
  • 영속성 컨택스트에 담기는 Team은 모든 Member들이 아닌 나이가 10보다 큰 Member들만 가지게 된다. (데이터 정합성 문제 발생)

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

일대다대다 관계가 되버린다 (1 x N x M)

📌컬렉션을 페치 조인하면 페이징 API(setFirstResult, setMaxResults)를 사용할 수 없다.

// 일대다
String jpql = "select t from Team t join fetch t.members m";
List<Team> teams = em.createQuery(jpql, Team.class)
        .setFirstResult(0)
        .setMaxResults(1)
        .getResultList();
  • 일대일, 다대일 같은 단일 값 연관 필드들은 페치 조인해도 페이징 가능하다.
  • 하지만 일대다의 경우 하이버네이트는 경고 로그를 남기고 모든 데이터를 가져와 메모리에서 페이징한다. (매우 위험 : 만약 Member가 100만개라면 ㅎㄷㄷ)
    • WARN: HHH000104: firstResult/maxResults specified with collection fetch; applying in memory!

📢해결방안

  • 일대다를 다대일로 방향을 전환하여 해결한다
// 다대일로 쿼리를 바꾸면 페이징이 가능하다
String jpql = "select m from Member m join fetch m.team t"
List<Team> teams = em.createQuery(jpql, Team.class)
        .setFirstResult(0)
        .setMaxResults(1)
        .getResultList();
  • BatchSize()를 사용한다.
@Entity
public class Team {
    ...
    
    @BatchSize(size = 100)
    @OneToMany(mappedBy = "team")
    private List<Member> members;
    
    ...
}

String query = "select t from Team t";

지연로딩 상태이지만, 조회할 때 members를 BatchSize()의 size 속성만큼 조회해 온다.

  • BatchSize()는 글로벌 설정으로 할 수도 있다.
//persistence.xml
<property name="hibernate.default_batch_fetch_size" value="100"/>

나머지 특징

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

정리

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

✅다형성 쿼리

그리 중요하지 않다

TYPE

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

//SQL
select i from Item i where i.DTYPE in('B', 'M');
  • 조회 대상을 특정 자식으로 한정
  • ex: Item 중 Book, Movie를 조회해라

TREAT (JPA2.1)

//JPQL
select from Item i where treat(i as Book).author = 'kim';

//SQL[
select i.* from Item i where i.DTYPE = 'B' and i.author = 'kim';
  • 자바의 타입 캐스팅과 유사(형변환)
  • 상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용
  • FROM, WHERE, SELECT(하이버네이트 지원) 사용
  • ex: 부모님 Item과 자식 Book이 있다.

✅엔티티 직접 사용

기본 키 값

  • JPQL에서 엔티티를 직접 사용하면 SQL에서 해당 엔티티의 기본 키 값을 사용
//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
  • 파라미터를 엔티티를 넘겨주거나 식별자를 넘겨주더라도 실행된 SQL은 같다.
/*엔티티를 파라미터로 전달*/
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();
  • 위 두 JPQL의 실행 SQL은 아래와 같이 동일하다
select m.* from Member m where m.id = ?

외래 키 값

  • 기본키와 로직은 동일하다. 엔티티 or 외래 키를 쓰면 실행 SQL은 동일하다
Team team = em.find(Team.class, 1L);

String query = "select m from Member m where m.team = :team";
List resultList = em.createQuery(query)
                    .setParameter("team", team)
                    .getResultList();

String query = "select m from Member m where m.team.id = :teamId";
List resultList = em.createQuery(query)
                    .setParameter("teamId", teamId)
                    .getResultList();
  • 실행된 SQL
select m.* from Member m where m.team_id = ?

✅ Named 쿼리

  • 미리 정의해서 이름을 부여해두고 사용하는 JPQL
  • 동적 쿼리는 안되고 정적 쿼리만 가능하다.
  • 어노테이션, XML에 정의
@Entity
@NamedQuery(
      name="Member.findByUsername",
      query="select m from Member m where m.username = :username")
public class Member {
		...
}

...

List<Member> resultList = 
em.createNamedQuery("Member.findByUsername", Member.class)
  .setParameter("username", "회원1")
  .getResultList();
  • 📌애플리케이션 로딩 시점에 초기화 후 재사용할 수 있다.(가장 큰 장점)
    👉 JPA는 결국 SQL로 parsing 되어 사용되는데 로딩 시점에 초기화가 된다면 parsing cost를 절약 가능하다.
  • 📌애플리케이션 로딩 시점에 쿼리를 검증한다.(오류를 잡을 수 있다)⭐⭐

XML에 정의

사용법은 @NamedQuery의 query를 사용방법과 같다.

//[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="htt://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>
</entity-mappings>

NamedQuery와 XML에 정의된 Query중 XML이 항상 우선권을 가진다.
👉 애플리케이션 운영 환경에 따라 다른 XML를 배포할 수 있다.

Spring Data JPA를 사용하는 사람은 Named Query를 이미 사용하고 있다.

@Repository
public interface MemberRepository extends JpaRepository<Member, Long>{

      @Query("select u from User u where u.username = ?1")
      Member findByUsername(String username);
}

@Repository annotation이 등록된 인터페이스에서 사용되는 @Query annotation에 있는 JPQL(or native)들이 NamedQuery로써 컴파일시에 등록되는 것이다.

✅벌크 연산

  • 일반적으로 우리가 알고 있는 SQL의 update or delete 문을 생각하면 된다.
    • ex: 재고가 10개 미만인 모든 상품의 가격을 10% 상승하려면?
  • 위와 같은 예시를 실행하려면 JPA의 dirty check로 실행하기 위해서는 너무 많은 SQL이 실행되야 한다.
    1. 재고가 10개 미만인 상품을 리스트 조회
    2. 상품 엔티티의 가격 10% 증가
    3. 트랜잭션 커밋 시점에 dirty checking.
  • 변경된 데이터가 100건이면 100건의 UPDATE SQL 실행해야한다.

예시

  • 쿼리 한 번으로 여러 테이블 업데이트 (엔티티)
  • executeUpdate()의 결과는 영향받은 엔티티 수 반환
  • UPDATE, DELETE 지원
  • INSERT(insert into ... select, 하이버네이트 지원)
String query = 
  "update Product p "+ 
  "set p.price = p.price * 1.1 where p.stockAmount < :stockAmount";

int resultCount = em.createQuery(qlString)
                    .setParameter("stockAmount", 10)
                    .executeUpdate();

벌크 연산 주의

  • 벌크 연산은 영속성 컨텍스트를 무시하고 데이터베이스에 직접 쿼리를 날린다.
    1. 벌크 연산을 먼저 실행 (createQuery)한다.
    2. 벌크 연산 수행 (createQuery) 후 영속성 컨텍스트 초기화 (em.clear()) 한뒤 조회한다.
      👉 엔티티 조회 후 벌크연산으로 엔티티 업데이트가 되버리면 DB의 엔티티와 영속성 컨텍스트의 엔티티가 서로 다른 값이 되게 된다
Team teamA = new Team();
teamA.setName("팀A");
em.persist(teamA);

Team teamB = new Team();
teamB.setName("팀B");
em.persist(teamB);

Member member1 = new Member();
member1.setUsername("회원1");
member1.setTeam(teamA);
member1.setAge(0);
em.persist(member1);

Member member2 = new Member();
member2.setUsername("회원2");
member2.setTeam(teamA);
member2.setAge(0);
em.persist(member2);

Member member3 = new Member();
member3.setUsername("회원3");
member3.setTeam(teamB);
member3.setAge(0);
em.persist(member3);

int resultCount = em.createQuery("update Member m set m.age = 20")
        .executeUpdate();
System.out.println("resultCount = " + resultCount);

Member findMember = em.find(Member.class, member1.getId());
System.out.println("findMember.getAge() = " + findMember.getAge());

  • em.createQuery("update Member m set m.age = 20") 가 실행될때 flush되어 DB에 쿼리가 나간다.
    👉 Member들의 age가 모두 20으로 업데이트 된다.
  • em.find(Member.class, member1.getId());
    하지만 영속성 컨택스트의 Member들의 age는 아직 0이다.

int resultCount = em.createQuery("update Member m set m.age = 20")
        .executeUpdate();
System.out.println("resultCount = " + resultCount);

em.clear();

Member findMember = em.find(Member.class, member1.getId());
System.out.println("findMember.getAge() = " + findMember.getAge());

em.clear();으로 영속성 컨택스트를 비우면
em.find(Member.class, member1.getId()); 시점에 Member 데이터를 DB에서 가져오게 된다.

profile
hyyyynjn
이전 포스트

객체지향 쿼리 언어1 - 기본 문법

0개의 댓글