🍕 Reference

자바 ORM 표준 JPA 프로그래밍 : 교보문고
자바 ORM 표준 JPA 프로그래밍 - 기본편 : 인프런

JPQL

Java Persistence Query Language

JPA 에서 제공하는 SQL 을 추상화한 객체지향 쿼리 언어


테이블 대상이 아닌 객체 대상으로 쿼리를 작성한다.
SQL 과 유사하다.

• SELECT
• FROM
• WHERE
• GROUP BY
• HAVING
• JOIN
  등을 지원 한다.
  
  JPA COMMMIT 시점에 SQL Query 로 변환되어 DB 에 적용된다.

장점

1. 객체 중심으로 작성하기 때문에 DB 에 의존적이지 않다.
2. ANSI 표준 SQL 대부분을 지원한다.
3. 객체를 조회하기 때문에 재사용성과 유지보수에 좋다.

단점

1. 쿼리작성을 문자열로 하기 때문에 Compile 시점에서 문제를 파악하기 힘들다.
2. 동적으로 쿼리를 작성하기 힘들다.
3. 조인, 그룹화, 정렬과 같은 고급 기능에서 자체적인 문법을 사용하여 Learning Curve 존재

사용방법

Member

@Entity
public class Member
{
    @Id @GeneratedValue
    private Long id;
    private String username;

    private int age;

1.특징

Entity , property 는 대소문자 구별을 한다.
Entity 와 Table 이름은 같지 않다. ->Entity 이름 써야한다.
별칭은 필수다.

2.TypedQuery vs Query 타입

TypedQuery : JPQL 결과 타입이 정해졌을때,
TypedQuery : JPQL 결과 타입이 정해지지 않을 때,

JPQL 결과 타입이 정해졌을때

QUERY

select m from Member m
select m.username from Member m
---
TypedQuery<Member> query1 = em.createQuery("select m from Member m", Member.class);

Return Type 이 Memeber 타입 ( Entity ) 혹은 단일한 값 타입인 경우 사용

JPQL 결과 타입이 정해졌을때

QUERY

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

Return Type 이 다음과 같이 문자열과 정수 두개로 받을때와 같이
어느 특정 타입이라고 정하기 어려운 상태에서 사용한다.

3. getResultList() vs getSingleResult()

document

쿼리 결과 개수에 따라서 사용하는 메소드가 달라진다

1.getResultList()

• 반환하는 결과 개수가 복수 일때 사용
• return 값이 List
• Query 결과값이 존재하지 않으면 크기가 0 인 빈 List 를 반환
  main

