객체지향 쿼리 언어 (JPQL)

JPA는 다양한 쿼리 방법을 지원

• JPQL
• JPA Criteria
• QueryDSL
• 네이티브 SQL
• JDBC API 직접 사용, MyBatis, StringJdbcTemplate도 함께 사용

JPQL이란

• 가장 단순한 조회방법
  • em.find()
  • 객체 그래프 탐색 (a.getB().getC())
• jpa를 사용하면 엔티티 객체를 중심으로 개발
• 문제는 검색 쿼리
• 검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색
• 모든 DB데이터를 객체로 변환해서 검색하는 것은 불가능
• 애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색조건이 포함된 SQL이 필요
• JPA는 SQL을 추상화한 JPQL 이라는 객체 지향 쿼리 언어 제공
• SQL과 문법 유사, select, from, where, group by, having, join지원
• JPQL은 엔티티 객체를 대상으로 쿼리
• SQL은 데이터 베이스 테이블을 대상으로 쿼리

사용 방법은 다음과 같다.

List<Member> resultList = em.createQuery(
                    "select m from Member m where m.username like '%kim%'",
                    Member.class
            ).getResultList();

객체를 대상으로 쿼리를 작성해서 조건을 추가할 수 있다.

테이블이 아닌 객체를 대상으로 검색하는 객체지향 쿼리이며 SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.

JPA Criteria

우선 코드를 봐보자

CriteriaBuilder cr = em.getCriteriaBuilder();
CriteriaQuery<Member> query = cr.createQuery(Member.class);

Root<Member> m = query.from(Member.class);

CriteriaQuery<Member> where = query.select(m).where(cr.equal(m.get("username"), "kim"));
List<Member> resultList = em.createQuery(where).getResultList();

딱 봐도 뭔가 복잡하다. Criteria는 독자적인 사용법이 있어 이를 숙지하지 않으면 코드를 읽기가 굉장히 힘들다. 장점으로는 자바 코드로 이루어져 있기 때문에 오탈자가 발생할 시 컴파일 오류가 발생한다.

또 자바 코드로 이루어져 있는 만큼 동적 쿼리를 작성하는데도 훨씬 유리하다는 장점이 있다.

실무에서는 잘 안쓴다고 한다

QueryDSL

Criteria의 장점을 모두 가져오고 코드 가독성도 훨씬 좋다.

외부 라이브러리이기 때문에 초기 세팅이 어렵지만 세팅해놓으면 동적 쿼리를 작성할때 유리하다

네이티브 SQL

• JPA가 제공하는 SQL을 직접 사용하는 기능
• JPQL로 해결할 수 없는 특정 데이터베이스에 의존적인 기능
• 예) 오라클 CONNECT BY, 특정 DB만 사용하는 SQL 힌트

JDBC 직접사용, SpringJdbcTemplate등

• JPA를 사용하면 JDBC 커넥션을 직접 사용하거나, 스프링 JdbcTemplate, 마이바티스 등을 함께 사용 가능
• 단 영속성 컨텍스트를 적절한 시점에 강제로 플러시 필요
• 예) JPA를 우회해서 SQL을 실행하기 직전에 영속성 컨텍스트 수동 플러시

주로 자주 사용되는 기술은 JPQL과 QueryDSL이 있다

JPQL

JPQL의 기본 문법과 기능

• select m from Member as m where m.age > 18
• 엔티티의 속성은 대소문자 구분해야함
• JPQL 키워드는 대소문자 구분 X (select, from, where)
• 엔티티 이름 사용, 테이블 이름이 아님(Member)
• 별칭은 필수

TypeQuery, Query

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

//타입쿼리
TypedQuery<Member> selectMFromMemberM = em.createQuery("select m from Member m", Member.class);
TypedQuery<String> query = em.createQuery("select m.username from Member m", String.class);
//쿼리
Query query2 = em.createQuery("select m.username, m.age from Member m");

결과 조회 API

• query.getResultList() : 결과가 하나 이상일때, 리스트 반환
  • 결과가 없으면 빈 리스트 반환
• query.getSingleResult() : 결과가 정확히 하나, 단일 객체 반환
  • 결과가 없거나 둘 이상이면 Exception이 터진다

파라미터 바인딩

• 이름이나 위치 기준으로 바인딩 해준다.

TypedQuery<Member> query = em.createQuery("select m from Member m where m.username = :username", Member.class);
query.setParameter("username", "test");
Member singleResult = query.getSingleResult();
System.out.println("singleResult = " + singleResult);

그냥 위치기반 쓰지 말고 이름 기반으로 쓰자

프로젝션

