QueryDSL

Querydsl 소개

스프링부트 + 스프링 데이터 JPA But 복잡한 쿼리, 동적 쿼리 Querydsl 쿼리를 자바 코드로 작성, 문법 오류를 컴파일 시점에!

기본 문법

시작 - JPQL vs Querydsl

//JPQL
@Test
public void startJPQL(){
    String qlString=
        "select m from Member m "+
        "where m.username = :username";
    
    Member findMember=em.createQuery(qlString,Member.class)
        .setParameter("username","member1")
        .getSingleResult();
    
    assertThat(findMember.getUsername()).isEqualTo("member1");
}

//Querydsl
@Test
public void startQuerydsl() {
    JPAQueryFactory queryFactory = new JPAQueryFactory(em);
    QMember m = new QMember("m");
   
    Member findMember = queryFactory
        .select(m)
        .from(m)
        .where(m.username.eq("member1"))//파라미터 바인딩 처리
        .fetchOne();
    assertThat(findMember.getUsername()).isEqualTo("member1");
}

JPAQueryFactory를 필드로 제공하면 동시성 문제는 어떻게 될까? 동시성 문제는 JPAQueryFactory를 생성할 때 제공하는 EntityManager(em)에 달려있다. 스프링 프레임워크는 여러 쓰레드에서 동시에 같은 EntityManager에 접근해도, 트랜잭션 마다 별도의 영속성 컨텍스트를 제공하기 때문에, 동시성 문제는 걱정하지 않아도 된다.

기본 Q-Type 활용

Q클래스 인스턴스를 사용하는 2가지 방법

QMember qMember = new QMember("m"); //별칭 직접 지정 
QMember qMember = QMember.member; //기본 인스턴스 사용

기본 인스턴스를 static import와 함께 사용

import static study.querydsl.entity.QMember.*;

검색 조건 쿼리

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 조건을 파라미터로 처리

@Test
public void searchAndParam() {
  List<Member> result1 = queryFactory
          .selectFrom(member)
          .where(member.username.eq("member1"),
                  member.age.eq(10))
          .fetch();
  assertThat(result1.size()).isEqualTo(1);
}

where() 에 파라미터로 검색조건을 추가하면 AND 조건이 추가됨
이경우 null 값은무시 메서드추출을활용해서동적쿼리를깔끔하게만들수있음 뒤에서설명

결과조회

• fetch() : 리스트 조회, 데이터 없으면 빈 리스트 반환
• fetchOne() : 단 건 조회
  • 결과가 없으면 : null
  • 결과가 둘 이상이면 : com.querydsl.core.NonUniqueResultException
• fetchFirst() : limit(1).fetchOne()
• fetchResults() : 페이징 정보 포함, total count 쿼리 추가 실행
• fetchCount() : count 쿼리로 변경해서 count 수 조회

//List
List<Member> fetch = queryFactory
        .selectFrom(member)
        .fetch();

//단 건
Member findMember1 = queryFactory
        .selectFrom(member)
        .fetchOne();

//처음 한 건 조회
Member findMember2 = queryFactory
        .selectFrom(member)
        .fetchFirst();

//페이징에서 사용
QueryResults<Member> results = queryFactory
        .selectFrom(member)
        .fetchResults();

//count 쿼리로 변경
long count = queryFactory
        .selectFrom(member)
        .fetchCount();

정렬

List<Member> result = queryFactory
        .selectFrom(member)
        .where(member.age.eq(100))
        .orderBy(member.age.desc(), member.username.asc().nullsLast())
        .fetch();

desc() , asc() : 일반 정렬
nullsLast() , nullsFirst() : null 데이터 순서 부여

페이징

@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);
}

전체 조회 수가 필요하면?

@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 쿼리가 실행되니 성능상 주의!

