스프링과 JPA를 이용한 웹개발_JPQL

🤔JPQL란?(Java Persistence Query Language)

• 객체지향 쿼리!
• JPQL은 테이블을 대상으로 쿼리를 생성하는 것이 아닌 엔티티 객체를 대상으로 쿼리를 생성
• JPQL로 실행한 쿼리도 결국 SQL로 변환되어 실행
• 따라서 실행되는 SQL 로깅하여 확인하는 작업이 필요
• JPA에서 관리되는 엔티티에 대한 SQL은 트랜잭션 커밋 시점이지만 JPQL은 즉시 실행 됨

JPA가 있는데도 JPQL을 사용해야하나요?

➡️JPA로는 데이터를 셀렉할 때 조건에 한계가 있기 때문에 JPQL을 사용해야 합니다!

Ex) 20대 이상인 남성 중에서, 구매를 2번 이상 한 고객들을 대상으로 데이터를 조회해야할 때

➡️즉, SQL관점에서 Where절이 필요한 순간에 JPQL을 사용하면 됩니다.

Selection

• Selection – The FROM clause
• FROM 절은 select 대상이 되는 엔티티를 지정하기 위해 사용

SELECT a FROM Author (AS) a

• AS는 생략 가능
• 위 예시에서 Author는 DB 테이블을 의미하는 것이 아닌 엔티티를 의미
• 반드시 별칭을 명시해야 함. 위 예시에서는 a에 해당
• persist가 INSERT문을 대신함

Types of JPA Queries: Query의 종류

• TypedQuery
  • 쿼리 실행의 결과로 반환될 타입을 알고 있을 때
  • 추가적인 형변환이 없고 유연하고 쉬운 테스트를 제공

➡️JPQL쿼리를 적고, UserEntity.class를 반환(=Return type)한다는 것을 명시해준다. 그리고 TypedQuery의 지네릭타입에 UserEntity를 지정해주면 된다!

+) 위의 JPQL은 사용자가 지정한 id값을 where절로 가져오겠다는 뜻.

•  NamedQuery
  • 엔티티에 실행될 JPQL과 그 이름을 명시하여 직관적으로 이해

➡️이름 그대로 name이 있는 쿼리라서 Query만 보면 읽기 전까지 어떤 쿼리인지 모르지만, name이 있으면 이해도 UP!!

• NativeQuery
  • 얘는 Native라는 이름처럼 그냥 SQL쿼리
  • 그렇기 때문에 JPQL의 구문에 제약 없이 대상 DB에 곧 바로 SQL실행가능
  • JPQL이나 JPA의 관리를 벗어나므로 이식성이 떨어질 수 있음
  • 그래서 NativeQuery는 최후의 수단으로 생각..!
    • NativeQuery 날렸는데도 기존 JPA보다 성능이 좋으면 JPA의 연관관계 등을 잘못 사용했다는 뜻이기도 하다

😶작성한 JPQL을 실행하려면 쿼리 객체를 만들어야 한다!

• 타입을 명시할 수 있을 때

TypedQuery<String> query = em.createQuery("SELECT p.name from Person p", String.class);
List<String> resultList = query.getResultList();

➡️p.name은 당연히 String타입으로 반환될 것이므로 반환 타입과 지네릭타입에 String.class를 적어주면 된다.

➕위 JPQL의 절은 SQL의 "SELECT NAME FROM PERSON"과 같다!

• 타입을 명시할 수 없을 때

Query query = em.createQuery("SELECT p.name, p.age from Person p");
List resultList = query.getResultList();
for(Object o: resultList){
    Object[] result = (Object[]) o; //결과가 둘 이상이면 Object[] 반환, 하나면 Object 반환
    System.out.println("name = " + result[0]);
    System.out.println("age = " + result[1]);
}

➡️p.name은 String이고 p.age는 int타입이기 때문에 이럴 경우에는 자바에서 최상위 계층인 Object를 반환한다!

    또한, 결과값이 두개 이상이기 때문에 List []으로 반환한다.

대표적인 JPQL의 기능 = "getResult"

• query.getResultList()
  • 결과가 하나 이상인 경우, 리스트를 반환
  • 결과가 없으면 null반환
• query.getSingleResult()
  • 일치하는 하나의 엔티티를 반환
  • 결과가 없거나 한 개를 초과하면 예외 발생
    • 스프링 데이터 JPA에서는 한 개를 초과할 때 null 반환

➡️getSingleResult가 조금 더 엄격하다고 볼 수 있음!

예제 : 반환 타입을 알 때

@Entity
public class Person {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "PERSON_ID")
    private int id;

    private String name;
    private int age;

    @OneToMany(mappedBy = "person", cascade = CascadeType.REMOVE)
    private List<Address> addresses = new ArrayList<Address>();
...

@Entity
public class Address {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String street;
    private String city;
    private String zipCode;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "PERSON_ID")
    private Person person;
    
   ...

package study;

import javax.persistence.*;
import java.util.List;

public class Main {
    public static void main(String[] args){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("playground");
        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();

        try{
            tx.begin();
            Address address1 = new Address();
            address1.setCity("city1");
            address1.setStreet("street1");
            address1.setZipCode("zipCode1");

            Address address2 = new Address();
            address2.setCity("city1");
            address2.setStreet("street1");
            address2.setZipCode("zipCode1");

            Person person = new Person();
            person.setName("kim");
            person.setAge(20);

            address1.setPerson(person); //연관관계 주입
            address2.setPerson(person);

            person.getAddresses().add(address1);
            person.getAddresses().add(address2);

            em.persist(person);
            em.persist(address1);
            em.persist(address2);

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

			----여기서부터 JPQL쿼리!!-----
            TypedQuery<Person> query =
                    em.createQuery("SELECT p FROM Person AS p", Person.class);

            List<Person> resultList = query.getResultList();
            resultList.stream().forEach(v-> System.out.println("v = " + v));

            tx.commit();
        }catch (Exception e){
            tx.rollback();
        }finally {
            em.close();
        }
    }
}

➡️실행하면 addresses 값이 이상하게 나오는데, 이는 Person에서 @OneToMany가 fetch의 기본 값이 LAZY이기 때문!

응용version : 반환 타입을 모를 때

Query query = em.createQuery(("SELECT p.name, p.age FROM Person p"));
            List resultList = query.getResultList();
            for(Object o:resultList){
                Object[] result = (Object[]) o;
                System.out.println("result[0]= " + result[0]);
                System.out.println("result[1]= " + result[1]);
            }

➡️반환타입을 모를 경우 return 타입을 지정해주지 않고 최상위 계층인 Object를 사용하는 것이 큰 차이점이다!

➕List 타입이 저장될 때는 [kim, 20] 이런 식으로 저장된다!