페이징과 정렬 — 대량 데이터를 나눠서 조회하는 전략

// 0번째 페이지, 10건 조회, age 내림차순 정렬
Pageable pageable = PageRequest.of(0, 10, Sort.by("age").descending());

// 여러 정렬 조건
Pageable pageable = PageRequest.of(0, 10,
    Sort.by(Sort.Order.desc("age"), Sort.Order.asc("name")));

public interface MemberRepository extends JpaRepository<Member, Long> {

    // Page 반환 — COUNT 쿼리 자동 실행
    Page<Member> findByAge(int age, Pageable pageable);

    // Slice 반환 — COUNT 쿼리 없음
    Slice<Member> findByTeamName(String teamName, Pageable pageable);

    // List 반환 — 페이징만, 전체 수 불필요
    List<Member> findByName(String name, Pageable pageable);
}

Page<Member> page = memberRepository.findByAge(20, PageRequest.of(0, 10));

List<Member> content = page.getContent();       // 조회된 데이터
int totalPages = page.getTotalPages();           // 전체 페이지 수
long totalElements = page.getTotalElements();    // 전체 데이터 수
boolean hasNext = page.hasNext();                // 다음 페이지 존재 여부
int number = page.getNumber();                   // 현재 페이지 번호

-- 실제 실행되는 쿼리 2개
SELECT * FROM member WHERE age = 20 ORDER BY id LIMIT 10 OFFSET 0;
SELECT COUNT(*) FROM member WHERE age = 20;

Slice<Member> slice = memberRepository.findByTeamName("teamA", PageRequest.of(0, 10));

List<Member> content = slice.getContent();
boolean hasNext = slice.hasNext();    // 다음 페이지 존재 여부
// slice.getTotalElements()  — 사용 불가!
// slice.getTotalPages()     — 사용 불가!

-- 실제 실행되는 쿼리 1개 (11건 조회 → 다음 페이지 존재 여부 판단)
SELECT * FROM member WHERE team_name = 'teamA' ORDER BY id LIMIT 11 OFFSET 0;

@Query(value = "SELECT m FROM Member m LEFT JOIN m.team t WHERE m.age > :age",
       countQuery = "SELECT COUNT(m) FROM Member m WHERE m.age > :age")
Page<Member> findByAgeWithCount(@Param("age") int age, Pageable pageable);

// QueryDSL 등에서 커스텀 페이징 시 사용
JPAQuery<Long> countQuery = queryFactory
    .select(member.count())
    .from(member)
    .where(condition);

return PageableExecutionUtils.getPage(content, pageable, countQuery::fetchOne);

// Controller에서 요청 파라미터로 정렬 받기
// GET /members?page=0&size=10&sort=age,desc&sort=name,asc
@GetMapping("/members")
public Page<MemberDto> list(Pageable pageable) {
    return memberRepository.findAll(pageable).map(MemberDto::from);
}

// 이런 정렬은 Sort로 불가능 → 직접 쿼리 작성
// ORDER BY CASE WHEN status = 'ACTIVE' THEN 0 ELSE 1 END

@Query("SELECT m FROM Member m ORDER BY " +
       "CASE WHEN m.status = 'ACTIVE' THEN 0 ELSE 1 END")
List<Member> findAllOrderByStatus(Pageable pageable);

-- 100,001번째부터 10건 → 앞의 100,000건을 모두 스캔
SELECT * FROM member ORDER BY id LIMIT 10 OFFSET 100000;

public List<MemberDto> findMembersAfter(Long lastId, int size) {
    return queryFactory
        .select(new QMemberDto(member.id, member.name, member.age))
        .from(member)
        .where(
            member.id.gt(lastId)  // 마지막 조회 ID 이후부터
        )
        .orderBy(member.id.asc())
        .limit(size + 1)          // 다음 페이지 존재 여부 확인용
        .fetch();
}

// Controller
@GetMapping("/members")
public CursorResponse<MemberDto> list(
        @RequestParam(required = false) Long lastId,
        @RequestParam(defaultValue = "20") int size) {

    List<MemberDto> result = memberQueryRepository
        .findMembersAfter(lastId != null ? lastId : 0L, size);

    boolean hasNext = result.size() > size;
    if (hasNext) {
        result = result.subList(0, size); // 마지막 1건 제거
    }

    Long nextCursor = hasNext ? result.get(result.size() - 1).getId() : null;
    return new CursorResponse<>(result, nextCursor, hasNext);
}