Querydsl 기본 문법 정리

- 조건 검색

where(조건)

• null 값일 경우 무시

user.name.eq("홍길동") 			// name = '홍길동'
user.name.ne("홍길동") 			// name != '홍길동'
user.name.eq("홍길동").not() 		// name != '홍길동'
user.name.isNotNull()    		// name is not null

user.age.in(10, 20) 			// age in(10, 20)
user.age.notIn(10, 20) 			// age not in(10, 20)
user.age.between(10,30) 		// 10 <= age <= 30
user.age.goe(30) 			// age >= 30
user.age.gt(30) 			// age > 30
user.age.loe(30) 			// age <= 30
user.age.lt(30) 			// age < 30

user.name.like("홍%") 			// like '홍%'
user.name.contains("길") 		// like '%길%'
user.name.startsWith("홍") 		// like '홍%'

List<User> result = queryFactory
        .select(user)
        .from(user)
        .where(user.name.eq("홍길동"))
        .fetch();

// And
List<User> result = queryFactory
        .select(user)
        .from(user)
        .where(user.name.eq("홍길동"))
        	.and(user.age.in(10, 20))
        .fetch();
        
List<User> result = queryFactory
        .select(user)
        .from(user)
        .where(user.name.eq("홍길동"), user.age.in(10, 20))
        .fetch();

// OR
List<User> result = queryFactory
        .select(user)
        .from(user)
        .where(user.name.eq("홍길동"))
        	.or(user.age.in(10, 20))
        .fetch();

---

- 결과 조회

• fetch(): 리스트 조회, 데이터 없으면 빈 리스트 반환
• fetchOne(): 리스트 조회, 데이터 없으면 null 반환 (결과가 2개 이상일 경우 NonUniqueResultException 예외 발생)
• fetchFirst(): limit(1)
• fetchOne(): limit(1)
• fetchResults(): 페이징 정보 포함하여 조회. total count 쿼리 추가 실행
  
  • 조인이 필요 없는 경우에도 fetchResults 쿼리를 사용하면,
    total count를 구할 때 모두 조인하여 성능이 저하될 수 있으므로,
    count 쿼리를 따로 작성하는 것이 좋음
• fetchCount():  total count 쿼리로 변경하여 조회

List<User> result = queryFactory
        .select(user)
        .from(user)
        .fetch();
        
        
QueryResults<User> results = queryFactory
        .selectFrom(user)
        .fetchResults();

---

- 정렬

orderBy(정렬 조건)

• desc() : 내림차순
• asc() : 올림차순
• nullsFirst() : null 순서 처음으로
• nullsLast() : null 순서 마지막으로

List<User> result = queryFactory
        .selectFrom(user)
        .orderBy(user.name.desc(), user.age.asc().nullsLast())
        .fetch();

---

- 페이징

• offset(): 시작점 설정
• limit(): 데이터 개수
• listResults(): 페이징 형태로 반환 (QueryResults 객체로 반환)
  
  • QueryResults.getTotal(): 전체 건 수
  • QueryResults.getLimit(): limit
  • QueryResults.getOffset(): offset
  • QueryResults.getResults(): 결과 값

List<User> result = queryFactory
        .selectFrom(user)
        .offset(0)
        .limit(10)
        .fetch();

---

- Join

join(조인 대상, 별칭 쿼리 타입)

• join()
  
  • innerJoin() 동일
• leftJoin()
• rightJoin()
• fullJoin()
• on()
  • join, innerJoin의 경우 where 사용
  • leftJoin, rightJoin, fullJoin의 경우 on 사용

List<User> result = queryFactory
    .selectFrom(user)
    .join(user.team, team)
    .where(team.name.eq("BlueTeam"))
    .fetch();
    
List<User> result = queryFactory
    .selectFrom(user)
    .leftJoin(user.team, team)
    	.on(team.name.eq("BlueTeam"))
    .fetch();

---

- 서브 쿼리

• JPAExpressions:  JPAExpressions.select()......
• 주로 QType을 정의하고 사용

QUser userSub = new QUser("userSub");

// select절에 사용
List<User> result1 = queryFactory
    .select(user.name,
        JPAExpressions
            .select(userSub.age.max())
            .from(userSub)
    .from(user)
    .fetch();

// where절에 사용
List<User> result2 = queryFactory
    .selectFrom(user)
    .where(user.age.eq(
        JPAExpressions
            .select(userSub.age.max())
            .from(userSub)
    ))
    .fetch();
    
// in절도 가능
List<User> result3 = queryFactory
    .selectFrom(user)
	.where(member.age.in(
        JPAExpressions
            .select(memberSub.age)
            .from(memberSub)
            .where(memberSub.age.between(10,20))
    ))
    .fetch();

 

• static import
  • 깔끔하게 코드 사용 가능

import static com.querydsl.jpa.JPAExpressions.select;

QUser userSub = new QUser("userSub");

List<User> result = queryFactory
    .selectFrom(user)
    .where(user.age.eq(
        select(userSub.age.max())
        .from(userSub)
    ))
    .fetch();

---

- 그룹화

• groupby()
• having()

---

- 집합 함수

Tuple 형태로 결과 값 리턴

• count()
• sum()
• avg()
• max()
• min()

List<Tuple> result = queryFactory
                .select(team.name, user.age.avg())
                .from(user)
                .join(user.team, team)
                .groupBy(team.name)
                .fetch();

---

- Case

• when()
• then()
• otherwise()

// ==
List<String> result = queryFactory
    .select(user.age
        .when(10).then("10살")
        .when(20).then("20살")
        .when(30).then("30살")
        .otherwise("나머지"))
    .from(user)
    .fetch();

// 조건을 넣을 수도 있음
List<String> result = queryFactory
    .select(user.age
        .when(user.age.between(10, 19)).then("10대")
        .when(user.age.between(20, 29)).then("20대")
        .when(user.age.between(30, 39)).then("30대")
        .otherwise("나머지"))
    .from(user)
    .fetch();

---

- 문자 더하기

• concat() : 문자열 뒤에 이어서 더함
• prepend() : 문자열 맨 앞에 더함 (앞이 아닌 맨 앞!)
• stringValue() 함수를 통해 문자로 변환 가능

String result = queryFactory
    .select(user.name.concat("_").concat(user.age.stringValue()).prepend("사용자_")) // 사용자_name_age
    .from(user)
    .fetch()