[JPA] JPQL

📌 JPQL이란?

JPQL(Java Persistence Query Language) 는 JPA에서 사용하는 객체 지향 쿼리 언어이다. SQL을 추상화한 쿼리 언어이며, SQL과 비슷한 문법을 가지지만 SQL은 테이블을 대상으로 쿼리를 작성하는 반면 JPQL은 엔티티를 대상으로 쿼리를 작성한다.

JPA에서 제공하는 기본 메서드로 복잡한 조건을 가진 데이터를 조회하기엔 한계가 있으며, 이를 극복하기 위해 JPQL이 개발되었다. JPQL은 이후 SQL로 변환된다.

📌 문법

SELECT m FROMMember m WHERE m.age > 18

• 엔티티와 속성은 대소문자를 구분한다. 단, SELECT, WHERE과 같은 JPQL 키워드는 대소문자를 구분하지 않는다.
• 테이블 이름이 아닌 엔티티 이름을 사용한다. 엔티티 이름은 @Entity 어노테이션으로 설정할 수 있다.
• 별칭을 필수로 사용해야 하며, AS는 생략 가능하다.

📌 TypedQuery vs. Query

TypedQuery 와 Query 는 JPQL을 사용하기 위한 쿼리 타입이다. 두 타입 모두 EntityManager 의 createQuery() 를 호출하여 생성한다.

TypedQuery

TypedQuery는 쿼리 결과의 리턴 타입이 명확할 때 사용한다. 두 번째 인자로 엔티티 클래스를 전달한다.

TypedQuery<Member> typedQuery = em.createQuery("select m from Member m where m.age > 18", Member.class);
List<Member> members = typedQuery.getResultList();

getResultList()는 결과가 하나 이상일 때 사용하며 결과가 리스트 타입이다. getSingleResult() 는 결과가 하나일 때 사용하며 단일 객체를 리턴한다.

TypedQuery를 사용하면 리턴되는 결과를 별도의 캐스팅 없이 바로 사용할 수 있다. 또한 타입 안전성을 보장하므로 컴파일 시점에 타입 오류를 잡을 수 있다.

Query

Query는 리턴 타입이 명확하지 않거나 여러 컬럼을 선택하여 조회할 때 사용한다.

Query query = em.createQuery("select m.username, m.age from Member m where m.age > 18");
List<Object[]> resultList = query.getResultList();

Query 타입의 결과를 사용할 때 적절한 타입으로 캐스팅하여 사용해야 한다.

📌 파라미터 바인딩

파라미터 바인딩은 JPQL에서 쿼리에 특정 값을 동적으로 전달하는 방법이다. 이를 통해 SQL Injection을 방지할 수 있으며 쿼리 재사용성을 높일 수 있다.

이름 기준 파라미터

파라미터를 이름을 구분하는 방식이다. ‘:’을 사용하여 파라미터 이름을 지정한다.

TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m WHERE m.username = :username", Member.class);
query.setParameter("username", "member1");
List<Member> resultList = query.getResultList();

위치 기준 파라미터

‘?’ 뒤에 위치 값을 지정하는 방식이다. 위치 값은 1부터 시작한다.

TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m WHERE m.username = ?1", Member.class);
query.setParameter(1, "member1");
List<Member> resultList = query.getResultList();

일반적으로 위치 기준 파라미터 바인딩보다 이름 기준 파라미터 바인딩이 더 권장된다.

메서드 체이닝

JPQL API는 메서드 체인 형식으로 설계되어 있다.

List<Member> members = em.createQuery("SELECT m FROM Member m WHERE m.username = :username", Member.class)
    .setParameter("username", "member1")
    .getResultList(); 

📌 프로젝션

프로젝션(Projection)은 JPQL에서의 SELECT절에 조회할 대상을 지정하는 것을 의미한다.

엔티티 프로젝션

엔티티 자체를 조회 대상을 지정하는 방식이다.

SELECT m FROM Member m
SELECT m.team FROM Member m

엔티티 프로젝션으로 조회된 결과는 영속성 컨텍스트에서 관리된다.

임베디드 타입 프로젝션

엔티티에 포함된 임베디드 타입을 조회하는 방식이다.

SELECT m.address FROM Member m

-- 불가능
SELECT a FROM Address a

임베디드 타입은 엔티티와 유사하게 사용되지만, 조회의 시작점이 될 수 없다.

스칼라 타입 프로젝션

숫자나 문자 같은 기본 데이터 타입을 조회하는 방식이다.

SELECT m.username FROM Member m

여러 스칼라 값도 함께 조회할 수 있다. Object[] 타입으로 조회하는 방법과 JPQL의 new 키워드와 DTO 클래스를 통해 조회하는 방법이 있다.

// Object[]
String jpql = "SELECT m.username, m.age FROM Member m";
List<Object[]> resultList = entityManager.createQuery(jpql).getResultList();

// DTO
String jpql = "SELECT new com.example.MemberDTO(m.username, m.age) FROM Member m";
List<MemberDTO> resultList = entityManager.createQuery(jpql, MemberDTO.class).getResultList();

DTO 클래스를 사용하는 방법이 더 권장된다.

📌 페이징 API

JPQL에서 대용량 데이터를 효율적으로 조회하기 위해 페이징을 사용한다.

setFirstResult(int startPos) 는 조회 시 시작 위치를 지정하는 메서드이다. startPos + 1 번째 결과부터 조회를 시작한다. 인덱스는 0부터 시작한다.

setMaxResults(int maxResult) 는 한 번에 조회할 데이터의 최대 개수를 maxResult 개로 지정하는 메서드이다.

