[자바 ORM 표준] 객체지향 쿼리 언어1(JPQL)

June 3, 2022 6 분 소요

JPA가 지원하는 쿼리 방법

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

JPQL 소개

JPA를 사용하면 엔티티 객체를 중심으로 개발
검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색
애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색 조건이 포함된 SQL이 필요
JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어를 제공
SQL과 문법이 유사하다.(SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN 지원)
JPQL은 엔티티 객체를 대상으로 쿼리
SQL은 데이터베이스 테이블을 대상으로 쿼리
SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.

// 검색
String jpql = "select m From Member m where m.name like '%hello%'";

List<Member> result = em.createQuery(jpql, Member.class)
        .getResultList();

JPQL과 SQL

JPQL

String jpql = "select m From Member m where m.age > 18";

List<Member> result = em.createQuery(jpql, Member.class)
        .getResultList();

실행된 SQL

select
    m.id as id,
    m.age as age, 
    m.USERNAME as USERNAME, 
    m.TEAM_ID as TEAM_ID 
from 
    Member m 
where 
    m.age>18 

Criteria 소개

앞에서 본 JPQL 예제는 SQL문이 String이기 때문에 동적쿼리를 만들기가 어렵다.
Criteria는 문자가 아닌 자바코드로 JPQL을 작성할 수 있다.
JPQL 빌더 역할
JPA 공식 기능
장점 : 동적 쿼리를 작성하기 좋으며, 자바 코드이기 때문에 오타시 컴파일 에러가 발생한다.
단점 : 너무 복잡하고 실용성이 없다.(실무에서 사용하지 않는다.)
Criteria 대신에 QueryDSL 사용을 권장한다.

QueryDSL 소개

문자가 아닌 자바코드로 JPQL을 작성할 수 있다.
JPQL 빌더 역할
컴파일 시점에 문법 오류를 찾을 수 있다.
동적쿼리 작성이 편리함
단순하고 쉬움
실무에서 사용하는 것을 권장

네이티브 SQL 소개

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

JDBC 직접 사용, SpringJdbcTemplate 등

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

JPQL - 기본 문법과 기능

JPQL은 엔티티 객체를 대상으로 쿼리
JPQL은 SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.
JPQL은 결국 SQL로 변환된다.
- JPQL + 매핑 정보 + 방언

JPQL 문법

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

집합과 정렬

select
    COUNT(m),   // 회원 수
    SUM(m.age), // 나이 합
    AVG(m.age), // 평균 나이
    MAX(m.age), // 최대 나이
    MIN(m.age)  // 최소 나이
from Member m

GROUP BY, HAVING
ORDER BY

TypeQuery, Query

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

TypedQuery<Member> query =
    em.createQuery("select m from Member m", Member.class)

반환 타입 : Member

Query query = 
    em.createQuery("select m.username, m.age from Member m");

반환 타입 : Stirng, Integer

결과 조회 API

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

파라미터 바인딩

이름 기준

SELECT m FROM Member m where m.username=:username

query.setParameter("username", usernameParam);

위치 기준

SELECT m FROM Member m where m.username=?1

query.setParameter(1, usernameParam);

데이터 값 삭제 또는 수정시 위치가 바뀔 수 있다.
위치가 바뀌면 에러가 발생하기 때문에 사용하지 않는 것이 좋다.

프로젝션

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

프로젝션 - 여러 값 조회

1.Query 타입으로 조회

2.Object[] 타입으로 조회

List<Object[]> resultList = em.createQuery("SELECT m.username, m.age FROM Member m")
      .getResultList();
Object[] o = resultList.get(0);

3.new 명령어로 조회
- 단순 값을 DTO로 바로 조회
- 패키지명을 포함한 전체 클래스명 입력
- 순서와 타입이 일치하는 생성자 필요

public class MemberDTO {
    private String username;
    private int age;

    // constructor
    // getter and setter
}

------------------------------------

public class JpqlMain {

