QueryDSL + JPA

참고로 아래와 같이 설정하면 하이버네이트가 어떻게 동작하는지 확인할 수 있다.

spring:
  datasource:
    url: jdbc:h2:tcp://localhost/~/test
    username: sa
    password:
    driver-class-name: org.h2.Driver

  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        format_sql: true # 쿼리를 포맷팅하여 출력한다.
        use_sql_comments: true # 해당 쿼리의 JPQL을 주석으로 출력한다.

logging.level:
  org.hibernate.SQL: debug # 쿼리를 로그에 남긴다.
  org.hibernate.event.internal.AbstractFlushingEventListener: DEBUG # Flush 확인 로그

 

💭 QueryDSL 소개(오픈소스)

2015년에 출시한 오픈소스 프로젝트이다. 자바 코드로 쿼리를 생성할 수 있게 만들어준다.

설정은 조금 귀찮지만, 자바 코드로 작성되었기에 재사용 가능하고, 컴파일 시점에서 많은 오류를 잡을 수 있다.

https://github.com/querydsl/querydsl/tree/master/querydsl-examples

 

재밌는 점은 Spring 공식문서에서도 Predicate(JPA Criteria)는 언급도 없는데, JPA + QueryDSL 지원은 강조하고 있다.

그만큼 인기있고, 실무에서 거의 기본으로 사용하는 도구이다.

 

 

💭 어떻게 추가하나요

스프링부트 2.6.4 이후, queryDsl을 설정하는 방법이 굉장히 쉬워졌다. 참고로 QClass는 ./build/generated/{엔티티 경로} 에 생성된다.
github.com/querydsl 에 나와있는 그래들 설정방법 (2022.07)

 implementation `com.querydsl:querydsl-jpa`
 annotationProcessor "com.querydsl:querydsl-apt

- Gradle Kotlin DSL 을 사용한다면 https://jessyt.tistory.com/106 참고

// kotlin
 implementation("com.querydsl:querydsl-jpa")
 kapt(group = "com.querydsl", name = "querydsl-apt", classifier = "jpa")

buildscript {
  ext {
    queryDslVersion = "5.0.0"
  }
}

