[JPA] 객체지향쿼리

JPQL

JPQL은 엔티티 객체를 조회하는 객체지향 쿼리다.
JPQL은 SQL을 추상화해서 특정 데이터베이스에 의존하지 않으며, SQL에 비해 간결하다.

@Entity(name="MEMBER")
public class Member{
    @Column(name="name")
    private String username;
}

//사용

String jpql = "select m from Member as m where m.username = "kim"
List<Member> resultList = 
        em.createQuery(jpql, Member.class).getResultList();

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

TypeQuery와 Query가 있는데 반환할 타입을 명확하게 지정할 수 있으면 TypeQuery객체를 사용하고 명확하게 지정할 수 없으면 Query 객체를 사용하면 된다.

//Type Query사용
TypeQuery<Member> query = em.createQuery("SELECT m FROM Member m", Member.class);
for(Member member : resultList)({
    System.out.println("member = " + member);
})

// Query사용
Query query = em.createQuery("SELECT m.username, m.age from Member m");
for(Object o : resultList)({
    Object[] result = (Object[]) o; //결과가 둘 이상이면 Object[]반환
})

SELECT 절에서 여러 엔티티나 컬럼을 선택할 때는 반환할 타입이 명확하지 않으므로 Query 객체를 사용해야 한다.

결과조회

query.getResultList() : 결과를 예제로 반환한다. 만약 결과가 없으면
빈 컬렉션을 반환한다.
query.getStringResult(): 결과가 정확히 하나일 때 사용한다.

-결과가 없으면 NoResultException 예외가 발생한다.

-결과가 1개보다 많으면 NonUniqueResultException예외가 발생

파라미터 바인딩

-이름 기준 파라미터:

String usernameParam = "User1";

TypeQuery<Member> query = em.createQuery("SELECT m FROM Member m where m.username = :username",Member.class);

query.setParameter("username", usernameParam);
List<Member> resultList = query.getResultList();

-위치 기준 파라미터

List<Member> members = 
                em.createQuery("SELECT m FROm Member m where m.username =?1", Member.class)
                    .setParameter(1, usernameParam)
                    .getResultList();

프로젝션

SELECT 절에 조회할 대상을 지정하는 것을 프로젝션이라 한다.

프로젝션 대상은 엔티티, 엠비디드타입, 스칼라 타입이 있다.

-임베디드 타입 프로젝션

임베디드 타입은 조회의 시작점이 될 수 없다는 제약이 있다.

String query = "SELECT o.address FROM Order o ";
List<Address> addresses = em.createQuery(query,Address.class).getResultList();

임베디드 타입은 엔티티 타입이 아닌 값 타입이다. 따라서 이렇게 직접 조회한 임베디드 타입은 영속성 컨텍스트에서 관리되지 않는다.

-스칼라 타입 프로젝션

숫자, 문자 날짜와 같은 기본 데이터 타입들을 스칼라 타입이라 한다.

List<String> usernames = em.createQuery("select username FROM Member m ", String.class).getResultList();

중복 데이터를 제거하려면 DISTINCT를 사용한다.

-여러 값 조회

꼭 필요한 데이터들만 선택해서 조회할때 사용한다. 프로젝션에 여러 값을 선택하면 TypeQuery를 사용할 수 없고 대신에 Query를 사용해야 한다.

Query query = em.createQuery("SELECT m.username, m.age FROM Member m ");
List resultList = query.getResultList();

Iterator iterator = resultList.iterator();
while(iterator.hasNext()){
    Object[] row = (Object[]) iterator.next();
    String username = (String) row[0];
    Integer age = (Integer) row[1];
}

List<Object[]> resultList = 
Qem.createQuery("SELECT m.username, m.age FROM Member m ");
List resultList = query.getResultList();

Iterator iterator = resultList.iterator();
while(iterator.hasNext()){
    Object[] row = (Object[]) iterator.next();
    String username = (String) row[0];
    Integer age = (Integer) row[1];
}

-NEW 명령어

패키지 명을 포함한 전체 클래스 명을 입력해야 한다.
순서와 타입이 일치하는 생성자가 필요하다.

TypedQuery<UserDTO> query = em.createQuery("SELECT new jpabook.jpql.UserDTO(m.username, m.age) FROM Member m", UserDTO.class);
List<UserDTO> resultList = query.getResultList();

List<UserDTO> resultList = query.getResultList();

페이징 API

setFirstResult(int startPosition): 조회 시작 위치(0부터 시작한다)
setMaxResults(int maxResult): 조회할 데이터 수

