객체지향 쿼리 언어

1) 소개

• JPQL : 표준문법
• JPA Criteria : JPQL을 기반으로 자바 코드로 짜서 빌드해주는 제너레이터 클래스의 모음
• QueryDSL : JPQL을 기반으로 자바 코드로 짜서 빌드해주는 제너레이터 클래스의 모음
• 네이티브 SQL : JPA를 써도 표준문법을 벗어나거나 종속적인 코드가 나올 때 사용한다.
• JDBC API 직접사용, MyBatis, SpringJdbcTemplate 함께 사용:
  JPA를 써도 표준문법을 벗어나거나 종속적인 코드가 나올 때 사용한다.

실무에서 거의 대부분이 JPA로 해결이 가능하고 나머지를 나는 MyBatis등으로 사용하면 좋을 거 같다.
단 영속성 컨텍스트를 적절한 시점에 강제로 플러시 필요, JPA만 인식할 수 있는 영역에서 DB영역으로 보내야
함께 조화를 이룰 수 있음.

JPQL이 왜 필요한가?

• JPA를 사용하면 엔티티 객체를 중심으로 개발한다.
• 문제는 검색 쿼리
• 검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색
• 모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능(성능문제 등등)
• 애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색 조건이 포함된 SQL이 필요

JPQL에 대해

• JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어 제공
• SQL과 문법 유사하고 ANSI표준에 지원하는 표준 문법은 거의 지원
  (SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN 지원)
• JPQL은 엔티티 객체를 대상으로 쿼리, SQL은 데이터베이스 테이블을 대상으로 쿼리
  (테이블이 아닌 객체를 대상으로 검색하는 객체 지향 쿼리)
• SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않는다.
  (JPQL을 한마디로 정의하면 객체 지향 SQL)
• JPQL은 결국 SQL로 변환된다.

Criteria에 대해

결론적으로 단점은 너무 복잡해서 유지보수가 어렵고 실용성이 없다.
따라서 동적쿼리에 대해서 Criteria 대신에 QueryDSL 사용 권장. 한 마디로 망한 스펙.

• 문자가 아닌 자바코드로 JPQL을 작성할 수 있음
• JPA의 공식기능이자 JPQL 빌더 역할
• 메소드 체인방식으로 쿼리에 대한 메소드를 제공함

//Criteria 사용 준비
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Member> query = cb.createQuery(Member.class);

//루트 클래스 (조회를 시작할 클래스)
Root<Member> m = query.from(Member.class);

//쿼리 생성 CriteriaQuery<Member> cq =
query.select(m).where(cb.equal(m.get("username"), “kim”));
List<Member> resultList = em.createQuery(cq).getResultList();

QueryDSL에 대해

JPAFactoryQuery query = new JPAQueryFactory(em);
 QMember m = QMember.member;

 List<Member> list =
    query.selectFrom(m)
       .where(m.age.gt(18))
       .orderBy(m.name.desc())
       .fetch();

• 문자가 아닌 자바코드로 JPQL을 작성할 수 있음(동적쿼리 작성 가능)
• JPQL 빌더 역할(쉽게 만들 수 있게 하는 역할)
• 컴파일 시점에 문법 오류를 찾을 수 있음
• 동적쿼리 작성 편리! 단순하고 쉬움! 실무 사용 권장!

  자세히는 따로 강의 듣고 ㄱㄱ 결국 JPQL이 기본이다.

2) JPQL 기본 문법

select m from Member as m where m.age > 18

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

설계 토대로 예시들거임

기본적으로 sql 문법하고 동일하다.

select_문 :: =
 select_절
 from_절
 [where_절]
 [groupby_절]
 [having_절]
 [orderby_절]

update_문 :: = update_절 [where_절]

delete_문 :: = delete_절 [where_절]

집합과 정렬

• COUNT(m) : 회원수
• SUM(m.age) : 나이 합
• AVG(m.age) : 평균 나이
• MAX(m.age) : 최대 나이
• MIN(m.age) : 최소 나이
• GROUP BY, HAVING
• ORDER BY

TypeQuery, Query

• TypeQuery: 반환 타입이 명확할 때 사용
• Query: 반환 타입이 명확하지 않을 때 사용(이거 저거 타입 섞여 있을 때 )

TypedQuery<Member> query =
 em.createQuery("SELECT m FROM Member m", Member.class); 

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

결과 조회 API

• query.getResultList(): 결과가 하나 이상일 때, 리스트 반환
  (결과가 없으면 빈 리스트 반환)
• query.getSingleResult(): 결과가 정확히 하나, 단일 객체 반환 (where 조건에 m.id = 10 같은 경우)
  (결과가 없으면: javax.persistence.NoResultException => 스프링 데이터 JPA에서 추상화된 함수를 제공, 나중에 강의듣자)
  (둘 이상이면: 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);

JPQL에서는 2가지 기준으로 매개변수를 지원하는데,
위치 기준으로 받을 시 중간에 값 하나만 끼워 넣어도 다 뒤틀리니까 이름 기준으로만 받는다.

프로젝션

JPQL문 안에 들어간 엔티티는 모두 영속성 컨텍스트에서 관리된다.