• select 절에 조회할 대상을 지정하는 것
• 프로젝션 대상 : 엔티티, 임베디드 타입, 스칼라 타입 (숫자, 문자등 기본 데이터 타입)
• 그냥 select m from Member m → m 이 프로젝션이다

문제는 두개 이상의 스칼라 타입을 반환받는 쿼리의 리턴값을 설정해주는데서 온다.

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

프로젝션 - 여러 값 조회

• Query 타입으로 조회 - Object 배열로 값들을 받아옴

List resultList = em.createQuery("select m.username, m.age from Member m").getResultList();
Object o = resultList.get(0);
Object[] result = (Object[]) o;
System.out.println("result[0] = " + result[0]);
System.out.println("result[1] = " + result[1]);
// 뭔가 이상하다...

List<Object[]> resultList = em.createQuery("select m.username, m.age from Member m").getResultList();
Object[] result = resultList.get(0);
System.out.println("result[0] = " + result[0]);
System.out.println("result[1] = " + result[1]);
// 제네릭 타입을 선언해주면 그나마 가독성이 나아진다

• new 명령어로 조회
  • 단순값을 DTO로 바로 조회

Member member= new Member();
member.setUsername("test");
member.setAge(10);
em.persist(member);

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

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

for (MemberDTO memberDTO : resultList) {
		System.out.println("memberDTO.getUsername() = " + memberDTO.getUsername());
		System.out.println("memberDTO.getAge() = " + memberDTO.getAge());
}

가장 깔끔하지만 패키지가 길어지면 문장이 길어지는 단점이 있다

페이징 API

• JPA는 페이징을 다음 두 API로 추상화
• setFirstResult(int startPosition) : 조회 시작위치
• setMaxResult(int maxPosition) : 조회 시작위치

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

마이바티스로 프로젝트 진행할때 삽질한거 생각하면 정말 말도 안된다고 생각된다…..

persistence.xml 파일의 설정만 바꿔주만 DB 종류에 따른 방언도 모두 처리해준다고 한다

조인

[ ] 안에 있는 값은 생략 가능

• 내부조인
  • 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 절

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

서브 쿼리

• 나이가 평균보다 많은 회원
  • 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.member) > 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)

JPA 서브쿼리의 한계

• JPA는 where, having 절에서만 서브쿼리 사용 가능
• select 정도 가능 (하이버네이트에서 지원)
• from 절의 서브 쿼리는 현재 JPQL에서 불가능
  • 조인으로 풀 수 있으면 풀어서 해결

JPQL의 타입 표현

• 문자 : 작은 따옴표 안에 정의한다.
• 숫자 : 자바의 숫자 타입을 정의하는 방법과 비슷하다. (10L, 10D, 10F)
• Boolean : true, false
• enum : enum 같은 경우가 좀 특이한테 자바의 패키지 명까지 다 넣어줘야 한다.

String query = "select m.username, 'HELLO', TRUE from Member m " +
                    "where m.type = org.example.jpql.MemberType.ADMIN";

• 엔티티 타입 : TYPE(m) = Member (상속 관계에서 사용)

조건식 - CASE식

• 기본 CASE식

select
case when m.age <= 10 then '학생요금'
when m.age >= 60 then '경로요금'
else '일반요금'
end
from Member m

• 단순 CASE식

select
case t.name
when '팀A' then '인센티브110%'
when '팀B' then '인센티브120%'
else '인센티브105%'
end
from Team t

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

case

String query = "select " +
        " case when m.age <= 10 then '학생요금'" +
        "      when m.age >= 60 then '경로요금'" +
        "      else '일반요금' " +
        "end " +
        "from Member m";

List<String> result = em.createQuery(query, String.class)
        .getResultList();

for (String s : result) {
    System.out.println("s = " + s);
}

coalesce

String query =
        "select coalesce(m.username, '이름없는 회원') from Member m";

List<String> result = em.createQuery(query, String.class)
        .getResultList();

for (String s : result) {
    System.out.println("s = " + s);
}

nullif

String query =
        "select nullif(m.username, '관리자') from Member m";

List<String> result = em.createQuery(query, String.class)
        .getResultList();

for (String s : result) {
    System.out.println("s = " + s);
}

JPQL 기본함수와 사용자 정의함수

• 표준함수
  • CONCAT, SUBSTRING, TRIM, LOWER, UPPER, LENGTH, LOCATE, ABS, SQRT, MOD, SIZE, INDEX(JPA 용도)
• 사용자 정의 함수 호출
  • 하이버네이트는 사용 전 방언에 추가해야 한다
  • 사용하는 DB방언을 상속받고, 사용자 정의 함수를 등록한다.

select function('group_concat', i.name) from Item i