        try
        {
//            Member member = new Member();
//            member.setUsername("member1");
//            member.setAge(20);
//            em.persist(member);
            TypedQuery<Member> query1 = em.createQuery("select m from Member m", Member.class);
            List<Member> memberList = query1.getResultList();
            System.out.println(memberList.size());
            for (Member member1 : memberList) {
                System.out.println("memberList.size() : "+memberList.size());
            }

result

Hibernate: 
    /* select
        m 
    from
        Member m */ select
            member0_.id as id1_0_,
            member0_.age as age2_0_,
            member0_.TEAM_ID as TEAM_ID4_0_,
            member0_.username as username3_0_ 
        from
            Member member0_
memberList.size() : 0

• 아무것도 조회되지 않을 경우 크기가 0 인 List를 반환하는 것을 볼 수 있다.

2. getSingleResult()

• 단일 결과가 반환 시 사용한다.
• 결과가 복수이면 예외 발생 ( NonUniqueResultException )
  Member 2개 생성 후 전체 조회

       try
        {
            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            em.persist(member);
            Member member2 = new Member();
            member2.setUsername("member1");
            member2.setAge(20);
            em.persist(member2);
            em.flush();
            em.clear();
            TypedQuery<Member> query1 = em.createQuery("select m from Member m", Member.class);
            Member findMember = query1.getSingleResult();

결과

javax.persistence.NonUniqueResultException: query did not return a unique result: 2
	at org.hibernate.internal.ExceptionConverterImpl.convert(ExceptionConverterImpl.java:128)
	at org.hibernate.query.internal.AbstractProducedQuery.getSingleResult(AbstractProducedQuery.java:1560)
	at org.example.main.getResultListT.main(getResultListT.java:33)

• 결과가 존재하지 않으면 예외 발생 ( NoResultException )
  Member 생성 하지 않고 조회

       try
        {
            Member member = new Member();
//            member.setUsername("member1");
//            member.setAge(20);
//            em.persist(member);
//
//            Member member2 = new Member();
//            member2.setUsername("member1");
//            member2.setAge(20);
//            em.persist(member2);
            em.flush();
            em.clear();
            TypedQuery<Member> query1 = em.createQuery("select m from Member m", Member.class);
            Member findMember = query1.getSingleResult();

결과

javax.persistence.NoResultException: No entity found for query
	at org.hibernate.query.internal.AbstractProducedQuery.getSingleResult(AbstractProducedQuery.java:1555)
	at org.example.main.getResultListT.main(getResultListT.java:33)

결과가 존재하지 않을 수도 있는데 예외가 발생하는 것은 문제가 있다.
예외처리를 해주어야 한다.

4. Parameter Binding ( 이름 vs 위치 )

이름 바인딩

Main

        try
        {
            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            em.persist(member);

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

            TypedQuery<Member> query1 = em.createQuery("select m from Member m where m.username = :username", Member.class);
            query1.setParameter("username","member1");
            List<Member> members = query1.getResultList();

            for (Member member1 : members) {
                System.out.println("name : "+member1.getUsername());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m 
    where
        m.username = :username */ select
            member0_.id as id1_0_,
            member0_.age as age2_0_,
            member0_.TEAM_ID as TEAM_ID4_0_,
            member0_.username as username3_0_ 
        from
            Member member0_ 
        where
            member0_.username=?
name : member1

위치 바인딩

Main

        try
        {
            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            em.persist(member);

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

            TypedQuery<Member> query1 = em.createQuery("select m from Member m where m.username = ?1", Member.class);
            query1.setParameter(1,"member1");
            List<Member> members = query1.getResultList();

            for (Member member1 : members) {
                System.out.println("name : "+member1.getUsername());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m 
    where
        m.username = :username */ select
            member0_.id as id1_0_,
            member0_.age as age2_0_,
            member0_.TEAM_ID as TEAM_ID4_0_,
            member0_.username as username3_0_ 
        from
            Member member0_ 
        where
            member0_.username=?
name : member1

Parameter 바인딩을 통해 JPQL 역시 동적인 쿼리를 작성할 수 있다.
여기서 이름 으로 바인딩 하는 방법 위치로 바인딩 하는 방법 2가지로 나뉜다.
이름으로 바인딩 할 경우 Parameter 처럼 사용이 가능하다.
위치로 바인딩 할 경우 역시 Parameter 처럼 사용이 가능하지만, 위치 변경 시 유지보수에 어려움이 있기 때문에 가급적이면 이름 으로 바인딩 하는 것이 좋다.

프로젝션

SELECT 절에 조회할 대상을 지정하는 것을 말한다.

Member

@Entity
public class Member
{
    @Id @GeneratedValue
    private Long id;
    private String username;

    private int age;

    @ManyToOne(fetch = FetchType.LAZY )
    @JoinColumn(name = "TEAM_ID")
    private Team team;

    @Embedded
    private Address address;

Team

@Entity
public class Team
{
    @Id @GeneratedValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();

Address

@Embeddable
public class Address
{
    public Address(){}
    public Address(String city, String street, String zipcode)
    {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }

    private String city;
    private String street;
    private String zipcode;

1. 전체 속성 조회

select m from Member m

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

            List<Member> members = em.createQuery("select m from Member m").getResultList();

            for (Member member1 : members) {
                System.out.println("name : "+member1.getUsername());
                member1.setAge(12);
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m */ select
            member0_.id as id1_0_,
            member0_.city as city2_0_,
            member0_.street as street3_0_,
            member0_.zipcode as zipcode4_0_,
            member0_.age as age5_0_,
            member0_.TEAM_ID as TEAM_ID7_0_,
            member0_.username as username6_0_ 
        from
            Member member0_
Hibernate: 
    select
        team0_.id as id1_3_0_,
        team0_.name as name2_3_0_ 
    from
        Team team0_ 
    where
        team0_.id=?
name : member1
Hibernate: 
    /* update
        org.example.entity.Member */ update
            Member 
        set
            city=?,
            street=?,
            zipcode=?,
            age=?,
            TEAM_ID=?,
            username=? 
        where
            id=?

Member 안의 모든 필드들을 조회 했으며, 조회 결과의 Member 들은 모두 영속성 Context 에서 관리 된다.
( member1.setAge(12); 했을 때 Update Query 발생 )

2. 연관관계 속성 조회

select m.team from Member m

            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

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

            for (Team team1 : teams) {
                System.out.println("name : "+team1.getName());
            }

결과

Hibernate: 
    /* select
        m.team 
    from
        Member m */ select
            team1_.id as id1_3_,
            team1_.name as name2_3_ 
        from
            Member member0_ 
        inner join
            Team team1_ 
                on member0_.TEAM_ID=team1_.id
name : A

Member 와 연관관계인 Team 을 조회 했다. 객체 타입을 Team 으로 두어야 하며
Query 발생 시 JOIN 이 자동으로 발생한다. 사용자 입장에서 JOIN 쿼리 가나가는 것을 인지 시키기 위해서 연관관계 조회 시엔 명시적으로 JOIN 쿼리를 작성한다.

select m.team from Member m Join m.team t

3. Embedded Type 조회

select m.address from Member m

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

                List<Address> addresses = em.createQuery("select m.address from Member m", Address.class).getResultList();

            for (Address adr : addresses) {
                System.out.println("name : "+adr.getCity());
            }

결과

Hibernate: 
    /* select
        m.address 
    from
        Member m */ select
            member0_.city as col_0_0_,
            member0_.street as col_0_1_,
            member0_.zipcode as col_0_2_ 
        from
            Member member0_
name : 1

Member 의 Embedded 타입을 조회

4. Scala 타입 조회

select m.username, m.age from Member m

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member1");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

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

결과

Hibernate: 
    /* select
        m.username,
        m.age 
    from
        Member m */ select
            member0_.username as col_0_0_,
            member0_.age as col_1_0_ 
        from
            Member member0_

Member 다른 타입들을 조회, 즉 결과가 Query 타입 이다.

• Object 를 반환

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

결과

Hibernate: 
    /* select
        m.username,
        m.age 
    from
        Member m */ select
            member0_.username as col_0_0_,
            member0_.age as col_1_0_ 
        from
            Member member0_
result = member1
result = 20

• DTO 를 설정해서 값을 받을 수 있다.
  DTO 정의

public class NameAgeDto
{
    private  String username;
    private  int    age;
    public NameAgeDto(){}
    public NameAgeDto(String username, int age)
    {
        this.username = username;
        this.age      = age;
    }

main

            List<NameAgeDto> scala = em.createQuery("select new org.example.dto.NameAgeDto(m.username, m.age) from Member m",NameAgeDto.class).getResultList();
            NameAgeDto nameAgeDto = scala.get(0);
            System.out.println("nameAgeDto.getUsername() = "+nameAgeDto.getUsername());
            System.out.println("nameAgeDto.getAge() = "+nameAgeDto.getAge());

결과

Hibernate: 
    /* select
        new org.example.dto.NameAgeDto(m.username,
        m.age) 
    from
        Member m */ select
            member0_.username as col_0_0_,
            member0_.age as col_1_0_ 
        from
            Member member0_
nameAgeDto.getUsername() = member1
nameAgeDto.getAge() = 20

select new org.example.dto.NameAgeDto(m.username, m.age) from Member m

• 새로운 데이터 타입을 정의하고
• 순서와 타입이 일치하는 데이터 타입 생성자를 정의
• 데이터 타입의 경로를 포함한 생성자를 기재하면
  다음과 같이 데이터 타입으로 데이터를 얻을 수 있는 것을 볼 수 있다.

페이징 ( setFirstResult , setMaxResult )

• 생각보다 직관적인 API 를 사용

  setFirstResult : 몇번째 부터 가져올 것인지
  setMaxResult : 몇번째 까지 가져올 것인지

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            for(int i = 0; i< 20; i++)
            {
                Member member = new Member();
                member.setUsername("member"+i);
                member.setAge(20+i);
                member.setTeam(team);
                member.setAddress(address);
                em.persist(member);
            }

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

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

            System.out.println("members.size() : "+members.size());
            for (Member member : members) {
                System.out.println("member.getAge() : "+member.getAge());
            }

결과

Hibernate: 
    select
        team0_.id as id1_3_0_,
        team0_.name as name2_3_0_ 
    from
        Team team0_ 
    where
        team0_.id=?
members.size() : 10
member.getAge() : 39
member.getAge() : 38
member.getAge() : 37
member.getAge() : 36
member.getAge() : 35
member.getAge() : 34
member.getAge() : 33
member.getAge() : 32
member.getAge() : 31
member.getAge() : 30

Member의 크기가 10 이고, age 가 큰 Member 부터
내림 차순으로 10 개의 Member 의 나이를 출력 하는 것을 볼 수 있다.

• JPA 는 DB DIALECT에 따라 PAGINING 처리를 다르게 할 수 있다.

JOIN

1. Inner Join

select m from Member m inner join m.team t

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

            String query = "select m from Member m inner join m.team t";
            List<Member> members = em.createQuery(query).getResultList();

            for (Member member1 : members) {
                System.out.println(member1.toString());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m 
    inner join
        m.team t */ select
            member0_.id as id1_0_,
            member0_.city as city2_0_,
            member0_.street as street3_0_,
            member0_.zipcode as zipcode4_0_,
            member0_.age as age5_0_,
            member0_.TEAM_ID as TEAM_ID7_0_,
            member0_.username as username6_0_ 
        from
            Member member0_ 
        inner join
            Team team1_ 
                on member0_.TEAM_ID=team1_.id
Member{id=2, username='member', age=20, address=org.example.entity.Address@45e9b12d}

2. Outer Join

select m from Member m left outer join m.team t

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

            String query = "select m from Member m left outer join m.team t";
            List<Member> members = em.createQuery(query).getResultList();

            for (Member member1 : members) {
                System.out.println(member1.toString());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m 
    left outer join
        m.team t */ select
            member0_.id as id1_0_,
            member0_.city as city2_0_,
            member0_.street as street3_0_,
            member0_.zipcode as zipcode4_0_,
            member0_.age as age5_0_,
            member0_.TEAM_ID as TEAM_ID7_0_,
            member0_.username as username6_0_ 
        from
            Member member0_ 
        left outer join
            Team team1_ 
                on member0_.TEAM_ID=team1_.id
Member{id=2, username='member', age=20, address=org.example.entity.Address@45e9b12d}

3. Setter Join

select m from Member m, Team t where m.username = t.name

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

            String query = "select m from Member m, Team t where m.username = t.name";
            List<Member> members = em.createQuery(query).getResultList();

            for (Member member1 : members) {
                System.out.println(member1.toString());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m,
        Team t 
    where
        m.username = t.name */ select
            member0_.id as id1_0_,
            member0_.city as city2_0_,
            member0_.street as street3_0_,
            member0_.zipcode as zipcode4_0_,
            member0_.age as age5_0_,
            member0_.TEAM_ID as TEAM_ID7_0_,
            member0_.username as username6_0_ 
        from
            Member member0_ cross 
        join
            Team team1_ 
        where
            member0_.username=team1_.name

JOIN-ON

Join 을 필터링 할 수 있는 ON 조건 절을 사용할 수 있다.
select m from Member m left outer join m.team t on t.name = 'A'

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

            String query = "select m from Member m left outer join m.team t on t.name = 'A'";
            List<Member> members = em.createQuery(query).getResultList();

            for (Member member1 : members) {
                System.out.println(member1.toString());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m 
    left outer join
        m.team t 
            on t.name = 'A' */ select
                member0_.id as id1_0_,
                member0_.city as city2_0_,
                member0_.street as street3_0_,
                member0_.zipcode as zipcode4_0_,
                member0_.age as age5_0_,
                member0_.TEAM_ID as TEAM_ID7_0_,
                member0_.username as username6_0_ 
        from
            Member member0_ 
        left outer join
            Team team1_ 
                on member0_.TEAM_ID=team1_.id 
                and (
                    team1_.name='A'
                )
Member{id=2, username='member', age=20, address=org.example.entity.Address@3bc4ef12}

연관관계 없는 JOIN

select m from Member m left join Team t on m.username = t.name

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            em.persist(member);

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

            String query = "select m from Member m left join Team t on m.username = t.name";
            List<Member> members = em.createQuery(query).getResultList();

            for (Member member1 : members) {
                System.out.println(member1.toString());
            }

결과

Hibernate: 
    /* select
        m 
    from
        Member m 
    left join
        Team t 
            on m.username = t.name */ select
                member0_.id as id1_0_,
                member0_.city as city2_0_,
                member0_.street as street3_0_,
                member0_.zipcode as zipcode4_0_,
                member0_.age as age5_0_,
                member0_.TEAM_ID as TEAM_ID7_0_,
                member0_.username as username6_0_ 
        from
            Member member0_ 
        left outer join
            Team team1_ 
                on (
                    member0_.username=team1_.name
                )
Member{id=2, username='member', age=20, address=org.example.entity.Address@37ad042b}

SUB QUERY

일반적인 SQL 에서 지원하는 SUB QUERY 를 지원한다.
여러가지 지원함수와 같이 사용 할 수 있다.

JPQL 타입 표현

• 문자 : 'a'
• 숫자 : 1L, 1D, 1F
• 불린 : TRUE, FALSE
• ENUM : 패키지명 포함

ENUM TYPE

select m.username, m.memberType from Member m where m.memberType = :userType

public enum MemberType {
    ADMIN,USER;
}

Member

@Entity
public class Member
{
    @Id @GeneratedValue
    private Long id;
    private String username;

    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "TEAM_ID")
    private Team team;

    @Embedded
    private Address address;
    
    @Enumerated(EnumType.STRING)
    private MemberType memberType;

main

        try
        {
            Address address = new Address("1","1","1");

            Team team = new Team();
            team.setName("A");
            em.persist(team);

            Member member = new Member();
            member.setUsername("member");
            member.setAge(20);
            member.setTeam(team);
            member.setAddress(address);
            member.setMemberType(MemberType.ADMIN);
            em.persist(member);

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

            String query = "select m.username, m.memberType from Member m where m.memberType = :userType";
            List<Object[]> result = em.createQuery(query)
                    .setParameter("userType",MemberType.ADMIN)
                    .getResultList();

            System.out.println(result.get(0)[0]);
            System.out.println(result.get(0)[1]);

결과

Hibernate: 
    /* select
        m.username,
        m.memberType 
    from
        Member m 
    where
        m.memberType = :userType */ select
            member0_.username as col_0_0_,
            member0_.memberType as col_1_0_ 
        from
            Member member0_ 
        where
            member0_.memberType=?

Parameter Binding 과 함께 사용하였다.