실무에서 페이징 쿼리를 작성할 때, 데이터를 조회하는 쿼리는 여러 테이블을 조인해야 하지만, count 쿼리는 조인이 필요 없는 경우도 있다. 그런데 이렇게 자동화된 count 쿼리는 원본 쿼리와 같이 모두 조인을 해버리기 때문에 성능이 안나올 수 있다. count 쿼리에 조인이 필요없는 성능 최적화가 필요하다면, count 전용 쿼리를 별도로 작성해야 한다.

집합 함수

@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);
}

JPQL이 제공하는 모든 집합 함수를 제공한다.
tuple은 프로젝션과 결과반환에서 설명한다.

GroupBy 사용

@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);
}

groupBy , 그룹화된 결과를 제한하려면 having

groupBy(), having() 예시

...
    .groupBy(item.price)
    .having(item.price.gt(1000))
...

조인

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

@Test
public void join() throws Exception {
  QMember member = QMember.member;
  QTeam team = QTeam.team;
  List<Member> result = queryFactory
          .selectFrom(member)
          .join(member.team, team)
          .where(team.name.eq("teamA"))
          .fetch();
  assertThat(result)
          .extracting("username")
          .containsExactly("member1", "member2");
}

• join() , innerJoin() : 내부 조인(inner join)
• leftJoin() : left 외부 조인(left outer join)
• rightJoin() : rigth 외부 조인(rigth outer join)
• JPQL의 on과 성능 최적화를 위한 fetch 조인 제공

세타조인 연관관계가 없는 필드로 조인

• from 절에 여러 엔티티를 선택해서 세타 조인
• 외부조인불가능

조인 - on

ON절을 활용한 조인(JPA 2.1부터 지원)

1. 조인 대상 필터링
2. 연관관계 없는 엔티티 외부 조인

on 절을 활용해 조인 대상을 필터링 할 때, 외부조인이 아니라 내부조인(inner join)을 사용하면, where 절에서 필터링 하는 것과 기능이 동일하다. 따라서 on 절을 활용한 조인 대상 필터링을 사용할 때, 내부조인 이면 익숙한 where 절로 해결하고, 정말 외부조인이 필요한 경우에만 이 기능을 사용하자.

하이버네이트 5.1부터 on 을 사용해서 서로 관계가 없는 필드로 외부 조인하는 기능이 추가되었다. 물론 내부 조인도 가능하다.
주의! 문법을 잘 봐야 한다. leftJoin() 부분에 일반 조인과 다르게 엔티티 하나만 들어간다.

• 일반조인: leftJoin(member.team, team)
• on조인: from(member).leftJoin(team).on(xxx)

조인 - 페치조인

페치 조인은 SQL에서 제공하는 기능은 아니다. SQL조인을 활용해서 연관된 엔티티를 SQL 한번에 조회하는 기능이다. 주로 성능 최적화에 사용하는 방법이다.

서브쿼리

com.querydsl.jpa.JPAExpressions 사용

@Test
public void subQuery() throws Exception {
  QMember memberSub = new QMember("memberSub");
  List<Member> result = queryFactory
          .selectFrom(member)
          .where(member.age.eq(
                  JPAExpressions
                          .select(memberSub.age.max())
                          .from(memberSub)
          )) .fetch();
  assertThat(result).extracting("age")
          .containsExactly(40);
}

from 절의 서브쿼리 한계 JPA JPQL 서브쿼리의 한계점으로 from 절의 서브쿼리(인라인 뷰)는 지원하지 않는다. 당연히 Querydsl 도 지원하지 않는다. 하이버네이트 구현체를 사용하면 select 절의 서브쿼리는 지원한다. Querydsl도 하이버네이트 구현체를 사용하면 select 절의 서브쿼리를 지원한다.

from 절의 서브쿼리 해결방안

1. 서브쿼리를 join으로 변경한다. (가능한 상황도 있고, 불가능한 상황도 있다.)
2. 애플리케이션에서 쿼리를 2번 분리해서 실행한다.
3. nativeSQL을 사용한다.

Case 문

select, 조건절(where), order by에서 사용 가능