plugins {
  id 'org.springframework.boot' version '2.6.2'
  id 'io.spring.dependency-management' version '1.0.11.RELEASE'
  //querydsl 추가
  id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
  id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

configurations {
  compileOnly {
    extendsFrom annotationProcessor
  }
}

repositories {
  mavenCentral()
}

dependencies {
  implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
  implementation 'org.springframework.boot:spring-boot-starter-web'
  //querydsl 추가
  implementation "com.querydsl:querydsl-jpa:${queryDslVersion}"
  annotationProcessor "com.querydsl:querydsl-apt:${queryDslVersion}"
  compileOnly 'org.projectlombok:lombok'
  runtimeOnly 'com.h2database:h2'
  annotationProcessor 'org.projectlombok:lombok'
}

test {
  useJUnitPlatform()
}

//querydsl 추가 시작
def querydslDir = "$buildDir/generated/querydsl"

querydsl {
jpa = true
querydslSourcesDir = querydslDir
}
sourceSets {
main.java.srcDir querydslDir
}
configurations {
querydsl.extendsFrom compileClasspath
}
compileQuerydsl {
options.annotationProcessorPath = configurations.querydsl
}
//querydsl 추가 끝

 

- 참고로 기존에는 Gradle 플러그인 (com.ewerk.gradle.plugins.querydsl) 을 사용하여 추가했었다.

스프링부트 2.6.4 이전 설정방법

아래 2가지 의존성을 추가해줘야한다.

• implementation 'com.querydsl:querydsl-jpa'
  ➡ queydsl의 JPA 연동 라이브러리
• annotationProcessor "com.querydsl:querydsl-apt
  ➡ QueryDsl의 컴파일 타임 QClass 생성도구 (Gradle-Task querydslClasses)

buildscript {
    ext {
        queryDslVersion = "5.0.0"
    }
}

plugins {
    id 'org.springframework.boot' version '2.6.3'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id "com.ewerk.gradle.plugins.querydsl" version "1.0.10" // 플러그인 추가
    id 'java'
}

dependencies{
	...
    implementation "com.querydsl:querydsl-jpa:${queryDslVersion}"
    annotationProcessor "com.querydsl:querydsl-apt:${queryDslVersion}"
}

혹시나 NoClassDefFoundError가 발생한다면, 아래 두줄을 추가해주자.

javax.annotation.Entity가 jakarta.annotation.Entity로 바뀌면서 JPA 어노테이션을 찾지못해서 발생하는 에러이다.

// javax -> jakarta 변경으로 인한 NoClassDefFoundError 오류 방지
annotationProcessor "jakarta.persistence:jakarta.persistence-api"
annotationProcessor "jakarta.annotation:jakarta.annotation-api"

 

 

📑 QureyDsl 플러그인 추가설정

앞에서 사용한 스프링의 도구들은, Spring-boot-starter를 사용하면 별도의 설정없이 쉽게 추가가 가능했었다.하지만 QueryDsl은 오픈소스라서 설정을 자동화해주는 스프링 부트가 없다. Gradle을 직접 설정해주어야한다.
물론 버전 정도는 맞춰주지만 (컴파일 타임에 QueryDsl의 추가작업)에 대한 설정 자동화는 제공해주지 않는다.
공식문서에는 Maven 설정만 제공해준다. 물론 오류가 생기더라도, 사용하는 사람이 많으므로 구글링하면 해결가능.

/*📌 QueryDsl이 생성한 파일이 위치할 경로 */
def querydslDir = "$buildDir/generated/querydsl"

/*📌 querydsl에 관한 설정 */
querydsl {
 jpa = true
 querydslSourcesDir = querydslDir
}

/*📌 build시 사용할 sourceSet에 추가한다. 이를 해줘야 IDE에서 QClass를 사용할 수 있다. */
sourceSets {
 main.java.srcDir querydslDir
}

/*📌 컴파일 클래스패스에 추가하고, 어노테이션 프로세서를 통해 Q-Class를 생성한다. */
/* 기존에는 없어도 되었으나, Gradle 5.X에서 AnnotaionProcessor가 추가되며 설정이 필요해졌다. */
compileQuerydsl {
 options.annotationProcessorPath = configurations.querydsl
}

/*📌 complie 타임에 JPA 의존성에 접근 할 수 있도록 설정(상속)을 추가한다. */
/* 기존에는 없어도 되었으나, Gradle 6.X에서 compileClasspath가 생기며 필요해졌다. */
configurations {
 querydsl.extendsFrom compileClasspath
}

 

📑 이전 빌드에 생성된 QClass 삭제 자동화

엔티티 위치가 변경되거나 삭제될 경우 기존 쿼리 타입(Q클래스)를 삭제해주어야 정상 동작한다.

이는 직접 찾아서 삭제해도 되지만, 아래와 같이 자동화해주면 편하게 사용가능하다.

참고로 Gradle 빌드의 경우, 새로 빌드하면 기존 빌드파일을 삭제하기 때문에 아래와 같은 작업을 안해줘도 된다.

/** gradle clean 태스크 실행시 기존의 QClass 삭제 */
clean {
    delete file('src/main/generated') // 인텔리제이 Annotation processor 생성물 생성위치
}

만약 Clean 실행시 파일이 삭제되는게 불편하다면, 위 코드를 넣지말고 아래처럼 gradle-task를 추가해줘도 된다.

/** 인텔리제이 Annotation processor 에 생성되는 'src/main/generated' 디렉터리 삭제 */
task cleanGeneatedDir(type: Delete) { 
    delete file('src/main/generated')
}

 

참고로 전체 빌드를 하지않더라도, Intellij를 쓴다면 우측상단 Gradle탭에서 compileQuerydsl을 실행시킬 수 있다.

기본적으로는 프로젝트경로/src/main/generated 에 생성된다. 그래들로 생성했다면 build를 열어보면 있다.

위에서 Gradle SourceSet을 설정해주었기 때문에, 빌드 후에 IDE에서 정상적으로 QClass를 바로 사용할 수 있다.

 

---

💭 사용 방법

빌드 후, 생성된 Q-Type ( QMember )를 이용하면 된다.

우선 이해하기 쉽게 풀어쓰면, 아래와 같다.

@Test
void querydsl() {
    JPAQueryFactory queryFactory = new JPAQueryFactory(em);
    QMember member = new QMember("nick"); // 별명은 같은테이블을 조인할 때 사용된다. 그 외 필요 X

    Member findMember = queryFactory
        .select(member)
        .from(member)
        .where(member.username.eq("member1"))
        .fetchOne();

    assertThat(findMember.getUsername()).isEqualTo("member1");
}

이 코드는 아래와 똑같은 JPQL을 생성해낸다.

@Test
void jpql(){
    var findMember = em.createQuery(
            "select m from Member m where m.username = :username", Member.class)
        .setParameter("username", "member1")
        .getSingleResult();

    assertThat(findMember.getUsername()).isEqualTo("member1");
}

 

이를 조금 더 깔끔하게 만들어보자.

• querydsl . JPAQueryFactory는 영속성 컨텍스트(em)을 받아서 사용한다.
  스프링에서는 트랜잭션 단위로 em을 관리하기 때문에 이렇게 사용해도 괜찮다. (동시성 문제에 안전하다.)

JPAQueryFactory queryFactory;
 
@BeforeEach
public void before() {
    queryFactory = new JPAQueryFactory(em);
}

 

• QMember 코드를 뜯어보면, 편하게 사용해라고 static QMember member = new QMember() 를 제공해준다.
  참고로 QMember("~") 안에 들어가는건 별명이다. 평소엔 필요없고, 같은 테이블을 조인할 때 사용한다.

이를 이용하면 QMember를 매번 만들지 않고도, static import로 불러와 아래와 같이 깔끔한 코드를 사용할 수 있다.

import static mypackage.domain.QMember.member;

@Test
void querydsl() throws Exception {
    Member findMember = queryFactory
        .select(member) // import static QMember.member
        .from(member)
        .where(member.username.eq("member1"))
        .fetchOne();

    assertThat(findMember.getUsername()).isEqualTo("member1");
}

 

---

💭 검색 조건 쿼리

JPQL이 지원하는 모든 검색조건을 메서드로 지원한다.

member.username.eq("member1") // username = 'member1'
member.username.ne("member1") //username != 'member1'
member.username.eq("member1").not() // username != 'member1'
member.username.isNotNull() //이름이 is not null

member.age.in(10, 20) // age in (10,20)
member.age.notIn(10, 20) // age not in (10, 20)
member.age.between(10,30) //between 10, 30

member.age.goe(30) // age >= 30
member.age.gt(30) // age > 30
member.age.loe(30) // age <= 30
member.age.lt(30) // age < 30

member.username.like("member%") //해당 문구를 like 검색
member.username.contains("member") // like ‘%member%’ 검색
member.username.startsWith("member") //like ‘member%’ 검색

 

여러 조건을 .and() 나 .or()으로 연결할 수 있다.

@Test
void search() {
    Member findMember = queryFactory
        .selectFrom(member) // select(member).from(member)를 합친 메서드
        .where( member.username.eq("member1")
            .and(member.age.eq(10)) )
        .fetchOne();

    assertThat(findMember.getUsername()).isEqualTo("member1");
}

 

뒤에 설명할거지만, where(~) 안에 파라메타로 전달하면 AND 조건으로 처리한다.

참고로 조건에 null 값이 들어가면 해당 조건을 무시한다. 이를 이용해 동적쿼리를 생성하기 편하다.

List<Member> result1 = queryFactory
    .selectFrom(member)
    .where(member.username.eq("member1"), member.age.eq(10)) // .and()와 동일
    .fetch();

 

참고로 distinct()는 아래와 같이 select 뒤에 사용하면 된다.

이는 JPQL의 distinct와 동작이 완전히 같다.

List<String> result = queryFactory
        .select(member.username)
        .distinct()
        .from(member)
        .fetch();

---

💭 결과 조회

//List
List<Member> fetch = queryFactory
    .selectFrom(member)
    .fetch();
    
//단 건
Member findMember1 = queryFactory
    .selectFrom(member)
    .fetchOne();

//처음 한 건 조회 .limit(1).fetchOne()과 동일한 동작
Member findMember2 = queryFactory
    .selectFrom(member)
    .fetchFirst();

• fetch() 는 기본적으로 List<T>를 반환한다. (데이터가 없다면 빈 리스트를 반환한다.)

 

• fetchOne()을 사용하면 한건만 가져온다. (없으면 null)
  JPA에서는 2건 조회시 예외가 발생하는데, 스프링과 다르게 QueryDsl은 이 예외를 감싸서 던진다.

같은 이름인 com.querydsl.core.NonUniqueResultException(e) 예외로 감싼다.

 

• fetchFirst()는 fetchOne()과 동일하다. 차이점은 여러 개가 조회되더라도 하나만 가져오는거 정도.

실제 코드도 이렇다.

 

처음에는 페이지(fetchResults)나 전체 개수(fetchCount)도 가져올 수 있었지만, 지금은 해당 메서드가 없어졌다.

최적화 부분도 그렇고, 복잡한 쿼리에서 Count 쿼리의 성능이 나빠져서 그렇다고 한다.

아래 기능들은 현재 Deprecated 되어있다.

//페이징에서 사용
QueryResults<Member> results = queryFactory
    .selectFrom(member)
    .fetchResults();
    
//count 쿼리로 변경
long count = queryFactory
    .selectFrom(member)
    .fetchCount();

@Test
public void paging2() {
    QueryResults<Member> queryResults = queryFactory
        .selectFrom(member)
        .orderBy(member.username.desc())
        .offset(1)
        .limit(2)
        .fetchResults();
    assertThat(queryResults.getTotal()).isEqualTo(4);
    assertThat(queryResults.getLimit()).isEqualTo(2);
    assertThat(queryResults.getOffset()).isEqualTo(1);
    assertThat(queryResults.getResults().size()).isEqualTo(2);
}

---

간단한 Count 값이 필요하다면 아래와 같이 사용하자.

Long totalCount = queryFactory
    .select(member.count()) // select count(member.id)
    .from(member)
    .fetchOne();

Long totalCount = queryFactory
    .select(Wildcard.count) // select count(*)
    .from(member)
    .fetchOne();

 

---

💭 정렬

orderBy() 메서드를 이용하면 정말 간단하게 가능하다.

List<Member> result = queryFactory
    .selectFrom(member)
    .where(member.age.eq(100))
    .orderBy(member.age.desc(), member.username.asc())
    // 1순위 회원나이 내림차순 - 2순위 회원이름 오름차순
    .fetch();

단, 필드 null 값은 오름차순(asc)는 제일 앞으로, 내림차순(desc)이라면 제일 뒤로 정렬된다.

이 정렬 순서를 바꾸고 싶다면 .nullsLast()  .nullsFirst() 를 추가로 설정해주면 된다.

List<Member> result = queryFactory
    .selectFrom(member)
    .where(member.age.eq(100))
    .orderBy(member.age.desc(), member.username.asc().nullsLast()) // 무조건 null이 뒤로감.
    .fetch();

 

 

---

💭 페이징 (Paging)

이것도 딱히 설명할게 없다. offset()과 limit() 메서드를 사용하면 된다.

단, 이렇게 쓰면 당연히 count 쿼리가 별도로 실행된다. 성능 최적화가 필요하다면 해당 쿼리를 별도로 작성하는게 좋다.

만약 여러 테이블을 조인해서 페이징했다면, count 쿼리를 실행할 때도 필요없는 조인이 발생한다. = 성능상 좋지않다.

@Test
public void paging1() {
    List<Member> result = queryFactory
        .selectFrom(member)
        .orderBy(member.username.desc())
        .offset(1) //0부터 시작(zero index)
        .limit(2) //최대 2건 조회
        .fetch();
    assertThat(result.size()).isEqualTo(2);
}

 

---

💭 집합 ( COUNT , SUM, AVG, MAX, MIN )

.select()에서 사용하면 된다. 참고로 집합으로 조회하면 Querydsl의 Tuple 객체로 반환된다.

public interface Tuple { // import com.querydsl.core.Tuple;

    @Nullable
    <T> T get(int index, Class<T> type);

    @Nullable
    <T> T get(Expression<T> expr);

    int size();

    Object[] toArray();
}

 

다만 실무에서는 Tuple보다는 DTO로 받아오는 걸 더 많이 사용한다. 이는 뒤에서 알아보도록 하자.

@Test
public void aggregation() throws Exception {
    List<Tuple> result = queryFactory
        .select(member.count(),
            member.age.sum(),
            member.age.avg(),
            member.age.max(),
            member.age.min())
        .from(member)
        .fetch();
    Tuple tuple = result.get(0);
    
    assertThat(tuple.get(member.count())).isEqualTo(4);
    assertThat(tuple.get(member.age.sum())).isEqualTo(100);
    assertThat(tuple.get(member.age.avg())).isEqualTo(25);
    assertThat(tuple.get(member.age.max())).isEqualTo(40);
    assertThat(tuple.get(member.age.min())).isEqualTo(10);
}

 

---

💭 groupBy, having

마찬가지로 쉽게 사용할 수 있다.

@Test
public void group() throws Exception {
	// [팀의 이름, 각 팀의 평균연령]을 구해라
    List<Tuple> result = queryFactory
        .select(team.name, member.age.avg())
        .from(member)
        .join(member.team, team)
        .groupBy(team.name)
        .fetch();
    
    Tuple teamA = result.get(0);
    Tuple teamB = result.get(1);
    
    assertThat(teamA.get(team.name)).isEqualTo("teamA");
    assertThat(teamA.get(member.age.avg())).isEqualTo(15);
    assertThat(teamB.get(team.name)).isEqualTo("teamB");
    assertThat(teamB.get(member.age.avg())).isEqualTo(35);
}

 

당연히 having도 지원한다.

groupBy()로 그룹을 만든 결과들을 필터링하고 싶다면 .having() 을 사용하자.

.groupBy(item.price) // 그룹으로 나누고
.having(item.price.gt(1000)) // 각 그룹은 price >= 1000 인 아이템만 포함

 

---

💭 조인

📑 Inner Join, Outer Join

조인 대상과, 조인할 Q-Type을 지정해주면 된다.

JPQL과 동일하게 기본은 Inner Join으로 동작한다.

@Test
public void join() throws Exception {
    QMember member = QMember.member;
    QTeam team = QTeam.team;

    // Member.team = "teamA" 인 모든 회원 조회
    List<Member> result = queryFactory
        .select(member)
        .from(member)
        .join(member.team, team) // Member.team 을 Team 엔티티(QTeam.team)과 조인한다.
        .where(team.name.eq("teamA"))
        .fetch();

    assertThat(result)
        .extracting("username")
        .containsExactly("member1", "member2");
}

만약 같은 테이블을 조인해야한다면 QMember other = new QMember("별명")을 만들어서 조인해주면 된다.

JPQL은 이렇게 찍힌다. inner join

 

leftJoin(), rightJoin() 도 마찬가지로 지원한다.

List<Member> result = queryFactory
    .selectFrom(member)
    .leftJoin(member.team, team) // Member.team 을 Team 엔티티(QTeam.team)과 조인한다.
    .where(team.name.eq("teamA"))
    .fetch();

생성된 JPQL

 

📑 Theta Join

참고로 세타조인은 연관관계가 없는(공통 값이 없는) 두 객체를 조인하는 것을 의미한다.

과거의 JPA(하이버네이트)에서는 불가능했는데, 최신 버전에는 이러한 막 조인도 가능하다.

List<Member> result = queryFactory
    .select(member)
    .from(member, team) // 그냥 두 테이블을 조인한다.
    .where(member.username.eq(team.name)) // member.username == team.name
    .fetch();

이는 아래와 같은 쿼리를 만든다. 참고로 이런 쿼리는 보통 DB에서 성능 최적화를 해준다.

/* JPQL
select
    member1 
from
    Member member1,
    Team team 
where
    member1.username = team.name
*/    

select
    member0_.member_id as member_i1_0_,
    member0_.age as age2_0_,
    member0_.team_id as team_id4_0_,
    member0_.username as username3_0_ 
from
    member member0_ cross 
join
    team team1_ 
where
    member0_.username=team1_.name

다만 이 방법으로는 Inner 조인만 가능하고, Outer 조인은 불가능하다.

필요하다면 아래의 on절을 활용해서 해결하면 된다.

 

 

📑 조인 on 절

참고로 이는 JPA2.1 (하이버네이트 5.1)부터 지원하는 기능이다.

조인 엔티티(테이블)를 필터링하거나, 위에서 말한대로 연관관계가 없는 엔티티를 조인할 때 사용할 수 있다.

-- 회원과 팀을 조인하면서, [팀 이름이 teamA인 팀]만 조인, 회원은 모두 조회
-- JPQL
SELECT m, t 
FROM Member m 
LEFT JOIN m.team t 
ON t.name = 'teamA'

-- SQL
SELECT m.*, t.* 
FROM Member m 
LEFT JOIN Team t 
ON m.TEAM_ID=t.id and t.name='teamA

 

보이는 그대로 사용하면된다. 간단하다.

@Test
public void join_on_filtering() throws Exception {
    List<Tuple> result = queryFactory
        .select(member, team)
        .from(member)
        .leftJoin(member.team, team)
        .on(team.name.eq("teamA"))
        .fetch();

    for (Tuple tuple : result) {
        System.out.println("tuple = " + tuple);
    }

}

Member 와 [Team on team.name = 'teamA']을  LEFT JOIN 했으므로, 결과는 아래와 같이 나온다.

team은 이름이 "teamA"인 데이터만 조인되었다. ( On t.name = 'teamA' )

 

당연한 말이긴한데, Inner 조인에서 on을 사용하는건 그냥 where()을 쓰는것과 결과가 동일하다.

Inner Join은 굳이 복잡하게 on 절을 사용할 필요가 없다. 그냥 where을 쓰자.

List<Tuple> result = queryFactory
    .select(member, team)
    .from(member)
    .join(member.team, team) // inner Join
    .where(team.name.eq("teamA"))
//  .on(team.name.eq("teamA")) 와 똑같은 결과가 나온다.
    .fetch();

 

 

연관관계가 없는 엔티티는 on을 이용해 아래와 같이 조인할 수 있다.

물론 Inner 조인( .join() )은 위에서 말한대로 from(member, team).where(...)으로 사용하면 된다.

@Test
public void join_on_no_relation() throws Exception {
    em.persist(Member.of("teamA", 11));
    em.persist(Member.of("teamB", 11));

    List<Tuple> result = queryFactory
        .select(member, team)
        .from(member)
        .leftJoin(team) // Left Outer 세타 조인
        .on(member.username.eq(team.name))
        .fetch();

    for (Tuple tuple : result) {
        System.out.println("t=" + tuple);
    }
}

 

LEFT OUTER 조인으로 연관관계가 없는 데이터를 가져왔다.

실제 쿼리를 찍어보면 아래와 같다.

on 을 이용해서, 연관관계 없이 조회한 모습.

 

 

📑 Join fetch (패치조인)

참고로 join fetch는 JPQL에만 존재하는 문법이다. 연관관계인 엔티티를 쿼리한방에 다 같이 가져온다.

(그냥 조인만하면 조인 조건으로만 사용하고, 엔티티를 가져오지는 않는다.)

 

사용방법은 간단하다. 조인뒤에 .fetchJoin() 을 붙여주면 된다.

@Test
public void fetchJoinUse() throws Exception {
    em.flush();
    em.clear();
    
    Member findMember = queryFactory
        .selectFrom(member)
        .join(member.team, team).fetchJoin()
        .where(member.username.eq("member1"))
        .fetchOne();
 
    
    boolean isFetchJoin = emf.getPersistenceUnitUtil().isLoaded(findMember.getTeam());
 
    assertThat(isFetchJoin).as("패치 조인 적용").isTrue();
}

 

당연한거지만, 위와 같이 fetchJoin()을 붙여주지 않으면 패치조인 하지 않는다. 지연 로딩된다.

// 패치조인 되지않음. 그냥 지연로딩 (Lazy 객체를 사용할 때 쿼리발생)
Member findMember = queryFactory
    .selectFrom(member)
    .where(member.username.eq("member1"))
    .fetchOne();

 

 

📑 서브 쿼리 where (select ... from ...)

QueryDsl의 JPAexpressions 객체로 사용할 수 있다. 어렵지 않다.

@Test
public void subQuery() throws Exception {
    QMember memberSub = new QMember("memberSub");
	
    /* Where 절 서브쿼리 */
    List<Member> result = queryFactory
        .select(member)
        .from(member)
        .where(member.age.eq(
            JPAExpressions
                .select(memberSub.age.max())
                .from(memberSub)
        ))
        .fetch();

    assertThat(result).extracting("age")
        .containsExactly(40); // oldest age.
}

참고로 쿼리는 아래와 같이 찍힌다.

-- JPQL
select
    member1 
from
    Member member1 
where
    member1.age = (
        select
            max(memberSub.age) 
        from
            Member memberSub
    )

-- SQL
select
    member0_.member_id as member_i1_0_,
    member0_.age as age2_0_,
    member0_.team_id as team_id4_0_,
    member0_.username as username3_0_ 
from
    member member0_ 
where
    member0_.age=(
        select
            max(member1_.age) 
        from
            member member1_
    )

 

JPA 표준에는 Select 서브쿼리가 없지만, 하이버네이트는 지원한다. 그래서 아래와 같이 사용할 수 있다.

/* select 절 서브쿼리 */
QMember memberSub = new QMember("memberSub");

List<Tuple> result = queryFactory
    .select(member.username,
        JPAExpressions
            .select(memberSub.age.avg())
            .from(memberSub))
    .from(member)
    .fetch();

/* JPQL */ SQL

 

 

🧨 JPA에서는 인라인뷰(from 절 서브쿼리)가 불가능

QueryDsl의 문제가 아니라, 하이버네이트에서 From 절 서브쿼리를 지원하지 않는다.

이는 조인으로 해결하거나, 쿼리를 2번으로 분리해서 해결하도록 하자.

 

대규모 서비스라, 성능에 민감해서 꼭 써야한다면 JPA를 포기하고 쌩 쿼리(JDBC, Mybatis)를 쓰는 걸 추천한다.

 

다만 이런 경우 데이터베이스 SQL에 비즈니스 로직이 포함되어 있는 경우가 많다.

설계적인 측면에서 어플리케이션에서 해야할 일을 DB에 위임하는게 아닌가 고민해볼 필요는 있다.

 

---

💭 Case 조건문 (잘 사용안하는 기능)

switch문처럼, 결과값에 따라 다른 결과를 반환하도록 만들 수 있다.

다만 보통 DB에서 데이터를 가져와서 어플리케이션에서 하기 때문에, 사용할 일은 거의 없긴하다.

• 간단한 조건은 아래와 같이 when().then() , otherwise()를 사용하면 된다.

@Test
void case_condition1() throws Exception {
    List<String> result = queryFactory
        .select(member.age
            .when(10).then("열살") // case 10: return "열살"
            .when(20).then("스무살") // case 20: return "스무살"
            .otherwise("기타")) // default: return "기타"
        .from(member)
        .fetch();

    for (String s : result) {
        System.out.println("s = " + s);
    }
}

m(10), m(20), m(30), m(40)

• 조건이 딱 떨어지지 않고, 복잡하다면 QueryDsl의 CaseBuilder를 사용할 수 있다.

@Test
void case_condition2() throws Exception {
    List<String> result = queryFactory
        .select(new CaseBuilder()
            .when(member.age.between(0, 20)).then("0~20살")
            .when(member.age.between(21, 30)).then("21~30살")
            .otherwise("기타"))
        .from(member)
        .fetch();

    for (String s : result) {
        System.out.println("memo = " + s);
    }
}

 

• Order By를 복잡한 조건으로 사용할 수 있다. 이땐 Expression 객체를 이용하면 된다.

@Test
void case_condition3() throws Exception {

    NumberExpression<Integer> rankPath = new CaseBuilder()
        .when(member.age.between(0, 20)).then(2) // 2순위
        .when(member.age.between(21, 30)).then(1) // 1순위
        .otherwise(3); // 3순위

    List<Tuple> result = queryFactory
        .select(member.username, member.age, rankPath)
        .from(member)
        .orderBy(rankPath.desc())
        .fetch();

    for (Tuple tuple : result) {
        String username = tuple.get(member.username);
        Integer age = tuple.get(member.age);
        Integer rank = tuple.get(rankPath);
        System.out.println("username = " + username + " age = " + age + " rank = " + rank);
    }
}

username = member4 age = 40 rank = 3 // 3순위 (그 외)
username = member1 age = 10 rank = 2 // 2순위 (0~20)
username = member2 age = 20 rank = 2 // 2순위 (0~20)
username = member3 age = 30 rank = 1 // 1순위 (21~30)

 

 

💭 결과 값에 상수, 문자 추가하기

우선, 단순히 상수를 추가하는건 QueryDsl에서 최적화가 이루어진다.

아래 코드에서는 상수에 관한 JPQL (SQL constant)가 발생하지 않는다.

Tuple result = queryFactory
    .select(member.username, Expressions.constant("A"))
    .from(member)
    .fetchFirst();
    
/* 결과값
    ["name1", "A"]
    ["name2", "A"]
    ["name3", "A"]...
*/

물론 복잡하게 상수값과 계산을 해버리면, SQL constant로 값을 넘긴다.

 

결과값에 특정 문자열을 더하고 싶다면, concat() 과 stringValue() 를 사용하면 된다.

나중에 문자가 아닌 타입들 (enum등)을 처리할 때, 유용하게 사용할 수 있다.

String result = queryFactory
    .select(member.username.concat("_").concat(member.age.stringValue()))
    .from(member)
    .where(member.username.eq("member1"))
    .fetchOne();

이렇게 잘 붙어서 나온다.

 

 

---

💭 프로젝션 ( Tuple, DTO 조회 )

참고로 프로젝션은 테이블의 특정 행을 뽑아내는 것을 의미한다.

프로젝션 대상이 하나라면, 반환 타입을 명확하게 지정할 수 있다.

List<String> result = queryFactory
    .select(member.username) // 프로젝션이 member 한 개
    .from(member)
    .fetch();

 

하지만 여러 개를 받고싶다면 어떻게 해야할까? [String, Team] 이렇게 여러 타입을 조회하고 싶다면?

• QueryDsl은 이런 경우, 기본적으로 Tuple로 포장해서 반환한다. (튜플 프로젝션)
  하지만 Tuple은 QueryDsl에서 제공해주는 객체라서, 컨트롤러나 서비스 계층에서 사용하기 어렵다.

List<Tuple> result = queryFactory
    .select(member.username, member.age)
    .from(member)
    .fetch();

for (Tuple tuple : result) {
    String username = tuple.get(member.username);
    Integer age = tuple.get(member.age);
    System.out.println("username=" + username);
    System.out.println("age=" + age);
}

 

 

📑 DTO 프로젝션

순수 JPQL에서는 아래와 같이 [ new MemeberDto(...) ]으로 DTO 프로젝션이 가능했었다.

생성자를 통한 방법만 제공했고, 사용하기 까다롭긴 하다.

List<MemberDto> result = em.createQuery(
        "select new study.querydsl.dto.MemberDto(m.username, m.age) " +
            "from Member m", MemberDto.class)
    .getResultList();

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

 

QueryDsl에서는 3가지 방법의 DTO 프로젝션을 지원한다.
QueryDsl이 제공하는 Projections 객체를 이용하면 쉽게 사용할 수 있다.

• 생성자 - Projections.constructor

List<MemberDto> result = queryFactory
    .select(Projections.constructor(MemberDto.class, member.username, member.age))
    .from(member)
    .fetch();

 

• 프로퍼티(Getter, Setter) 접근 - Projections.bean
  🧨 객체를 만든 다음 값을 넣는거라, 비어있는 기본생성자가 필요하다. 없으면 QueryDsl.ExpressionException 발생
  🧨 당연히 Setter가 없으면 정상 동작하지 않는다.

List<MemberDto> result = queryFactory
    .select(Projections.bean(MemberDto.class, member.username, member.age))
    .from(member)
    .fetch();

 

• 필드 직접 접근 - Projections.fields
  🧨 객체를 만든 다음 값을 넣는거라, 비어있는 기본생성자가 필요하다. 없으면 QueryDsl.ExpressionException 발생
  🧨 리플랙션을 통해 접근제어자(private)를 무시하고 강제로 값을 대입한다.

List<MemberDto> result = queryFactory
    .select(Projections.fields(MemberDto.class, member.username, member.age))
    .from(member)
    .fetch();

 

 

📑 필드 이름이 다른경우 ( as )

참고로 같은 이름의 필드를 찾아서 넣어준다.

만약 DTO 필드와 객체 필드의 이름이 다르다면, .as() 를 이용해서 별칭을 적용시켜주자.

List<UserDto> fetch = queryFactory
    .select(Projections.fields(UserDto.class,
        member.username.as("name"), // Member.username -> userDto.name
        member.age.as("userAge"))) // Member.age -> UserDto.userAge
    .from(member)
    .fetch();

 

단순 필드가 아니라, 서브쿼리를 통해 특정 값을 조회한 경우에는 ExpressionUtils.as()를 이용해서 이름을 지어주면 된다.

물론 이런식으로 이름을 바꿔서 사용할 일은 거의 없다.

List<UserDto> fetch = queryFactory
    .select(Projections.fields(UserDto.class,
                ExpressionUtils.as(member.username, "name"), // 필드로 이렇게 사용해도 된다.
                ExpressionUtils.as( // 서브쿼리인경우
                    JPAExpressions.select(memberSub.age.max()).from(memberSub),
                    "userAge")
                )
            )
    .from(member)
    .fetch();

 

 

📑 @QueryProjection ( + 생성자 )

제일 간단한 방법이다. DTO를 Q Type 으로 생성해버린다. (빌드 시)

하지만 DTO에 QueryDsl의 의존성이 생겨서 실무에 사용하기는 어려운 방법이다.

@Data
public class MemberDto {

    private String username;
    private int age;

    @QueryProjection
    public MemberDto(String username, int age) {
        this.username = username;
        this.age = age;
    }
}

 

그럼 Tuple로 받거나 귀찮은 프로젝션 과정없이, 아래와 같이 바로 사용할 수 있다.

다른 프로젝션과 다르게, 입력 값이 틀려서 오류가 생길일도 없다. 생성자가 다르면 컴파일 자체가 안되니까.

@Test
void dto() throws Exception {
    List<MemberDto> result = queryFactory
        .select(new QMemberDto(member.username, member.age))
        .from(member)
        .fetch();
}

 

---

💭 동적쿼리

📑 Where(BooleanBulider)

데이터베이스 SQL로 동적쿼리를 만드는건 까다롭지만, QueryDsl을 사용하면 매우 쉽게 할 수 있다.

Querydsl이 제공해주는 BolleanBuilder 객체를 이용해서, 여러 조건들을 받으면 된다.

private List<Member> searchMember1(String usernameCond, Integer ageCond) {
    BooleanBuilder builder = new BooleanBuilder();

    if (usernameCond != null) {
        builder.and(member.username.eq(usernameCond));
    }

    if (ageCond != null) {
        builder.and(member.age.eq(ageCond));
    }

    return queryFactory
        .selectFrom(member)
        .where(builder)
        .fetch();
}

 

📑 Where ( ..., ..., null ) 사용

앞에서 언급했지만, where(~)에는 여러 조건을 파라메타로 넘길 수 있다.

List<Member> result1 = queryFactory
    .selectFrom(member)
    .where(member.username.eq("member1"), member.age.eq(10)) // .and()와 동일
    .fetch();

 

where(...) 안에 null이 들어가면, 해당 조건을 무시하는데 이를 이용해서 아래와 같이 만들 수 있다.

메서드 반환 값을 BooleanExpression 으로 하면 된다.

private List<Member> searchMember2(String usernameCond, Integer ageCond) {
        return queryFactory
            .selectFrom(member)
            .where(usernameEq(usernameCond), ageEq(ageCond))
            .fetch();
}

private BooleanExpression usernameEq(String usernameCond) {
    return (usernameCond != null) ? member.username.eq(usernameCond) : null;
}

private BooleanExpression ageEq(Integer ageCond) {
    return (ageCond != null) ? member.age.eq(ageCond) : null;
}

 

 

순수한 자바코드이기에, 여러 조건을 조합해서 재사용할 수도 있다.

단, .and(null) 은 컴파일 오류가 발생하니 조심해서 사용해야한다.

private BooleanExpression allEq(String usernameCond, Integer ageCond) {
    return usernameEq(usernameCond).and(ageEq(ageCond));
}

 

---

💭 벌크 연산 (수정, 삭제)

JPA의 executeUpdate()와 마찬가지로, 영속성 컨텍스트를 무시하고 쿼리를 날리는 기능이 있다.

이 역시 데이터 정합성이 깨질 수 있으므로 적절하게 flush, clear 처리를 해주자.

long count = queryFactory
            .update(member)// 대량 데이터 업데이트
            .set(member.username, "비회원")
            .where(member.age.lt(28))
            .execute();

em.flush(); // 영속성 컨텍스트를 DB에 전송하고
em.clear(); // 초기화

그 외는 어려운게 없다. 그냥 쓰면 된다.

long count1 = queryFactory
    .update(member)
    .set(member.age, member.age.add(1)) // 모든 데이터에 +1
    .execute();

long count2 = queryFactory
    .delete(member)// 대량 데이터 삭제
    .where(member.age.gt(18))
    .execute();

 

 

---

💭 DB의 SQL function 호출하기

참고로 JPA에서 SQL function은 Dialect (ex H2Dialect )에 등록된 내용만 호출할 수 있다.

Dialect에 없으면 직접 등록하는 방법도 있긴한데, 그렇게까지 쓰는 경우는 잘 없으므로 넘어가도록 하자.

 

이것도 Expressions.stringTemplate(..)를 사용하면 원하는 함수를 직접 호출할 수 있다.

String result1 = queryFactory
    .select(Expressions.stringTemplate("function('replace', {0}, {1}, {2})",
        member.username, "member", "M"))
    .from(member)
    .fetchFirst();
    
    
String result2 = queryFactory
    .select(member.username)
    .from(member)
    .where(member.username.eq(Expressions.stringTemplate("function('lower', {0})",
        member.username)));

 

물론 특정 DB의 SQL함수가 아니라, ANSI 표준함수들은 QueryDsl이 대부분 내장하고 있다. 그냥 쓰면 된다.

.where(member.username.eq(member.username.lower())) // lower 함수