QueryDSL로 복잡한 동적 검색 쿼리 설계하기

// 이런 코드가 만들어진다
@Query("""
    SELECT d FROM Document d
    WHERE (:statuses IS NULL OR d.status IN :statuses)
    AND (:categories IS NULL OR d.category IN :categories)
    AND (:startDate IS NULL OR d.createdAt >= :startDate)
    AND (:endDate IS NULL OR d.createdAt <= :endDate)
    AND (:domains IS NULL OR d.domain IN :domains)
    AND (:keyword IS NULL OR d.title LIKE %:keyword% OR d.content LIKE %:keyword%)
    AND d.deletedAt IS NULL
    """)
List<Document> search(
    @Param("statuses") List<String> statuses,
    @Param("categories") List<String> categories,
    // ...
);

// build.gradle.kts
dependencies {
    implementation("com.querydsl:querydsl-jpa:5.1.0:jakarta")
    annotationProcessor("com.querydsl:querydsl-apt:5.1.0:jakarta")
    annotationProcessor("jakarta.annotation:jakarta.annotation-api")
    annotationProcessor("jakarta.persistence:jakarta.persistence-api")
}
 
// Q클래스 생성 경로 설정
val generated = "src/main/generated"
 
sourceSets {
    main {
        java.srcDirs(generated)
    }
}
 
tasks.withType<JavaCompile> {
    options.generatedSourceOutputDirectory = file(generated)
}
 
tasks.named("clean") {
    doLast {
        file(generated).deleteRecursively()
    }
}

@Repository
@RequiredArgsConstructor
public class DocumentQueryRepository {
 
    private final JPAQueryFactory queryFactory;
 
    public Page<Document> search(DocumentSearchCondition condition, Pageable pageable) {
        List<Document> content = queryFactory
                .selectFrom(document)
                .where(
                        statusIn(condition.statuses()),
                        categoryIn(condition.categories()),
                        dateRangeBetween(condition.startDate(), condition.endDate()),
                        domainIn(condition.domains()),
                        keywordContains(condition.keyword()),
                        notDeleted()  // 소프트 딜리트 조건은 항상 포함
                )
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .orderBy(document.createdAt.desc())
                .fetch();
 
        Long total = queryFactory
                .select(document.count())
                .from(document)
                .where(
                        statusIn(condition.statuses()),
                        categoryIn(condition.categories()),
                        dateRangeBetween(condition.startDate(), condition.endDate()),
                        domainIn(condition.domains()),
                        keywordContains(condition.keyword()),
                        notDeleted()
                )
                .fetchOne();
 
        return new PageImpl<>(content, pageable, total != null ? total : 0);
    }
 
    // 각 조건을 메서드로 분리 — null이면 조건 제외
    private BooleanExpression statusIn(List<DocumentStatus> statuses) {
        if (statuses == null || statuses.isEmpty()) return null;
        return document.status.in(statuses);
    }
 
    private BooleanExpression categoryIn(List<String> categories) {
        if (categories == null || categories.isEmpty()) return null;
        return document.category.in(categories);
    }
 
    private BooleanExpression dateRangeBetween(LocalDate startDate, LocalDate endDate) {
        if (startDate == null && endDate == null) return null;
        if (startDate == null) return document.createdAt.loe(endDate.atTime(23, 59, 59));
        if (endDate == null) return document.createdAt.goe(startDate.atStartOfDay());
        return document.createdAt.between(
                startDate.atStartOfDay(),
                endDate.atTime(23, 59, 59)
        );
    }
 
    private BooleanExpression domainIn(List<String> domains) {
        if (domains == null || domains.isEmpty()) return null;
        return document.domain.in(domains);
    }
 
    private BooleanExpression keywordContains(String keyword) {
        if (keyword == null || keyword.isBlank()) return null;
        return document.title.containsIgnoreCase(keyword)
                .or(document.content.containsIgnoreCase(keyword));
    }
 
    private BooleanExpression notDeleted() {
        return document.deletedAt.isNull();
    }
}

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class SoftDeleteBaseEntity {
 
    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;
 
    @LastModifiedDate
    private LocalDateTime updatedAt;
 
    private LocalDateTime deletedAt;
 
    public boolean isDeleted() {
        return deletedAt != null;
    }
 
    public void softDelete() {
        this.deletedAt = LocalDateTime.now();
    }
}

-- documentKey에 unique 인덱스 (논리 삭제를 고려)
-- 삭제된 같은 key가 재등록될 수 있으므로 단순 unique 인덱스는 불가
CREATE UNIQUE INDEX idx_document_key_not_deleted
ON document (document_key)
WHERE deleted_at IS NULL;  -- 부분 인덱스 (PostgreSQL)
 
-- 검색에 자주 쓰이는 복합 인덱스
CREATE INDEX idx_document_search
ON document (status, category, domain, created_at)
WHERE deleted_at IS NULL;  -- 삭제된 데이터 제외

CREATE UNIQUE INDEX idx_document_key_active
ON document (document_key)
WHERE deleted_at IS NULL;

// Repository에서 활성 문서 중 같은 키가 있는지 확인
public boolean existsActiveByDocumentKey(String documentKey) {
    return queryFactory
            .selectOne()
            .from(document)
            .where(
                    document.documentKey.eq(documentKey),
                    document.deletedAt.isNull()
            )
            .fetchFirst() != null;
}