단순한 조건

List<String> result = queryFactory
        .select(member.age
                .when(10).then("열살") .when(20).then("스무살") .otherwise("기타"))
        .from(member)
        .fetch();

복잡한 조건

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();

상수, 문자 더하기

상수가 필요하면 Expressions.constant(xxx) 사용

Tuple result = queryFactory
            .select(member.username, Expressions.constant("A"))
            .from(member)
            .fetchFirst();

위와 같이 최적화가 가능하면 SQL에 constant 값을 넘기지 않는다. 상수를 더하는 것 처럼 최적화가 어려우면 SQL에 constant 값을 넘긴다.

문자 더하기 concat

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

member.age.stringValue() 부분이 중요한데, 문자가 아닌 다른 타입들은 stringValue() 로 문자로 변환할 수 있다. 이 방법은 ENUM을 처리할 때도 자주 사용한다.

중급 문법

프로젝션과 결과 반환 - 기본

프로젝션: select 대상 지정

프로젝션 대상이 하나

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

프로젝션 대상이 하나면 타입을 명확하게 지정할 수 있음 프로젝션 대상이 둘 이상이면 튜플이나 DTO로 조회

튜플조회 프로젝션 대상이 둘 이상일 때 사용 com.querydsl.core.Tuple

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 조회

순수 JPA에서 DTO 조회 코드

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

• 순수 JPA에서 DTO를 조회할 때는 new 명령어를 사용해야함
• DTO의 package이름을 다 적어줘야해서 지저분함
• 생성자 방식만 지원함

Querydsl 빈 생성(Bean population) 결과를 DTO 반환할 때 사용 다음 3가지 방법 지원

1. 프로퍼티 접근 - Setter

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

2. 필드 직접 접근

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

별칭이 다를때

List<UserDto> fetch = queryFactory
        .select(Projections.fields(UserDto.class,
                member.username.as("name"),
                ExpressionUtils.as(
                     JPAExpressions
                        .select(memberSub.age.max())
                        .from(memberSub), "age")
                )
        ).from(member)
        .fetch();

• 프로퍼티나, 필드 접근 생성 방식에서 이름이 다를 때 해결 방안
• ExpressionUtils.as(source,alias) : 필드나, 서브 쿼리에 별칭 적용
• username.as(“memberName”) : 필드에 별칭 적용

1. 생성자 사용

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

프로젝션과 결과 반환 - @QueryProjection

생성자 + @QueryProjection

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

./gradlew compileQuerydsl
QMemberDto 생성 확인

@QueryProjection 활용

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

이 방법은 컴파일러로 타입을 체크할 수 있으므로 가장 안전한 방법이다. 다만 DTO에 QueryDSL 어노테이션을 유지해야 하는 점과 DTO까지 Q 파일을 생성해야 하는 단점이 있다.

동적 쿼리 - BooleanBuilder 사용

동적 쿼리를 해결하는 두가지 방식

• BooleanBuilder
• Where 다중 파라미터 사용

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 다중 파라미터 사용

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;
}

수정, 삭제 벌크 연산

쿼리 한번으로 대량 데이터 수정

long count = queryFactory
        .update(member)
        .set(member.username, "비회원")
        .where(member.age.lt(28))
        .execute();

기본 숫자에 1 더하기

long count = queryFactory
        .update(member)
        .set(member.age, member.age.add(1))
        .execute();

곱하기:multiply(x)

쿼리 한번으로 대량 데이터 삭제

long count = queryFactory
        .delete(member)
        .where(member.age.gt(18))
        .execute();

JPQL 배치와 마찬가지로, 영속성 컨텍스트에 있는 엔티티를 무시하고 실행되기 때문에 배치 쿼리를 실행하고 나면 영속성 컨텍스트를 초기화 하는 것이 안전하다.

SQL function 호출하기

SQL function은 JPA와 같이 Dialect에 등록된 내용만 호출할 수 있다.

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

