김경호

김경호

Slow but steady wins the race
2022.01 ~

느리더라도 꾸준하게…

[JPA] 자바 ORM 표준 JPA 프로그래밍 - 기본편 (객체지향 쿼리 언어1 - 기본 문법)


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

0. 객체지향 쿼리 언어 소개

  • JPA는 다양한 쿼리 방법을 지원한다.
    • JPQL : 실무에서는 대부분 JPQL로 해결 가능
    • JPA Criteria
    • QueryDSL
    • 네이티브 SQL
    • JDBC API 직접 사용, MyBatis, SpringJdbcTemplate
  • JPQL 소개
    • 가장 단순한 조회 방법
      • EntityManager.find()
      • 객체 그래프 탐색(a.getB().getC())
    • ex) 나이가 18살 이상인 회원을 모두 검색하고 싶다면?
      • 단순히 하나를 찍어서 가져올수 있는것이 아니다.
  • JPQL
    • JPA를 사용하면 엔티티 객체를 중심으로 개발
    • 문제는 검색 쿼리
    • 검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색
    • 모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능
    • 애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색 조건이 포함된 SQL이 필요
    • 위에 언급된 문제들을 해결하기 위해 JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어 제공
    • SQL과 문법 유사, SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN 지원
    • JPQL은 엔티티 객체를 대상으로 쿼리
    • SQL은 데이터베이스 테이블을 대상으로 쿼리
    • 테이블이 아닌 객체를 대상으로 검색하는 객체지향 쿼리
    • SQL을 추상화해서 특정 데이터베이스 SQL에 의존X
    • JPQL을 한마디로 정의하면 객체지향 SQL
    • JPQL은 단순 문자이기 때문에 동적 쿼리를 만들기 매우 어렵다.
//간단한 JPQL의 예
List<Member> result = em.createQuery(
                    "select m From Member m where m.age > 18",
                    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을 작성할 수 있음
    • 쿼리문에서 오타를 내도 컴파일 시점에서 잡아준다
    • JPQL 빌더 역할
    • JPA 공식 기능
    • 단점 : 너무 복잡하고 실용성이 없다.
      • 유지보수가 어려움
      • sql 같지가 않음
      • 디버깅을 못함
    • Criteria 대신에 QueryDSL 사용 권장
//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 소개
    • 문자가 아닌 자바코드로 JPQL을 작성할 수 있음
    • JPQL 빌더 역할
    • 컴파일 시점에 문법 오류를 찾을 수 있음
    • 동적쿼리 작성 편리함
    • 단순하고 쉬움
    • 실무 사용 권장
//JPQL
//select m from Member m where m.age > 18
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();
  • 네이티브 SQL 소개
    • JPA가 제공하는 SQL을 직접 사용하는 기능
    • JPQL로 해결할 수 없는 특정 데이터베이스에 의존적인 기능
    • 예) 오라클 CONNECT BY, 특정 DB만 사용하는 SQL 힌트
em.createNativeQuery("select MEMBER_ID, city, street, zipcode, USERNAME from MEMBER").getResultList();
  • JDBC 직접 사용, SpringJdbcTemplate 등
    • JPA를 사용하면서 JDBC 커넥션을 직접 사용하거나, 스프링 JdbcTemplate, MyBatis 등을 함께 사용 가능
    • 단 영속성 컨텍스트를 적절한 시점에 강제로 플러시 필요
    • 예) JPA를 우회해서 SQL을 실행하기 직전에 영속성 컨텍스트 수동 플러시

1. JPQL(Java Persistence Query Language)

기본 문법과 기능

  • JPQL 소개
    • JPQL은 객체지향 쿼리 언어다. 따라서 테이블을 대상으로 쿼리하는 것이 아니라 엔티티 객체를 대상으로 쿼리한다.
    • JPQL은 SQL을 추상화해서 특정데이터베이스 SQL에 의존하지 않는다.
    • JPQL은 결국 SQL로 변환된다.
  • JPQL 문법
    • select m from Member as m where m.age > 18 (Member는 테이블이 아닌 엔티티)
    • 엔티티와 속성은 대소문자 구문 O (Member, age)
    • JPQL 키워드는 대소문자 구분 X (SELECET, FROM, where)
    • 엔티티 이름 사용, 테이블 이름이 아님(Member)
    • 별칭은 필수(m) (as는 생략 가능)
select_문 :: =
  select_절
  from_절
  [where_절]
  [groupby_절]
  [having_절]
  [orderby_절]
update_문 :: = update_절 [where_절]
delete_문 :: = delete_절 [where_절]
  • 집합과 정렬
    • GROUP BY, HAVING 다 똑같이 사용하면 된다.
select
  COUNT(m), //회원수
  SUM(m.age), //나이 합
  AVG(m.age), //평균 나이
  MAX(m.age), //최대 나이
  MIN(m.age) //최소 나이