String jpql = "select m from Member m order by m.name desc";
List<Member> resultList = entityManager.createQuery(jpql, Member.class)
                              .setFirstResult(10)
                              .setMaxResults(20)
                              .getResultList();

위 코드는 11번 째 결과부터 20개의 데이터를 조회하는 코드이다.

JPQL의 페이징 API를 사용하면 SQL의 페이징 쿼리를 직접 작성할 필요가 없다. 여러 DBMS마다 다른 페이징 처리 쿼리 문법이 존재하기에, 개발자는 DBMS 종류에 구애받지 않고 일관된 방식으로 페이징 로직을 구현할 수 있다.

📌 집계 함수

JPQL은 SQL과 유사한 집계 함수를 제공한다.

COUNT(x): 결과의 개수 리턴, Long타입

SUM(x): 숫자 필드의 합계 계산, Long , Double 타입

AVG(x): 평균 계산, Double 타입

MAX(x): 최댓값 계산

MIN(x): 최솟값 계산

SELECT COUNT(m), SUM(m.age), AVG(m.age), MAX(m.age), MIN(m.age)
FROM Member m

📌 JOIN

Inner Join

두 엔티티 간 연관관계가 존재하는 데이터만 조회한다. INNER 키워드는 생략 가능하다.

SELECT m FROM Member m INNER JOIN m.team t WHERE t.name = :teamName

Outer Join

연관관계가 없더라도 기준이 되는 엔티티의 데이터를 모두 포함하여 조회한다. 데이터가 없는 경우 NULL 로 표시된다. OUTER 키워드는 생략 가능하다.

SELECT m FROM Member m LEFT OUTER JOIN m.team t

Theta Join

연관관계 없는 엔티티 간에도 WHERE절을 만족하는 데이터를 조인한다.

SELECT m FROM Member m, Team t WHERE m.username = t.name

---

JPA 2.1부터 ON 절을 사용하여 조인 대상을 필터링할 수 있다.

SELECT m FROM Member m LEFT JOIN m.team t ON t.name = 'A'

Fetch Join

Fetch Join 은 JPQL에서 성능 최적화를 위해 제공하는 기능이다. Fetch Join을 통해 연관된 엔티티나 컬렉션을 프록시 객체가 아닌 실제 데이터로 SQL 쿼리와 함께 조회하여 로딩할 수 있다. 이를 통해 N+1 문제를 해결할 수 있다.

JOIN FETCH 라는 키워드를 사용하며, 조회 주체가 되는 엔티티뿐만 아니라 FETCH로 명시된 연관 엔티티까지 함께 조회하여 즉시 로딩(Eager Loading) 후 영속화한다.

@ManyToOne, @OneToOne 관계에서 사용하는 페치 조인을 엔티티 페치 조인, @OneToMany 관계에서 사용하는 페치 조인을 컬렉션 페치 조인이라고 한다.

-- 엔티티 페치 조인
SELECT m FROM Member m JOIN FETCH m.team

-- 컬렉션 페치 조인
SELECT t FROM Team t JOIN FETCH t.members

컬렉션 페치 조인 시 데이터 중복이 발생할 수 있다. 이를 해결하기 위해 DISTINCT 키워드를 사용한다. 애플리케이션 레벨에서 엔티티의 식별자를 기준으로 중복된 엔티티를 제거한다.

페치 조인은 FetchType 같은 글로벌 로딩 전략보다 우선순위가 높다. 보통 엔티티 로딩 전략을 fetch = FetchType.LAZY 로 설정하고 필요한 경우 페치 조인을 사용하는 경우가 많다. 또한 페치 조인 대상에는 별칭을 사용할 수 없다. 둘 이상의 컬렉션을 페치 조인할 수 없으며, 페이징 API를 사용할 수 없다.

일반 조인과 페치 조인의 가장 큰 차이점은 연관 엔티티의 조회 및 영속화 여부이다. 일반 조인은 연관 엔티티를 로딩하지 않으며 영속화하지 않는다. 그러나 페치 조인은 연관 엔티티를 함께 로딩하여 영속성 컨텍스트에 로딩한다.

📌 @Query

JPA에서 @Query 어노테이션을 통해 직접 JPQL 또는 Native SQL 쿼리를 작성할 수 있다.

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.status = 1")
    Collection<User> findAllActiveUsers();
}

nativeQuery = true 속성을 통해 Native SQL 쿼리를 작성할 수 있다.

public interface UserRepository extends JpaRepository<User, Long> {
    @Query(
      value = "SELECT * FROM USERS u WHERE u.status = 1",
      nativeQuery = true)
    Collection<User> findAllActiveUsersNative();
}

메서드의 파라미터에 @Param 어노테이션을 통해 JPQL 내의 파라미터 이름과 매핑할 수 있다.

public interface MemberRepository extends JpaRepository<Member, Long> {
    @Query("select m from Member m where m.username = :name")
    Member findMembers(@Param("name") String username);
}

INSERT, UPDATE, DELETE와 같은 DML 쿼리를 사용할 때, @Modifying 어노테이션을 함께 사용해야 한다.

public interface UserRepository extends JpaRepository<User, Long> {
    @Transactional
    @Modifying
    @Query("update User u set u.name = :name where u.id = :id")
    int updateName(@Param("id") Long id, @Param("name") String name); // 벌크 연산은 업데이트된 행 수를 반환
}

📌 참고

https://ittrue.tistory.com/270

https://adjh54.tistory.com/479

https://ict-nroo.tistory.com/116

https://velog.io/@kevin_/JPQL