실무활용 - 순수 JPA와 Querydll

동시성 문제는 걱정하지 않아도 된다. 왜냐하면 여기서 스프링이 주입해주는 엔티티 매니저는 실제 동작 시점에 진짜 엔티티 매니저를 찾아주는 프록시용 가짜 엔티티 매니저이다. 이 가짜 엔티티 매니저는 실제 사용 시점에 트랜잭션 단위로 실제 엔티티 매니저(영속성 컨텍스트)를 할당해준다. 더 자세한 내용은 자바 ORM 표준 JPA 책 13.1 트랜잭션 범위의 영속성 컨텍스트를 참고하자.

실무활용 스프링 데이터 JPA와 Querydsl

스프링 데이터 페이징 활용1 - Querydsl 페이징 연동

• 스프링 데이터의 Page, Pageable을 활용해보자.
• 전체 카운트를 한번에 조회하는 단순한 방법
• 데이터 내용과 전체 카운트를 별도로 조회하는 방법

전체 카운트를 한번에 조회하는 단순한 방법 searchPageSimple(), fetchResults() 사용

@Override
public Page<MemberTeamDto> searchPageSimple(MemberSearchCondition condition,
                                            Pageable pageable) {
  QueryResults<MemberTeamDto> results = queryFactory
          .select(new QMemberTeamDto(
                  member.id,
                  member.username,
                  member.age,
                  team.id,
                  team.name))
          .from(member)
          .leftJoin(member.team, team)
          .where(usernameEq(condition.getUsername()),
                  teamNameEq(condition.getTeamName()),
                  ageGoe(condition.getAgeGoe()),
                  ageLoe(condition.getAgeLoe()))
          .offset(pageable.getOffset())
          .limit(pageable.getPageSize())
          .fetchResults();
  List<MemberTeamDto> content = results.getResults();
  long total = results.getTotal();
  return new PageImpl<>(content, pageable, total);

Querydsl이 제공하는 fetchResults() 를 사용하면 내용과 전체 카운트를 한번에 조회할 수 있다.(실제 쿼리는 2번 호출)
fetchResult() 는 카운트 쿼리 실행시 필요없는 order by 는 제거한다.

데이터 내용과 전체 카운트를 별도로 조회하는 방법 searchPageComplex()

@Override
public Page<MemberTeamDto> searchPageComplex(MemberSearchCondition condition, Pageable pageable) {
  List<MemberTeamDto> content = queryFactory
          .select(new QMemberTeamDto(
                  member.id,
                  member.username,
                  member.age,
                  team.id,
                  team.name))
          .from(member)
          .leftJoin(member.team, team)
          .where(usernameEq(condition.getUsername()),
                  teamNameEq(condition.getTeamName()),
                  ageGoe(condition.getAgeGoe()),
                  ageLoe(condition.getAgeLoe()))
          .offset(pageable.getOffset())
          .limit(pageable.getPageSize())
          .fetch();
  
  long total = queryFactory
          .select(member)
          .from(member)
          .leftJoin(member.team, team)
          .where(usernameEq(condition.getUsername()),
                  teamNameEq(condition.getTeamName()),
                  ageGoe(condition.getAgeGoe()),
                  ageLoe(condition.getAgeLoe()))
          .fetchCount();
  return new PageImpl<>(content, pageable, total);
}

전체 카운트를 조회 하는 방법을 최적화 할 수 있으면 이렇게 분리하면 된다. (예를 들어서 전체 카운트를 조회할 때 조인 쿼리를 줄일 수 있다면 상당한 효과가 있다.)
코드를 리펙토링해서 내용 쿼리과 전체 카운트 쿼리를 읽기 좋게 분리하면 좋다.

스프링 데이터 페이징 활용2 - CountQuery 최적화

JPAQuery<Member> countQuery = queryFactory
        .select(member)
        .from(member)
        .leftJoin(member.team, team)
        .where(usernameEq(condition.getUsername()),
                          teamNameEq(condition.getTeamName()),
                          ageGoe(condition.getAgeGoe()),
                          ageLoe(condition.getAgeLoe()));
//        return new PageImpl<>(content, pageable, total);
        return PageableExecutionUtils.getPage(content, pageable, countQuery::fetchCount);

• 스프링 데이터 라이브러리가 제공
• count 쿼리가 생략 가능한 경우 생략해서 처리
  1. 페이지 시작이면서 컨텐츠 사이즈가 페이지 사이즈보다 작을 때
  2. 마지막 페이지 일 때 (offset + 컨텐츠 사이즈를 더해서 전체 사이즈 구함)

스프링 데이터 정렬(Sort)

스프링 데이터 JPA는 자신의 정렬(Sort)을 Querydsl의 정렬(OrderSpecifier)로 편리하게 변경하는 기능을 제공한다. 이 부분은 뒤에 스프링 데이터 JPA가 제공하는 Querydsl 기능에서 살펴보겠다.

스프링 데이터의 정렬을 Querydsl의 정렬로 직접 전환하는 방법은 다음 코드를 참고하자. 스프링 데이터 Sort를 Querydsl의 OrderSpecifier로 변환

JPAQuery<Member> query = queryFactory
          .selectFrom(member);

for (Sort.Order o : pageable.getSort()){
    PathBuilder pathBuilder=new PathBuilder(member.getType(),member.getMetadata());
    query.orderBy(new OrderSpecifier(o.isAscending() ? Order.ASC : Order.DESC,pathBuilder.get(o.getProperty())));
}
List<Member> result = query.fetch(); 

정렬( Sort )은 조건이 조금만 복잡해져도 Pageable 의 Sort 기능을 사용하기 어렵다. 루트 엔티티 범위를 넘어가는 동적 정렬 기능이 필요하면 스프링 데이터 페이징이 제공하는 Sort 를 사용하기 보다는 파라미터를 받아서 직접 처리하는 것을 권장한다.

스프링데이터 JPA가 제공하는 Querydls 기능

인터페이스 지원 - QuerydslPredicateExecutor

한계점

• 조인X (묵시적 조인은 가능하지만 left join이 불가능하다.)
• 클라이언트가 Querydsl에 의존해야 한다. 서비스 클래스가 Querydsl이라는 구현 기술에 의존해야 한다.
• 복잡한 실무환경에서 사용하기에는 한계가 명확하다.

Querydsl Web 지원

한계점

• 단순한 조건만 가능
• 조건을 커스텀하는 기능이 복잡하고 명시적이지 않음
• 컨트롤러가 Querydsl에 의존
• 복잡한 실무환경에서 사용하기에는 한계가 명확

리포지토리 지원 - QuerydslRepositorySupport

장점

• getQuerydsl().applyPagination() 스프링 데이터가 제공하는 페이징을 Querydsl로 편리하게 변환 가능(단! Sort는 오류발생)
• from() 으로 시작 가능(최근에는 QueryFactory를 사용해서 select() 로 시작하는 것이 더 명시적)
• EntityManager 제공

한계

• Querydsl 3.x 버전을 대상으로 만듬
• Querydsl 4.x에 나온 JPAQueryFactory로 시작할 수 없음
  • select로 시작할 수 없음 (from으로 시작해야함)
• QueryFactory 를 제공하지 않음
• 스프링 데이터 Sort 기능이 정상 동작하지 않음

Querydsl 지원 클래스 직접 만들기

스프링 데이터가 제공하는 QuerydslRepositorySupport 가 지닌 한계를 극복하기 위해 직접 Querydsl 지원 클래스를 만들어보자.

장점

• 스프링 데이터가 제공하는 페이징을 편리하게 변환
• 페이징과 카운트 쿼리 분리 가능
• 스프링 데이터 Sort 지원
• select() , selectFrom() 으로 시작 가능
• EntityManager , QueryFactory 제공