Spring/JPA

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

Ynghan 2023. 3. 1. 02:19

JPQL(Java Persistence Query Language)

JPQL - 기본 문법과 기능

JPQL 소개

JPQL은 객체지향 쿼리 언어다. 따라서 테이블을 대상으로 쿼리하는 것이 아니라 엔티티 객체를 대상으로 쿼리한다.
JPQL은 SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.
JPQL은 결국 SQL로 변환된다.

JPQL 문법

select m from Member as m where m.age > 18
엔티티와 속성은 대소문자 구분O (Member, age)
JPQL 키워드 대소문자 구분 X (SELECT, FROM, where)
엔티티 이름 사용, 테이블 이름이 아님(Member)
별칭은 필수(m) (as는 생략가능)

집합과 정렬

GROUP BY, HAVING
ORDER BY

TypeQuery, Query

TypeQuery : 반환 타입이 명확할 때 사용
Query : 반환 타입이 명확하지 않을 때 사용

TypeQuery<Member> query1 = em.createQuery("select m from Member m", Member.class);
TypeQuery<String> query2 = em.createQuery("select m username from Member m", Member.class);
Query query3 = em.createQuery("select m.username, m.age from Member m");

결과 조회 API

query.getResultList() : 결과가 하나 이상일 때, 리스트 반환
- 결과가 없으면 빈 리스트 반환
query.getSingleResult() : 결과가 정확히 하나, 단일 객체 반환
- 결과가 없으면 : javax.persistence.NoResultException
- 둘 이상이면 : javax.persistence.NonUniqueResultException
- 값 하나가 보장되어야 함

TypeQuey<Member> query1 = em.createQuery("select m from Member m", Member.class);
List<Member> resultList = query.getResultList();

for(Member member1 : resultList) {
	System.out.println("member1 = " + member1);
}


TypeQuey<Member> query2 = em.createQuery("select m from Member m where m.id = 10", Member.class);
Member result = query.getStringResult();
System.out.println("result = " + result);

결과가 없는 경우에도 예외가 터지기 때문에 논란이 되고 있다.
Spring Data JPA의 경우에는 null로 반환하거나 optional로 반환한다.

파라미터 바인딩 - 이름 기준, 위치 기준

Member result = em.createQuery("select m from where m.username = :username", Member.class)
	.setParameter("username", "member1")
    .getStringResult();
    
System.out.println("result = " + result.getUsername());

위치 기준 파라미터는 사용하지 않는 것을 권장

프로젝션

SELECT 절에 조회할 대상을 지정하는 것
프로젝션 대상 : 엔티티, 임베디드 타입, 스칼라 타입(숫자, 문자 등 기본 데이터 타입)
SELECT m FROM Member m -> 엔티티 프로젝션
SELECT m.team FROM Member m -> 엔티티 프로젝션

List<Team> result = em.createQuery("select t from Member m.team t", Team.class)
		.getResultList();

SELECT m.address FROM Member m -> 엔티티 타입 프로젝션

em.createQuery("select o.address from Order o", Address.class)
	.getResultList();

SELECT m.username, m.age FROM Member m -> 스칼라 타입 프로젝션

em.createQuery("select distinct m.username, m.age from Member m")
	.getResultList();

DISTINCT로 중복 제거

프로젝션 - 여러 값 조회

SELECT m.username, m.age FROM Member m
1. Query 타입으로 조회

em.createQuery("select distinct m.username, m.age from Member m")
	.getResultList();
    
Object o = resultList.get(0);
Object[] result = (Object[]) o;
System.out.println("username = " + result[0]);
System.out.println("age = " + result[1]);

타입을 명기할 수 없으므로 Object로 돌려줌.

2. Object[] 타입으로 조회

List<Object[]> resultList = em.createQuery("select m.username, m.age from Member m")
		.getResultList();
        
Object[] result = resultList.get(0);
System.out.println("username = " + result[0]);
System.out.println("age = " + result[1]);

3. new 명령어로 조회
- 단순 값을 DTO로 바로 조회
  SELECT new jpabook.jpql.UserDTO(m.username, m.age) FROM Member m
- 패키지 명을 포함한 전체 클래스 명 입력
- 순서와 타입이 일치하는 생성자 필요

List<MemberDTO> result = em.createQuery("select new jpql.MemberDTO(m.username, m.age) from Member m", MemberDTO.class)
        .getResultList();

MemberDTO memberDTO = result.get(0);
System.out.println("memberDTO = " + memberDTO.getUsername());
System.out.println("memberDTO = " + memberDTO.getAge());

페이징 API

JPA는 페이징을 다음 두 API로 추상화
setFirstResult(int startPosition) : 조회 시작 위치 ( 0부터 시작 )
setMaxResults(int maxResult) : 조회할 데이터 수

페이징 API 예시

String jpql = "select m from Member m order by m.name desc";
List<Member> resultList = em.createQuery(jpql, Member.class)
	.setFirstResult(10)
    .setMaxResults(20)
    .getResultList();

조인

내부 조인 :
SELECT m FROM Member m [INNER] JOIN m.team t
외부 조인 :
SELECT m FROM Member m LEFT [OUTER] JOIN m.team t
세타 조인 :
select count(m) from Member m, Team t where m.username = t.name