    ...

    List<MemberDTO> result = 
        em.createQuery("select new jpql.MemberDTO(m.username, m.age) from Member m", MemberDTO.class)
        .getResultList();
    
    MemberDTO memberDTO = result.get(0);
    String m_username = memberDTO.getUsername();
    int m_age = memberDTO.getAge();
}

페이징 API

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

// 페이징 쿼리
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();

조인

내부 조인 : Member만 있고, Team에는 값이 없으면 쿼리가 나가지 않는다.
- SELECT m FROM Member m [INNER] JOIN m.team t
외부 조인 : Member만 있고, Team에는 값이 없으면 Team값은 null이 되고, Member 쿼리는 그대로 나간다.
- SELECT m FROM Member m LEFT [OUTER] JOIN m.team t
세타 조인 : Member와 Team은 연관관계가 아니다.
- select count(m) from Member m, Team t where m.username = t.name

조인 - ON절

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

1. 조인 대상 필터링

Ex) 회원과 팀을 조인하면서 팀 이름이 A인 팀만 조인
JPQL
- SELECT m, t FROM Member m LEFT JOIN m.team t ON t.name = ‘A’
- team.name = ‘A’인것만 JOIN한다.
SQL
- SELECT m., t. FROM Member m LEFT JOIN Team t ON m.TEAM_ID=t.id and t.name=’A’

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

Ex) 회원의 이름과 팀의 이름이 같은 대상 외부 조인
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.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)

어떤 팀이든 팀에 소속된 회원

select m from Member m
where m.team = ANY (select t from Team t)

서브 쿼리 한계

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) = Member (상속 관계에서 사용)
- Ex) select i from Item i where type(i) = Book

ENUM

// 패키지명 포함
"select m.username, 'HELLO', true From Member m" + 
"where m.type = jpql.MemberType.Admin"
------------------------------------------------------
// 변경
String query = "select m.username, 'HELLO', true From Member m" + 
"where m.type =: userType";

em.createQuery(query)
    .setParameter("userType", MemberType.ADMIN)

JPQL 기타

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

조건식 - CASE

기본 CASE식

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

QueryDSL에서 자바 코드로 지원한다.
COALESCE : 인자가 모두 NULL이면 NULL 반환, 아닌 경우 NULL이 아닌 첫번째를 반환
NULLIF : 두 값이 같으면 NULL 반환, 다르면 첫번째 값 반환

사용자 이름이 없으면 ‘이름 없는 회원’을 반환 select coalesce(m.username, '이름 없는 회원') from Member m
m.username이 null이라면 ‘이름 없는 회원’이 null은 아니기 때문에 반환된다

사용자 이름이 ‘관리자’면 null을 반환, 아니면 ‘관리자’를 반환 select NULLIF(m.username, '관리자') from Member m

JPQL 기본 함수

JPQL 표준 함수이기 때문에 데이터베이스와 관계없이 사용 가능하다.

CONCAT(문자 더하기) - select concat(‘a’, ‘b’) …
SUBSTRING(문자 자르기) - select subString(m.username, 2, 3) …
TRIM(공백 제거)
LOWER, UPPER(대 소문자)
LENGTH
LOCATE - select locate(‘de’, ‘abcdefg’) -> 4(Integer.class)
ABS, SQRT, MOD
SIZE, INDEX(JPA 용도) - select size(t.members) from Team t
- INDEX는 @OrderColumn에서 사용하지만 실제로 사용하지 않는다.

사용자 정의 함수 호출

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

DB 방언 상속 후 사용자 정의 함수 등록

public class MyH2Dialect extends H2Dialect{
    public MyH2Dialect(){
        registerFunction(...);
    }
}

persistence.xml

"hibernate.dialect" value = "dialect.MyH2Dialect"

<출처 : 인프런 - 자바 ORM 표준 JPA 프로그래밍 - 기본편 (김영한)>

Twitter Facebook LinkedIn