• SELECT 절에 조회할 대상을 지정하는 것
• DB sql은 그냥 데이터만 찍으면 되지만 JPQL은 엔티티, 임베디드 타입, 스칼라 타입(숫자, 문자등 기본 데이터 타입) 등의 다양한 대상이 있기 때문에

SELECT m FROM Member m -> 엔티티 프로젝션

SELECT m.team FROM Member m  -> 엔티티 프로젝션 // 이렇게 하지마라! 조인되는게 예측이 안된다. 
SELECT t FROM Member m join m.team t -> 엔티티 프로젝션 // 이렇게 하라

SELECT m.address FROM Member m -> 임베디드 타입 프로젝션(임베디드만으로는 안되고 엔티티소속으로 해야함)
SELECT m.username, m.age FROM Member m -> 스칼라 타입 프로젝션

• DISTINCT로 중복 제거가능

프로젝션 - 여러 값 조회

SELECT m.username, m.age FROM Member m

• 방법1. Query 타입 조회
• 방법2. Object 타입 조회
• 방법3. new명령어로 DTO와 생성자를 이용해 조회

// 패키지 명을 포함한 전체 클래스 명 입력 해야함
// 순서와 타입이 일치하는 생성자 필요하다.
List<MemberDTO> result = em.createQuery("select new 패키지명.MemberDTO(m.username, m.age)",MemberDTO)

페이징 API

MySQL 방언 페이징

SELECT
      M.ID AS ID,
      M.AGE AS AGE,
      M.TEAM_ID AS TEAM_ID,
      M.NAME AS NAME
FROM
      MEMBER M
ORDER BY
      M.NAME DESC LIMIT ?, ?

Oracle 방언 페이징

SELECT * FROM
      ( SELECT ROW_.*, ROWNUM ROWNUM_
      FROM
           ( SELECT
                M.ID AS ID,
                M.AGE AS AGE,
                M.TEAM_ID AS TEAM_ID,
                M.NAME AS NAME
           FROM MEMBER M
           ORDER BY M.NAME
           ) ROW_
      WHERE ROWNUM <= ?
      )
WHERE ROWNUM_ > ?

• JPA에서 oracle DB는 페이징이 그지같다.
  ( https://velog.io/@koo9b9h/103104%EC%9D%BC%EC%B0%A8-Spring-%EA%B2%8C%EC%8B%9C%ED%8C%90-%ED%8E%98%EC%9D%B4%EC%A7%95%EC%B2%98%EB%A6%AC ..오라클 페이징처리 생각보다 나쁘지 않았는데 )

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에 Member 기본키에 해당값 없으면 null넣어서 합친다.
  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. 조인 대상 필터링
     - 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. 연관관계 없는 엔티티 외부 조인(하이버네이트 5.1부터)
     아무 연관관계가 없어도 조인 할 수 있다.
     예) 회원과 팀을 조인하면서, 팀 이름이 A인 팀만 조인
     - 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 서브 쿼리 한계

• JPA는 WHERE, HAVING 절에서만 서브 쿼리 사용 가능
• SELECT 절도 가능(하이버네이트에서 지원)
• FROM 절의 서브 쿼리는 현재 JPQL에서 불가능 (조인으로 풀 수 있으면 풀어서 해결)
  (FROM절을 sql로직에서 하지말고 최대한 풀어서 애플리케이션영역에서 해결할 수 있도록 해보자)

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

기타식 (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

• 단순 CASE 식

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

• COALESCE: 하나씩 조회해서 null이 아니면 반환

사용자 이름이 없으면 이름 없는 회원을 반환
select coalesce(m.username,'이름 없는 회원') from Member m

• NULLIF: 두 값이 같으면 null 반환, 다르면 첫번째 값 반환

사용자 이름이 ‘관리자’면 null을 반환하고 나머지는 본인의 이름을 반환
select NULLIF(m.username, '관리자') from Member m

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

• https://devraphy.tistory.com/m/599 관련 내용들을 찾아보다가 정리 잘되어있는 블로그 찾음

JPQL 기본함수 = 보통 sql에서 제공하는 함수와 거의 같다.

• https://velog.io/@jhp1115/JPQL-%EA%B8%B0%EB%B3%B8%ED%95%A8%EC%88%98 참고
• CONCAT : 문자열 합치기
• SUBSTRING : 문자열 자르기
• TRIM : 공백 제거
• LOWER, UPPER : 소문자 대문자 변경
• LENGTH : 길이 반환
• LOCATE : 문자의 위치
• ABS, SQRT, MOD : 절대값, 제곱근, 나머지
• (JPA 용도)SIZE : 컬렉션 크기 , INDEX : LIST 타입 컬렉션 위치값 구하기 (@OrderColunm이랑 같이 사용하는데 거의 사용하지 않는 거 추천)

사용자 정의 함수에 대한 강의에서 중점적인 내용

• 특정 DB에서 제공하는 함수를 JPA에서 사용하기 위해서는 사용자 정의 함수를 사용한다.
• 사용자 함수 설정을 하기위한 DB방언을 상속 받은 클래스가 필요하다.
• persistence 설정 파일에서 DB를 상속받은 클래스의 경로로 적용 시켜야한다.
• 사용: select function('group_concat', i.name) from Item i