from Member m
  • 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"); //username은 String, age는 int라서 타입을 명기할 수 없다.
  • 결과 조회 API
    • query.getResultList() : 결과가 하나 이상일 때, 리스트 반환
      • 결과가 없으면 빈 리스트 반환
    • query.getStringResult() : 결과가 정확히 하나, 단일 객체 반환
      • 결과가 없으면 : javax.persistence.NoResultException
        • Spring Data JPA에서는 null을 반환
      • 둘 이상이면 : 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);

//-----------------------------------------------

TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m where m.username = :username", Member.class);
query.setParameter("username", "member1");
Member singleResult = query.getSingleResult();

위에처럼 쓰는것 보다 아래처럼 쓰는게 편하고 좋다.

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

결과 : result = member1

프로젝션(SELECT)

  • 프로젝션
    • SELECT 절에 조회할 대상을 지정하는것
    • 프로젝션 대상 : 엔티티, 임베디드 타입, 스칼라 타입(숫자, 문자등 기본 데이터 타입)
      • 관계형 데이터베이스는 select 에 스칼라 타입만 선택할 수 있다.
    • SELECT m FROM Member m -> 엔티티 프로젝션
    • SELECT m.team FROM Member m -> 엔티티 프로젝션
      • Member에 연관된 team을 가져옴
      • join이 사용된다.
      • join이 사용되면 성능에 어떠한 영향을 미치는지 알 수 없기때문에 최대한 sql문과 비슷하게 써야한다. (join을 최대한 명시)
      • ex) (SELECT t FROM Member m join m.team t, Team.class)
    • SELECT m.address FROM Member m -> 임베디드 타입 프로젝션
      • 어디 소속인지 확실하게 적어야함 (m.address)
    • SELECT m.username, m.age FROM Member m -> 스칼라 타입 프로젝션
    • DISTINCT로 중복 제거
Member member = new Member();
member.setUsername("member1");
member.setAge(10);
em.persist(member);

em.flush();
em.clear(); //영속성 컨텍스트 비우기

List<Member> result = em.createQuery("select m from Member m", Member.class)
          .getResultList(); //엔티티 프로젝션을 하면 select 절이 몇개가 나오든 영속성 컨텍스트에서 관리된다.

Member findMember = result.get(0);
findMember.setAge(20); //바뀌면 영속성 컨텍스트에서 관리 되는것이고 안바뀌면 관리가 안되는것이다.
  • 프로젝션 - 여러 값 조회
    • SELECT m.username, m.age FROM Member m
      1. Query 타입으로 조회
      1. Object[] 타입으로 조회
      1. new 명령어로 조회
        • 단순 값을 DTO로 바로 조회
          SELECT new jpabook.jpql.UserDTO(m.username, m.age) FROM Member m
        • 패키지 명을 포함한 전체 클래스 명 입력
        • 순서와 타입이 일치하는 생성자 필요
// 1.
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]); //Member1
System.out.println(result[1]); //10

// 2.
List<Object[]> resultList = em.createQuery("select m.username, m.age from Member m")
          .getResultList();

Object[] result = resultList.get(0);
System.out.println(result[0]); //Member1
System.out.println(result[1]); //10

// 3. 제일 깔끔한 방법, 많이 사용
List<Object[]> resultList = em.createQuery("select new jpql.MemberDTO(m.username, m.age) from Member m, MemberDTO.class")
          .getResultList(); //MemberDTO에 생성자 만들어야함, 생성자를 통해 호출됨

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

페이징

  • 페이징 API
    • JPA는 페이징을 다음 두 API로 추상화
    • setFirstResult(int startPosition) : 조회 시작 위치
    • setMaxResult(int maxResult) : 조회할 데이터 수
//페이징 쿼리
for(int i=0; i<100; i++){
  Member member = new Member();
  member.setUsername("member"+i);
  member.setAge(i);
  em.persist(member);
}

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

List<Member> resultList = em.createQuery("select m from Member m order by m.age desc", Member.class)
    .setFirstResult(1)
    .setMaxResults(10)
    .getResultList();
// username, age = member98 ~ 89

페이징 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 ?, ?

페이징 API - 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_ > ?

조인

  • 조인
    • 조인은 엔티티 중심으로 동작
    • 내부 조인 : team이 없으면 데이터가 아예 안나옴
      • SELECT m FROM Member m[INNER] JOIN m.team t
    • 외부 조인 : team이 없으면 team은 null로 나오고 Member가 조회됨
      • 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. 조인 대상 필터링
        1. 연관관계가 없는 엔티티 외부 조인(하이버네이트 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

Quiz

문제 1. 다음 예제들의 성공 여부를 쓰시오.

예제 1. select o.member.team
        from Order o

예제 2. select t.members from Team

예제 3. select t.members.username from Team t

예제 4. select m.username from Team t join t.members m
정답 확인


1. 성공


2. 성공


3. 실패


4. 성공


실패 이유 : 컬렉션에서는 더 들어가면 안된다. 명시적 조인을 통해 별칭을 얻어야한다.



태그:

카테고리:

업데이트:

댓글남기기

참고