TypeQuery<Member> query = em.createQuery("SELECT m FROM Member m ORDER BY m.username DESC"), Member.class);
query.setFirstResult(10);
query.setMaxResult(20);
query.getResultList();

-페치 조인

페치 조인은 JPQL에서 성능 최적화를 위해 제공하는 기능이다.
이것은 연관된 엔티티나 컬렉션을 한 번에 같이 조회하는 기능인데
join fetch 명령어로 사용할 수 있다.

엔티티 페치 조인

String jpql = "select m from Member m join fetch m.team"

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

for(Member member : members){
    //패치 조인으로 회원과 팀을 함께 조회하기 때문에 지연 로딩 발생안함
    System.out.println(member.getUsername()+"teamname = "+member.getTeam().name());
}

Criteria쿼리

JPQL을 생성하는 빌더 클래스다. Criteria의 장점은 문자가 아닌
query.select(m).where(...)처럼 프로그래밍 코드로 JPQL을 작성할 수 있다는 점이다.

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> result = em.createQuery(cq).getResultList();

Criteria쿼리 생성 방법

Criteria쿼리를 생성하려면 먼저 Criteria 빌더를 얻어야 한다. Criteria빌더는 EntityManager나
EntityManagerFactory에서 얻을 수 있다.
CriteriaBuilder cb = em.getCriteriaBuilder();
Criteria 쿼리 빌더에서 Criteria쿼리를 생성한다. 이떄 반환 타입을 지정할 수 있다.
CriteriaQuery<Member> cq = cb.createQuery(Member.class)
From 절을 생성한다. 반환된 값 m은 Criteria에서 사용하는 특별한 별칭이다. m을 조회의 시작점
이라는 의미로 쿼리 루트라 한다.
Root<Member> m = cq.from(Member.class)
SELECT 절을 생성한다.
cq.select(m);

조건절 생성 방법

Predicate usernameEqual = cb.equal(m.get("username"),"회원1")
Order ageDesc = cb.desc(m.get("age"))
cq.select(m).where(usernameEqual).orderBy(ageDesc)
em.createQuery(cq).getResultList();

튜플

Criteria는 Map과 비슷한 튜플이라는 특별한 반환 객체를 제공한다.

CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Tuple> cq = cb.createTupleQuery();
        Root<Member> m = cq.from(Member.class);
        cq.multiselect(m.get("username").alias("username"),
                       m.get("age").alias("age")
        );

        TypedQuery<Tuple> query = em.createQuery(cq);
        List<Tuple> resultList = query.getResultList();
        for (Tuple tuple : resultList) {
            String username = tuple.get("username", String.class);
            Integer age = tuple.get("age",Integer.class);
        }

QueryDSL

QueryDSL도 Criteria처럼 JPQL 빌더 역할을 한다. QueryDSL의 장점은 코드 기반이면서 단순하고 사용하기 쉽다.

EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        JPAQuery query = new JPAQuery(em);
        QMember qMember = new QMember("m");
        List<Member> members = query.from(qMember)
                                                                        .where(qMember.name.eq("회원1"))
                                                                        .orderBy(qMember.name.desc())
                                                        .list(qMember);

조인

QJoinParent joinParent = QJoinParent.joinParent;
QJoinChild joinChild = QJoinChild.joinChild;

List<JoinParent> list = query.from(joinParent).leftJoin(joinParent.joinChild, joinChild)
        .fetch().on(joinChild.isNotNull()).list(joinParent);

조인의 기본 문법은 첫 번째 파라미터에 조인 대상을 지정하고, 두 번째 파라미터에 별칭으로 사용할 쿼리 타입을 지정하면 된다.
→join(조인대상, 별칭으로 사용할 쿼리 타입)

네이티브 SQL

SQL을 직접 사용할 수 있는 기능으로 SQL은 지원하지만 JPQL이 지원하지 않는 기능이 있을때 네이티브 SQL을 사용한다.

네이티브 쿼리 API는 다음3가지가 있다.

//결과 타입 정의
public Query createnativeQuery(String sqlString, Class resultClass)
//결과 타입을 정의할 수 없을 때
public Query createnativeQuery(String sqlString)
//결과 매핑 사용
public Query createnativeQuery(String sqlString, String resultSetMapping)

엔티티 조회
네이티브 SQL은 em.createNativeQuery(SQL, 결과 클래스)를 사용한다.
첫번째 파라미터는 네이티브 SQL을 입력, 두번째 파라미터는 조회할
엔티티의 타입을 입력한다.

JPQL

Criteria쿼리

QueryDSL

네이티브 SQL

티스토리툴바