조인

ON절을 활용한 조인(JPA 2.1부터 지원)
- 1. 조인 대상 필터링
- 2. 연관관계 없는 엔티티 외부 조인(하이버네이트 5.1부터)

1. 조인 대상 필터링

예) 회원과 팀을 조인하면서, 팀 이름이 A인 팀만 조인

JPQL :
SELECT m,t FROM Member m LEFT JOIN m.team t on t.name = 'A'

SQL :
SELECT m.*, t.* FROM
Member m LEFT JOIN Team t ON m.TEAM_ID=t.id and t.name='A'

2. 연관관계 없는 엔티티 외부 조인

예) 회원의 이름과 팀의 이름이 같은 대상 외부 조인

JPQL :
SELECT m, t FROM
Member m LEFT JOIN Team t on m.username = t.name

SQL :
SELECT m.*, t.* FROM
Member m LEFT JOIN Team t ON m.username = t.name

서브 쿼리

나이가 평균보다 많은 회원
select m from Member m
where m.age > (select avg(m2.age) from Member m2)
한 건이라도 주문한 고객
select m from Member m
where (select count(o) from Order o where m = o.memeber) > 0

서브 쿼리 지원 함수

[NOT] EXISTS (subquery) : 서브쿼리에 결과가 존재하면 참
{ALL | ANY | SOME} (subquery)
ALL 모두 만족하면 참
ANY, SOME : 같은 의미, 조건을 하나라도 만족하면 참
[NOT] IN (subquery) : 서브쿼리의 결과 중 하나라도 같은 것이 있으면 참

서브 쿼리 - 예제

팀A 소속인 회원
select m from Member m
where exists (select t from m.team t where t.name = '팀A')
전체 상품 각각의 재고보다 주문량이 많은 주문들
select o from Order o
where o.orderAmount > ALL (select p.stockAmount from Product p)
어떤 팀이든 팀에 소속된 회원
select m from Member m
where m.team = ANY (select t from Team t)

JPA 서브 쿼리 한계

JPA는 WHERE, HAVING 절에서만 서브 쿼리 사용 가능
SELECT 절도 가능(하이버네이트에서 지원)
FROM 절의 서브 쿼리는 현재 JPQL에서 불가능
- 조인으로 풀 수 있으면 풀어서 해결

JPQL 타입 표현

문자 : 'HELLO', 'She''s'
숫자 : 10L(Long), 10D(Double), 10F(Float)
Boolean : TRUE, FALSE
ENUM : jpabook.MemberType.Admin
엔티티 타입 : TYPE(m) = Memer (상속 관계에서 사용)

JPQL 기타

SQL과 문법이 같은 식
EXISTS, IN
AND, OR, NOT
=, >, >=, <. <=, <>
BETWEEN, LIKE, IS NULL

조건식 - CASE 식

• COALESCE: 하나씩 조회해서 null이 아니면 반환
• NULLIF: 두 값이 같으면 null 반환, 다르면 첫번째 값 반환

JPQL 기본 함수

CONCAT
SUBSTRING
TRIM
LOWER, UPPER
LENGTH
LOCATE
ABS, SQRT, MOD
SIZE, INDEX(JPA 용도)

사용자 정의 함수 호출

하이버네이트는 사용전 방언에 추가해야 한다.
사용하는 DB 방언을 상속받고, 사용자 정의 함수를 등록한
다.

JPQL - 경로 표현식

경로 표현식

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

경로 표현식 용어 정리

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

경로 표현식 특징

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

상태 필드 경로 탐색

JPQL : select m.username, m.age from Member m
SQL : select m.username, m.age from Member m

단일 값 연관 경로 탐색

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

경로 표현식 - 예제

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) 절에 영향을 줌

실무 조언

가급적 묵시적 조인 대신에 명시적 조인 사용
조인은 SQL 튜닝에 중요 포인트
묵시적 조인은 조인이 일어나는 상황을 한눈에 파악하기 어려움

JPQL - 페치 조인(fetch 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

페치 조인 사용 코드

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] SELE 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가지 기능 제공
- 1. SQL에 DISTINCT를 추가
- 2. 애플리케이션에서 엔티티 중복 제거
select distinct t from Team t join fetch t.members where t.name = '팀A'
SQL에 DISTINCT를 추가하지만 데이터가 다르므로 SQL 결과에서 중복제거 실패

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

[DISTINCT 추가시 결과]
teamname = 팀A, team = Team@0x100
-> username = 회원1, member = Member@0x200
-> username = 회원2, member = Member@0x300

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

일반 조인 실행시 연관된 엔티티를 함께 조회하지 않음
[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 한번에 조회하는 개념

페치 조인 실행 예시

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

페치 조인의 특징과 한계

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

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

페치 조인 - 정리

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

JPQL - 다형성 쿼리

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(JPA 2.1)

자바의 타입 캐스팅과 유사
상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용
FROM, WHERE, SELECT(하이버네이트 지원) 사용
예) 부모인 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 //엔티티의 아이디를 사용
select count(m) from Member m //엔티티를 직접 사용
[SQL](JPQL 둘다 같은 다음 SQL 실행)
select count(m.id) as cnt from Member m

엔티티를 파라미터로 전달

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

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

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