#Step 03 — 기본 조회

@Configuration
public class QuerydslConfig {
    @Bean
    public JPAQueryFactory jpaQueryFactory(EntityManager em) {
        return new JPAQueryFactory(em);
    }
}

import static com.example.shop.entity.QCustomer.customer;
import static com.example.shop.entity.QProduct.product;
import static com.example.shop.entity.QOrder.order;

List<Customer> result = queryFactory
        .select(customer)
        .from(customer)
        .where(customer.grade.eq(Grade.VIP))
        .fetch();

// 아래 둘은 완전히 같습니다
queryFactory.select(customer).from(customer)
queryFactory.selectFrom(customer)

List<Customer> result = queryFactory
        .selectFrom(customer)
        .where(customer.grade.eq(Grade.VIP))
        .fetch();

List<String> names = queryFactory
        .select(customer.name)
        .from(customer)
        .where(customer.city.eq("서울"))
        .fetch();

List<Tuple> rows = queryFactory
        .select(customer.name, customer.points)
        .from(customer)
        .where(customer.grade.eq(Grade.VIP))
        .fetch();

for (Tuple row : rows) {
    String name = row.get(customer.name);
    Integer points = row.get(customer.points);
    System.out.println(name + " / " + points);
}

// (1) fetch — 여러 건
List<Customer> list = queryFactory
        .selectFrom(customer)
        .where(customer.city.eq("부산"))
        .fetch();

// (2) fetchOne — 단건. email 은 UNIQUE 이므로 안전합니다
Customer one = queryFactory
        .selectFrom(customer)
        .where(customer.email.eq("seojun.kim@example.com"))
        .fetchOne();

Customer gold = queryFactory
        .selectFrom(customer)
        .where(customer.grade.eq(Grade.GOLD))
        .fetchOne();          // 9건인데 fetchOne

import com.querydsl.core.NonUniqueResultException;      // QueryDSL 이 던지는 것 (잡아야 할 것)
// import jakarta.persistence.NonUniqueResultException; // Hibernate 가 던지는 것 (원인)

Customer nobody = queryFactory
        .selectFrom(customer)
        .where(customer.email.eq("nobody@example.com"))
        .fetchOne();

System.out.println(nobody);      // null

Customer any = queryFactory
        .selectFrom(customer)
        .where(customer.grade.eq(Grade.GOLD))
        .fetchFirst();          // 9건이지만 예외 없음

// 포인트가 가장 많은 고객 1명
Customer top = queryFactory
        .selectFrom(customer)
        .orderBy(customer.points.desc())
        .fetchFirst();

long total = queryFactory
        .selectFrom(customer)
        .where(customer.grade.eq(Grade.GOLD))
        .fetchCount();            // ⚠️ deprecated

Long total = queryFactory
        .select(customer.count())
        .from(customer)
        .where(customer.grade.eq(Grade.GOLD))
        .fetchOne();

Long total = queryFactory
        .select(Wildcard.count)          // com.querydsl.core.types.dsl.Wildcard
        .from(customer)
        .fetchOne();

List<String> cities = queryFactory
        .select(customer.city)
        .distinct()
        .from(customer)
        .fetch();

List<String> cities = queryFactory
        .select(customer.city)
        .from(customer)
        .fetch();

List<String> cities = queryFactory
        .selectDistinct(customer.city)
        .from(customer)
        .fetch();

List<Customer> page = queryFactory
        .selectFrom(customer)
        .orderBy(customer.points.desc())
        .offset(0)
        .limit(5)
        .fetch();

List<Customer> page2 = queryFactory
        .selectFrom(customer)
        .orderBy(customer.points.desc())
        .offset(5)
        .limit(5)
        .fetch();

public Optional<Customer> findByEmail(String email) {
    return Optional.ofNullable(
            queryFactory
                    .selectFrom(customer)
                    .where(customer.email.eq(email))
                    .fetchOne()
    );
}

Customer c = customerRepository.findByEmail(email)
        .orElseThrow(() -> new CustomerNotFoundException(email));

// null 반환 — 호출부가 검사를 잊어도 컴파일됨
Customer c = repo.findByEmail(email);
return c.getName();                       // 런타임에 NPE

// Optional 반환 — 컴파일러가 처리를 요구함
Customer c = repo.findByEmail(email).orElseThrow();
return c.getName();                       // 여기서 NPE 날 수 없음

List<Customer> none = queryFactory
        .selectFrom(customer)
        .where(customer.city.eq("제주"))
        .fetch();

System.out.println(none == null);      // false
System.out.println(none.size());       // 0

List<Customer> result = queryFactory
        .select(customer)
        // .from(customer)  ← 빠졌습니다
        .where(customer.grade.eq(Grade.VIP))
        .fetch();

JPAQuery<Customer> query = queryFactory
        .selectFrom(customer)
        .where(customer.grade.eq(Grade.VIP));

// 여기까지 실행. 로그를 보십시오.

JPAQuery<Customer> query = queryFactory
        .selectFrom(customer)
        .where(customer.grade.eq(Grade.VIP));

System.out.println("아직 실행 전");
List<Customer> result = query.fetch();      // ← 여기서 SQL 실행
System.out.println("실행 후: " + result.size());

// 삭제 대상을 "조회했다고 생각했지만" 실제로는 아무것도 안 한 코드
public void deactivateInactive() {
    queryFactory.selectFrom(customer)
            .where(customer.points.loe(0));      // fetch() 없음
    // 컴파일 OK, 실행 OK, SQL 0건. 조용히 아무 일도 안 합니다.
}

package com.example.shop.step03;

import com.example.shop.entity.Customer;
import com.example.shop.entity.Grade;
import com.querydsl.core.NonUniqueResultException;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.dsl.Wildcard;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

import static com.example.shop.entity.QCustomer.customer;
import static com.example.shop.entity.QOrder.order;
import static com.example.shop.entity.QProduct.product;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

/**
 * Step 03 — 기본 조회 : 본문 예제 전체.
 *
 * 실행 전 application.yml 에 아래가 켜져 있어야 합니다.
 *   logging.level.org.hibernate.SQL: debug
 *   logging.level.org.hibernate.orm.jdbc.bind: trace
 *
 * 이 파일의 목적은 "테스트를 통과시키는 것"이 아니라
 * "각 메서드가 만들어 내는 SQL 을 눈으로 확인하는 것" 입니다.
 * 반드시 콘솔의 hibernate.SQL 로그를 함께 보십시오.
 */
@SpringBootTest
@Transactional
class Practice {

    @Autowired
    JPAQueryFactory queryFactory;

    @PersistenceContext
    EntityManager em;

    // =================================================================
    // [3-1] 쿼리의 뼈대 — select / from / where / fetch
    // =================================================================

    @Test
    @DisplayName("[3-1] selectFrom 은 select(x).from(x) 의 축약이다")
    void 쿼리의_뼈대() {
        // (1) 풀어 쓴 형태
        System.out.println("--- (1) select(customer).from(customer) ---");
        List<Customer> a = queryFactory
                .select(customer)
                .from(customer)
                .where(customer.grade.eq(Grade.VIP))
                .fetch();

        // (2) 축약 형태
        System.out.println("--- (2) selectFrom(customer) ---");
        List<Customer> b = queryFactory
                .selectFrom(customer)
                .where(customer.grade.eq(Grade.VIP))
                .fetch();

        // 두 SQL 로그가 글자 하나 다르지 않은 것을 위에서 확인하십시오.
        assertThat(a).hasSize(4);
        assertThat(b).hasSize(4);
        assertThat(a).extracting(Customer::getName)
                .containsExactlyInAnyOrderElementsOf(b.stream().map(Customer::getName).toList());
    }

    // =================================================================
    // [3-2] 컬럼 선택 — 엔티티 전체 vs 특정 컬럼
    // =================================================================

    @Test
    @DisplayName("[3-2] 컬럼 하나만 고르면 반환 타입이 그 컬럼 타입이 된다")
    void 컬럼_하나_선택() {
        List<String> names = queryFactory
                .select(customer.name)
                .from(customer)
                .where(customer.city.eq("서울"))
                .fetch();

        // 생성 SQL: select c1_0.name from customers c1_0 where c1_0.city = ?
        names.forEach(System.out::println);
        assertThat(names).hasSize(8);
    }

    @Test
    @DisplayName("[3-2] 컬럼을 두 개 이상 고르면 Tuple 이 된다")
    void 컬럼_여러개_선택_Tuple() {
        List<Tuple> rows = queryFactory
                .select(customer.name, customer.points)
                .from(customer)
                .where(customer.grade.eq(Grade.VIP))
                .fetch();

        // 생성 SQL: select c1_0.name, c1_0.points from customers c1_0 where c1_0.grade = ?
        for (Tuple row : rows) {
            // 꺼낼 때도 "무엇으로 select 했는지"를 그대로 지정해야 타입이 살아납니다.
            String name = row.get(customer.name);
            Integer points = row.get(customer.points);
            System.out.println(name + " / " + points);
        }
        assertThat(rows).hasSize(4);
    }

    @Test
    @DisplayName("[3-2] 엔티티 전체 조회는 매핑된 전 컬럼을 나열한다")
    void 엔티티_전체_조회() {
        List<Customer> all = queryFactory
                .selectFrom(customer)
                .fetch();

        // 생성 SQL 의 select 절에 customer_id, city, created_at, email,
        // grade, name, phone, points 가 전부 나열되는 것을 확인하십시오.
        assertThat(all).hasSize(30);
    }

    // =================================================================
    // [3-3] fetch 계열 — 정상 케이스
    // =================================================================

    @Test
    @DisplayName("[3-3] fetch() 는 List 를 돌려준다")
    void fetch_여러건() {
        List<Customer> list = queryFactory
                .selectFrom(customer)
                .where(customer.city.eq("부산"))
                .fetch();

        assertThat(list).hasSize(6);
    }

    @Test
    @DisplayName("[3-3] fetchOne() 은 단건. UNIQUE 컬럼 조회에 안전하다")
    void fetchOne_단건() {
        Customer one = queryFactory
                .selectFrom(customer)
                .where(customer.email.eq("seojun.kim@example.com"))
                .fetchOne();

        // 이 SQL 에는 limit 이 붙지 않습니다. 로그로 확인하십시오.
        assertThat(one).isNotNull();
        assertThat(one.getName()).isEqualTo("김서준");
        assertThat(one.getGrade()).isEqualTo(Grade.VIP);
    }

    // =================================================================
    // [3-4] fetchOne() 의 비대칭 — 2건이면 예외, 0건이면 null
    // =================================================================

    @Test
    @DisplayName("[3-4] fetchOne() 은 2건 이상이면 NonUniqueResultException")
    void fetchOne_두건이상이면_예외() {
        // GOLD 등급 고객은 9명입니다. 예외가 나는 것이 정상 동작인 테스트입니다.
        assertThatThrownBy(() ->
                queryFactory
                        .selectFrom(customer)
                        .where(customer.grade.eq(Grade.GOLD))
                        .fetchOne()
        )
                // 겉에서 잡히는 것은 com.querydsl.core.NonUniqueResultException 입니다.
                // jakarta.persistence 쪽을 import 하면 이 단언이 실패합니다.
                .isInstanceOf(NonUniqueResultException.class)
                .hasMessageContaining("Only one result is allowed");

        // ----- 대조: 0건이면 예외가 아니라 null -----
        Customer nobody = queryFactory
                .selectFrom(customer)
                .where(customer.email.eq("nobody@example.com"))
                .fetchOne();

        assertThat(nobody).isNull();     // 예외가 아닙니다. 조용히 null 입니다.
    }

    @Test
    @DisplayName("[3-4] 0건 null 이 먼 곳에서 NPE 로 터지는 경로")
    void null_이_NPE_로_이어지는_경로() {
        Customer c = queryFactory
                .selectFrom(customer)
                .where(customer.email.eq("nobody@example.com"))
                .fetchOne();

        // 아래 줄의 주석을 풀면 NullPointerException 이 납니다.
        // 스택트레이스는 이 줄을 가리키지만, 진짜 원인은 "그 이메일이 DB 에 없다" 입니다.
        // return c.getName();

        assertThat(c).isNull();
    }

    // =================================================================
    // [3-5] fetchFirst() = limit(1).fetchOne()
    // =================================================================

    @Test
    @DisplayName("[3-5] fetchFirst() 는 SQL 에 limit ? 를 붙인다")
    void fetchFirst_는_limit_을_붙인다() {
        Customer any = queryFactory
                .selectFrom(customer)
                .where(customer.grade.eq(Grade.GOLD))
                .fetchFirst();       // 9건이지만 예외 없음

        // 생성 SQL 마지막 줄에 limit ? 가 붙은 것을 확인하십시오.
        // 3-4 의 fetchOne 로그에는 없던 줄입니다.
        assertThat(any).isNotNull();
        assertThat(any.getGrade()).isEqualTo(Grade.GOLD);
    }

    @Test
    @DisplayName("[3-5] fetchFirst() 는 거의 항상 orderBy 와 함께 써야 한다")
    void fetchFirst_는_정렬과_함께() {
        Customer top = queryFactory
                .selectFrom(customer)
                .orderBy(customer.points.desc())
                .fetchFirst();

        // 생성 SQL: ... order by c1_0.points desc limit ?
        System.out.println("포인트 1위: " + top.getName() + " / " + top.getPoints());
        assertThat(top.getName()).isEqualTo("배채영");
        assertThat(top.getPoints()).isEqualTo(52000);
    }

    // =================================================================
    // [3-6] fetchCount() / fetchResults() 가 deprecated 인 이유
    // =================================================================

    @Test
    @DisplayName("[3-6] deprecated 인 fetchCount() 의 SQL 을 확인한다")
    @SuppressWarnings("deprecation")
    void deprecated_fetchCount() {
        // ⚠️ 실무 코드에 복사하지 마십시오. SQL 을 관찰하기 위한 호출입니다.
        long total = queryFactory
                .selectFrom(customer)
                .where(customer.grade.eq(Grade.GOLD))
                .fetchCount();

        // 생성 SQL: select count(c1_0.customer_id) from customers c1_0 where c1_0.grade = ?
        assertThat(total).isEqualTo(9);
    }

    @Test
    @DisplayName("[3-6] 권장 — count 쿼리를 직접 작성한다")
    void countManually() {
        Long total = queryFactory
                .select(customer.count())
                .from(customer)
                .where(customer.grade.eq(Grade.GOLD))
                .fetchOne();

        // 위 fetchCount() 와 생성 SQL 이 동일합니다.
        // 다른 것은 "누가 그 SQL 을 결정했는가" 하나입니다.
        assertThat(total).isEqualTo(9L);
    }

    @Test
    @DisplayName("[3-6] Wildcard.count 는 count(*) 를 만든다")
    void countWildcard() {
        Long total = queryFactory
                .select(Wildcard.count)
                .from(customer)
                .fetchOne();

        // 생성 SQL: select count(*) from customers c1_0
        assertThat(total).isEqualTo(30L);
    }

    // =================================================================
    // [3-7] distinct()
    // =================================================================

    @Test
    @DisplayName("[3-7] distinct() 로 중복 도시 제거")
    void distinct_적용() {
        List<String> cities = queryFactory
                .select(customer.city)
                .distinct()
                .from(customer)
                .fetch();

        // 생성 SQL: select distinct c1_0.city from customers c1_0
        System.out.println("도시: " + cities);
        assertThat(cities).hasSize(6);
    }

    @Test
    @DisplayName("[3-7] distinct() 를 빼면 30건이 그대로 실린다")
    void distinct_미적용() {
        List<String> cities = queryFactory
                .select(customer.city)
                .from(customer)
                .fetch();

        assertThat(cities).hasSize(30);
    }

    @Test
    @DisplayName("[3-7] selectDistinct 축약형")
    void selectDistinct_축약형() {
        List<String> cities = queryFactory
                .selectDistinct(customer.city)
                .from(customer)
                .fetch();

        assertThat(cities).hasSize(6);
    }

    // =================================================================
    // [3-8] limit / offset 맛보기
    // =================================================================

    @Test
    @DisplayName("[3-8] offset(0) 은 SQL 에 나타나지 않는다")
    void limit_offset_첫페이지() {
        List<Customer> page = queryFactory
                .selectFrom(customer)
                .orderBy(customer.points.desc())
                .offset(0)
                .limit(5)
                .fetch();

        // 생성 SQL: ... order by c1_0.points desc limit ?
        // offset 0 은 기본값이라 생략됩니다.
        page.forEach(c -> System.out.println(c.getName() + " " + c.getPoints()));
        assertThat(page).hasSize(5);
    }

    @Test
    @DisplayName("[3-8] offset 이 0 이 아니면 limit ?, ? 형태가 된다 (MySQL 방언)")
    void limit_offset_둘째페이지() {
        List<Customer> page = queryFactory
                .selectFrom(customer)
                .orderBy(customer.points.desc())
                .offset(5)
                .limit(5)
                .fetch();

        // 생성 SQL: ... order by c1_0.points desc limit ?, ?
        // PostgreSQL 방언이면 limit ? offset ? 로 나갑니다.
        assertThat(page).hasSize(5);
    }

    // =================================================================
    // [3-9] Optional 로 감싸기
    // =================================================================

    /** 3-9 의 관례. 단건 조회는 Optional 로 반환합니다. */
    private Optional<Customer> findByEmail(String email) {
        return Optional.ofNullable(
                queryFactory
                        .selectFrom(customer)
                        .where(customer.email.eq(email))
                        .fetchOne()
        );
    }

    @Test
    @DisplayName("[3-9] Optional 반환이 호출부에 처리를 강제한다")
    void optional_관례() {
        Customer found = findByEmail("seojun.kim@example.com")
                .orElseThrow(() -> new IllegalStateException("고객 없음"));
        assertThat(found.getName()).isEqualTo("김서준");

        assertThatThrownBy(() ->
                findByEmail("nobody@example.com")
                        .orElseThrow(() -> new IllegalStateException("고객 없음"))
        ).isInstanceOf(IllegalStateException.class);
    }

    @Test
    @DisplayName("[3-9] fetch() 는 0건이어도 null 이 아니라 빈 리스트")
    void fetch_는_null_을_주지_않는다() {
        List<Customer> none = queryFactory
                .selectFrom(customer)
                .where(customer.city.eq("제주"))
                .fetch();

        assertThat(none).isNotNull();
        assertThat(none).isEmpty();
    }

    // =================================================================
    // [3-10] MySQL8 코스와 나란히
    // =================================================================

    @Test
    @DisplayName("[3-10] SQL 5개를 QueryDSL 로 옮긴다")
    void mysql8_대조() {
        // 1) SELECT * FROM customers
        List<Customer> q1 = queryFactory.selectFrom(customer).fetch();

        // 2) SELECT name, points FROM customers
        List<Tuple> q2 = queryFactory.select(customer.name, customer.points).from(customer).fetch();

        // 3) SELECT DISTINCT city FROM customers
        List<String> q3 = queryFactory.select(customer.city).distinct().from(customer).fetch();

        // 4) SELECT * FROM customers WHERE grade = 'VIP'
        //    'VIP' 오타는 SQL 에서 0건으로 드러나지만, Grade.VIPP 는 컴파일 에러입니다.
        List<Customer> q4 = queryFactory.selectFrom(customer).where(customer.grade.eq(Grade.VIP)).fetch();

        // 5) SELECT COUNT(*) FROM customers
        Long q5 = queryFactory.select(Wildcard.count).from(customer).fetchOne();

        assertThat(q1).hasSize(30);
        assertThat(q2).hasSize(30);
        assertThat(q3).hasSize(6);
        assertThat(q4).hasSize(4);
        assertThat(q5).isEqualTo(30L);
    }

    @Test
    @DisplayName("[3-10] 다른 엔티티에도 같은 규칙이 적용된다")
    void 다른_엔티티() {
        List<String> productNames = queryFactory
                .select(product.name)
                .from(product)
                .where(product.price.goe(new java.math.BigDecimal("100000")))
                .fetch();

        List<String> shippingCities = queryFactory
                .select(order.shippingCity)
                .distinct()
                .from(order)
                .fetch();

        System.out.println("10만원 이상 상품 " + productNames.size() + "개");
        System.out.println("배송 도시 " + shippingCities);
        assertThat(shippingCities).hasSize(6);
    }

    // =================================================================
    // [3-11] 함정 두 가지
    // =================================================================

    @Test
    @DisplayName("[3-11] from 을 빼먹으면 IllegalArgumentException: No sources given")
    void from_누락() {
        // 아래 주석을 풀면 컴파일은 되지만 실행 시점에 예외가 납니다.
        // 즉시 터지는 실패이므로 위험하지는 않습니다.
        //
        // queryFactory
        //         .select(customer)
        //         .where(customer.grade.eq(Grade.VIP))
        //         .fetch();

        // selectFrom 축약형을 쓰면 애초에 이 실수를 할 수 없습니다.
        List<Customer> ok = queryFactory
                .selectFrom(customer)
                .where(customer.grade.eq(Grade.VIP))
                .fetch();
        assertThat(ok).hasSize(4);
    }

    @Test
    @DisplayName("[3-11] fetch() 를 안 부르면 SQL 이 한 줄도 나가지 않는다")
    void fetch_안부르면_아무일도_없다() {
        // 이 테스트는 아무것도 단언하지 않습니다.
        // 아래 두 println 사이에 hibernate.SQL 로그가 없다는 것을
        // 눈으로 확인하는 것이 전부입니다.
        System.out.println("--- 여기부터 쿼리 조립 ---");

        JPAQuery<Customer> query = queryFactory
                .selectFrom(customer)
                .where(customer.grade.eq(Grade.VIP));

        System.out.println("--- 조립 끝, SQL 로그를 확인하십시오 ---");

        // 이제 실행합니다. 여기서야 SQL 이 나갑니다.
        System.out.println("--- fetch() 호출 ---");
        List<Customer> result = query.fetch();
        System.out.println("--- 결과 " + result.size() + "건 ---");

        assertThat(result).hasSize(4);
    }

    @Test
    @DisplayName("[3-11] fetch() 누락은 실패하지 않는 실패다")
    void fetch_누락은_조용하다() {
        // 컴파일 OK, 실행 OK, SQL 0건. 조용히 아무 일도 하지 않습니다.
        // IDE 의 unused return value 경고를 켜 두면 잡을 수 있습니다.
        queryFactory.selectFrom(customer)
                .where(customer.points.loe(0));

        System.out.println("위 줄에서 SQL 이 나가지 않았습니다.");
    }
}

package com.example.shop.step03;

import com.example.shop.entity.Customer;
import com.example.shop.entity.Grade;
import com.example.shop.entity.ProductStatus;
import com.querydsl.core.Tuple;
import com.querydsl.jpa.impl.JPAQueryFactory;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

import static com.example.shop.entity.QCustomer.customer;
import static com.example.shop.entity.QOrder.order;
import static com.example.shop.entity.QProduct.product;
import static org.assertj.core.api.Assertions.assertThat;

/**
 * Step 03 — 연습문제 6개.
 *
 * 규칙
 *  - 각 문제의 "여기에 작성:" 아래를 채웁니다.
 *  - 코드를 완성한 뒤 반드시 콘솔의 hibernate.SQL 로그를 확인하고,
 *    주석 안의 빈칸(___)을 직접 채우십시오. 답을 주석에 적는 것이 문제의 일부입니다.
 *  - 정답은 Solution.java 에 있습니다. 먼저 풀어 보십시오.
 */
@SpringBootTest
@Transactional
@SuppressWarnings("deprecation")   // 문제 4 에서 fetchCount() 를 일부러 호출합니다
class Exercise {

    @Autowired
    JPAQueryFactory queryFactory;

    @PersistenceContext
    EntityManager em;

    // -----------------------------------------------------------------
    // 문제 1. 특정 컬럼만 조회하고 select 절 컬럼 수를 확인하기
    //
    // 요구사항
    //  - products 에서 price >= 100000 인 상품의 "이름과 가격만" 조회합니다.
    //  - 반환 타입은 List<Tuple> 이 됩니다.
    //  - 실행 후 hibernate.SQL 로그를 보고 아래 빈칸을 채우십시오.
    //
    // 확인 1) select 절에 나온 컬럼 개수 = ___
    // 확인 2) selectFrom(product) 로 바꿨다면 몇 개였을까 = ___
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 1 — 특정 컬럼만 조회")
    void 문제1() {
        List<Tuple> rows = null;

        // 여기에 작성:


        rows.forEach(t -> System.out.println(
                t.get(product.name) + " / " + t.get(product.price)));
        assertThat(rows).isNotEmpty();
    }

    // -----------------------------------------------------------------
    // 문제 2. fetchOne() 이 0건에서 null 을 돌려주는 것을 단언하기
    //
    // 요구사항
    //  - 존재하지 않는 이메일("ghost@example.com")로 고객 1명을 조회합니다.
    //  - fetchOne() 을 사용합니다.
    //  - 결과가 예외가 아니라 null 임을 assertThat(...).isNull() 로 단언합니다.
    //
    // 확인) SQL 은 정상적으로 나갔는가? (예/아니오) = ___
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 2 — 0건이면 null")
    void 문제2() {
        Customer found = null;

        // 여기에 작성:


        assertThat(found).isNull();
    }

    // -----------------------------------------------------------------
    // 문제 3. fetchOne() 의 예외와 fetchFirst() 의 limit 를 대조하기
    //
    // 요구사항
    //  (a) grade = SILVER 인 고객(8명)에 fetchOne() 을 호출해
    //      NonUniqueResultException 이 발생함을 확인합니다.
    //      힌트: assertThatThrownBy(() -> ...).isInstanceOf(...)
    //      주의: import 는 com.querydsl.core.NonUniqueResultException 입니다.
    //  (b) 같은 조건을 fetchFirst() 로 바꿔 예외 없이 1건이 나오는지 확인합니다.
    //
    // 확인 1) (a)의 SQL 에 limit 이 있는가 = ___
    // 확인 2) (b)의 SQL 에 limit 이 있는가 = ___
    // 확인 3) (a)에서 DB 가 돌려준 행 수는 몇 건인가 (예외 메시지에 찍힙니다) = ___
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 3 — fetchOne 예외 vs fetchFirst limit")
    void 문제3() {
        // (a) 여기에 작성:


        // (b) 여기에 작성:
        Customer first = null;


        assertThat(first).isNotNull();
        assertThat(first.getGrade()).isEqualTo(Grade.SILVER);
    }

    // -----------------------------------------------------------------
    // 문제 4. fetchCount() 와 직접 작성한 count 쿼리를 비교하기
    //
    // 요구사항
    //  (a) status = ON_SALE 인 상품 수를 deprecated 인 fetchCount() 로 셉니다.
    //  (b) 같은 결과를 select(product.count()) 로 직접 작성해 셉니다.
    //  (c) 두 값이 같은지 단언합니다.
    //
    // 확인) 두 SQL 이 같은가 = ___
    //       같다면, 어떤 조건에서 달라지는가 = ___________________
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 4 — fetchCount vs 직접 작성")
    void 문제4() {
        long byDeprecated = -1;
        Long byManual = null;

        // (a) 여기에 작성:


        // (b) 여기에 작성:


        assertThat(byManual).isEqualTo(byDeprecated);
    }

    // -----------------------------------------------------------------
    // 문제 5. distinct 유무에 따른 건수 차이를 기록하기
    //
    // 요구사항
    //  - orders 의 shippingCity 를 중복 없이 조회합니다 (distinct 사용).
    //  - 같은 쿼리를 distinct 없이 한 번 더 실행합니다.
    //  - 두 결과의 size() 를 콘솔에 찍습니다.
    //
    // 확인 1) distinct 있음 = ___ 건
    // 확인 2) distinct 없음 = ___ 건
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 5 — distinct 유무 비교")
    void 문제5() {
        List<String> withDistinct = null;
        List<String> withoutDistinct = null;

        // 여기에 작성:


        System.out.println("distinct 있음 = " + withDistinct.size());
        System.out.println("distinct 없음 = " + withoutDistinct.size());
        assertThat(withDistinct.size()).isLessThan(withoutDistinct.size());
    }

    // -----------------------------------------------------------------
    // 문제 6. Optional 반환으로 리팩터링하기
    //
    // 요구사항
    //  - 아래 findByEmail 메서드를 완성합니다.
    //    fetchOne() 의 결과를 Optional.ofNullable(...) 로 감싸 반환합니다.
    //  - 테스트에서
    //      (a) 존재하는 이메일 → orElseThrow() 로 꺼내 이름이 "김서준" 인지 확인
    //      (b) 없는 이메일 → orElseThrow(CustomerNotFoundException::new) 가
    //          예외를 던지는지 확인
    //
    // 확인) null 반환 대신 Optional 을 쓰면 무엇이 달라지는가 = ___________________
    // -----------------------------------------------------------------
    private Optional<Customer> findByEmail(String email) {
        // 여기에 작성:
        return Optional.empty();
    }

    @Test
    @DisplayName("문제 6 — Optional 반환")
    void 문제6() {
        // (a) 여기에 작성:


        // (b) 여기에 작성:


    }

    /** 문제 6 에서 사용할 예외입니다. 수정할 필요 없습니다. */
    static class CustomerNotFoundException extends RuntimeException {
        CustomerNotFoundException() {
            super("고객을 찾을 수 없습니다");
        }

        CustomerNotFoundException(String email) {
            super("고객을 찾을 수 없습니다: " + email);
        }
    }
}

package com.example.shop.step03;

import com.example.shop.entity.Customer;
import com.example.shop.entity.Grade;
import com.example.shop.entity.ProductStatus;
import com.querydsl.core.NonUniqueResultException;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.dsl.Wildcard;
import com.querydsl.jpa.impl.JPAQueryFactory;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

import static com.example.shop.entity.QCustomer.customer;
import static com.example.shop.entity.QOrder.order;
import static com.example.shop.entity.QProduct.product;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

/**
 * Step 03 — 연습문제 정답과 해설.
 *
 * 문제를 먼저 풀어 본 뒤에 여십시오.
 * 각 정답에는 "왜 그 답인가" 를 설명하는 긴 주석이 붙어 있습니다.
 */
@SpringBootTest
@Transactional
@SuppressWarnings("deprecation")
class Solution {

    @Autowired
    JPAQueryFactory queryFactory;

    @PersistenceContext
    EntityManager em;

    // =================================================================
    // 정답 1 — 특정 컬럼만 조회
    // =================================================================
    //
    // 확인 1) select 절 컬럼 개수 = 2  (product_name, price 두 개)
    // 확인 2) selectFrom(product) 였다면 = 9
    //         (product_id, category_id, name, price, cost, stock,
    //          status, attrs, created_at)
    //
    // 두 SQL 을 나란히 놓고 보십시오.
    //
    //   select(product.name, product.price)
    //     → select p1_0.name, p1_0.price
    //       from products p1_0
    //       where p1_0.price >= ?
    //
    //   selectFrom(product)
    //     → select p1_0.product_id, p1_0.attrs, p1_0.category_id,
    //              p1_0.cost, p1_0.created_at, p1_0.name, p1_0.price,
    //              p1_0.status, p1_0.stock
    //       from products p1_0
    //       where p1_0.price >= ?
    //
    // 여기서 중요한 것은 attrs 입니다. products.attrs 는 JSON 컬럼이고,
    // 상품마다 크기가 제각각입니다. "이름과 가격만 화면에 뿌리는" 목록 조회에서
    // selectFrom 을 쓰면 40개 상품의 JSON 전체를 매번 네트워크로 끌어옵니다.
    // 40행이라 체감이 없을 뿐, 이 습관 그대로 수만 행 테이블에 옮기면 그대로 장애가 됩니다.
    //
    // 다만 반대편도 기억하십시오. 컬럼만 뽑으면 엔티티가 아니므로
    // 영속성 컨텍스트에 올라가지 않고, 값을 바꿔도 변경 감지가 동작하지 않습니다.
    // "읽기 전용은 컬럼/DTO, 수정 대상은 엔티티" 가 기준입니다.
    // =================================================================
    @Test
    @DisplayName("정답 1 — 특정 컬럼만 조회")
    void 정답1() {
        List<Tuple> rows = queryFactory
                .select(product.name, product.price)
                .from(product)
                .where(product.price.goe(new BigDecimal("100000")))
                .fetch();

        rows.forEach(t -> System.out.println(
                t.get(product.name) + " / " + t.get(product.price)));
        assertThat(rows).isNotEmpty();
    }

    // =================================================================
    // 정답 2 — 0건이면 null
    // =================================================================
    //
    // 확인) SQL 은 정상적으로 나갔는가? = 예.
    //
    // 이 문제의 핵심은 "아무 일도 일어나지 않았다" 가 아니라는 것입니다.
    // SQL 은 정상 실행됐고, DB 는 "조건에 맞는 행이 0개" 라고 정확히 답했습니다.
    // 에러도 경고도 없습니다. QueryDSL 은 그 0건을 null 로 번역했을 뿐입니다.
    //
    // 내부적으로는 이렇게 동작합니다.
    //   Hibernate 의 getSingleResult() 는 0건이면 NoResultException 을 던집니다.
    //   QueryDSL 의 AbstractJPAQuery.fetchOne() 은 그 예외를 catch 해서 null 로 바꿉니다.
    //
    // 즉 "예외를 삼켜 null 로 만드는" 코드가 라이브러리 안에 이미 들어 있습니다.
    // 좋게 보면 편의이고, 나쁘게 보면 실패 신호를 지운 것입니다.
    // 그래서 3-9 의 Optional 관례가 필요합니다. 정답 6 을 보십시오.
    // =================================================================
    @Test
    @DisplayName("정답 2 — 0건이면 null")
    void 정답2() {
        Customer found = queryFactory
                .selectFrom(customer)
                .where(customer.email.eq("ghost@example.com"))
                .fetchOne();

        assertThat(found).isNull();
    }

    // =================================================================
    // 정답 3 — fetchOne 예외 vs fetchFirst limit  (이 스텝에서 가장 중요한 정답)
    // =================================================================
    //
    // 확인 1) (a) fetchOne 의 SQL 에 limit 이 있는가 = 아니오
    // 확인 2) (b) fetchFirst 의 SQL 에 limit 이 있는가 = 예 (limit ?, 값 1)
    // 확인 3) (a) 에서 DB 가 돌려준 행 수 = 8건
    //
    // 두 SQL 을 나란히 놓습니다.
    //
    //   fetchOne()
    //     select c1_0.customer_id, ... from customers c1_0 where c1_0.grade = ?
    //     바인딩: [1] Grade.SILVER
    //
    //   fetchFirst()
    //     select c1_0.customer_id, ... from customers c1_0 where c1_0.grade = ?
    //     limit ?
    //     바인딩: [1] Grade.SILVER  [2] 1
    //
    // 여기서 반드시 짚어야 할 것이 있습니다.
    //
    //   ** DB 는 두 경우 모두 정상 동작했습니다. **
    //
    // (a) 에서 MySQL 은 SILVER 고객 8건을 아무 불평 없이 돌려줬습니다.
    // 예외를 던진 것은 DB 도 JDBC 도 아니고, 결과를 받은 뒤 개수를 센 자바 코드입니다.
    // 예외 메시지가 그 사실을 그대로 말해 줍니다.
    //
    //   com.querydsl.core.NonUniqueResultException: Only one result is allowed for fetchOne calls
    //   Caused by: jakarta.persistence.NonUniqueResultException:
    //             Query did not return a unique result: 8 results were returned
    //
    // "8 results were returned" — 실제 건수가 찍힙니다. 운영 장애에서 이 숫자가
    // 결정적인 단서가 됩니다. "단건인 줄 알았는데 8건이었다" 는 곧
    // "UNIQUE 제약이 없거나, 조건이 부족하거나, 데이터가 중복됐다" 는 뜻이기 때문입니다.
    //
    // 그리고 예외 이름이 두 패키지에 똑같이 존재한다는 점을 조심하십시오.
    //   com.querydsl.core.NonUniqueResultException      ← 잡아야 할 것
    //   jakarta.persistence.NonUniqueResultException    ← 원인 (Caused by)
    // import 를 잘못하면 catch 가 걸리지 않고 테스트가 실패합니다.
    //
    // 마지막으로 선택 기준입니다.
    //   "2건이 나오면 데이터가 잘못된 것"  → fetchOne()  (터지는 게 낫다)
    //   "2건이 정상이고 하나만 필요"       → fetchFirst() (+ 반드시 orderBy)
    // =================================================================
    @Test
    @DisplayName("정답 3 — fetchOne 예외 vs fetchFirst limit")
    void 정답3() {
        // (a) SILVER 8명 → 예외
        assertThatThrownBy(() ->
                queryFactory
                        .selectFrom(customer)
                        .where(customer.grade.eq(Grade.SILVER))
                        .fetchOne()
        )
                .isInstanceOf(NonUniqueResultException.class)
                .hasMessageContaining("Only one result is allowed");

        // (b) 같은 조건 + fetchFirst → limit 1 이 붙어 예외 없음
        Customer first = queryFactory
                .selectFrom(customer)
                .where(customer.grade.eq(Grade.SILVER))
                .fetchFirst();

        assertThat(first).isNotNull();
        assertThat(first.getGrade()).isEqualTo(Grade.SILVER);
    }

    // =================================================================
    // 정답 4 — fetchCount vs 직접 작성
    // =================================================================
    //
    // 확인) 두 SQL 이 같은가 = 예. 이 쿼리에서는 완전히 같습니다.
    //
    //   fetchCount()
    //     select count(p1_0.product_id) from products p1_0 where p1_0.status = ?
    //
    //   select(product.count())
    //     select count(p1_0.product_id) from products p1_0 where p1_0.status = ?
    //
    // 그럼 왜 하나는 deprecated 이고 하나는 권장일까요.
    // 답은 "이 쿼리에서는" 이라는 단서에 있습니다.
    //
    // fetchCount() 는 여러분이 쓴 쿼리를 받아 select 절만 기계적으로 count 로
    // 갈아 끼웁니다. from, join, group by, having, distinct 는 그대로 둡니다.
    // 단순 쿼리에서는 맞는 변환이고, 아래 셋에서 무너집니다.
    //
    //  (1) group by 가 있을 때
    //      "도시별 고객 수" 쿼리(6행)의 select 절만 count 로 바꾸면
    //      "그룹이 몇 개냐" 가 아니라 "각 그룹에 몇 행이냐" 를 그룹마다 돌려줍니다.
    //      단건을 기대한 자리에서 그대로 NonUniqueResultException 이 납니다.
    //
    //  (2) distinct 가 있을 때
    //      select distinct c1_0.city 는 6행입니다.
    //      select 절만 갈아 끼우면 select count(c1_0.city) 가 되어 distinct 가 사라지고
    //      30 이 나옵니다. 예외도 안 나고 숫자만 조용히 틀립니다. 가장 위험한 경우입니다.
    //
    //  (3) 컬렉션 조인 / fetch join 이 있을 때
    //      일대다를 조인하면 행이 뻥튀기됩니다. 그 위에서 세면 "주문 수" 가 아니라
    //      "주문 상세 수" 가 나옵니다. fetch join 이 섞이면 Hibernate 6 에서 예외가 납니다.
    //
    // 직접 작성하면 이 셋을 전부 여러분이 결정합니다. 게다가
    // "본 쿼리에는 필요하지만 count 에는 필요 없는 조인" 을 뺄 수 있습니다.
    // 실무에서 체감되는 이득은 대부분 여기서 나옵니다.
    //
    // fetchResults() 도 같은 이유로 deprecated 이며, 추가로 count 쿼리와 본 쿼리를
    // 항상 두 번 날린다는 문제가 있습니다. count 가 필요 없는 상황에서도 무조건 셉니다.
    // 그 낭비를 없애는 것이 Step 09 의 PageableExecutionUtils 입니다.
    //
    // 마이그레이션 요령: fetchCount() 를 전부 한꺼번에 바꾸려 하지 말고,
    // group by / distinct / 컬렉션 조인이 들어간 쿼리부터 찾아 고치십시오.
    // 나머지는 지금 당장 틀린 값을 내지는 않습니다.
    // =================================================================
    @Test
    @DisplayName("정답 4 — fetchCount vs 직접 작성")
    void 정답4() {
        // (a) deprecated
        long byDeprecated = queryFactory
                .selectFrom(product)
                .where(product.status.eq(ProductStatus.ON_SALE))
                .fetchCount();

        // (b) 권장
        Long byManual = queryFactory
                .select(product.count())
                .from(product)
                .where(product.status.eq(ProductStatus.ON_SALE))
                .fetchOne();

        System.out.println("fetchCount() = " + byDeprecated);
        System.out.println("직접 작성    = " + byManual);
        assertThat(byManual).isEqualTo(byDeprecated);
    }

    // =================================================================
    // 정답 5 — distinct 유무 비교
    // =================================================================
    //
    // 확인 1) distinct 있음 = 6건  (서울, 부산, 대구, 인천, 광주, 대전)
    // 확인 2) distinct 없음 = 600건 (주문 1건마다 도시가 하나씩)
    //
    //   select distinct o1_0.shipping_city from orders o1_0     → 6행
    //   select o1_0.shipping_city from orders o1_0              → 600행
    //
    // 차이가 100배입니다. 여기서 배울 것은 distinct 문법이 아니라
    // "select 절에 무엇을 넣느냐가 곧 네트워크로 흐르는 데이터 양" 이라는 감각입니다.
    //
    // 한 가지 경고를 덧붙입니다. 이 문제의 distinct 는 "단일 컬럼 중복 제거" 입니다.
    // 엔티티를 조회하면서 컬렉션을 조인한 뒤 붙이는 distinct 는 완전히 다른 이야기이며,
    // SQL 의 distinct 와 JPA 의 엔티티 중복 제거가 각각 따로 동작합니다.
    // Hibernate 6 부터는 후자가 기본 동작이라 distinct() 없이도 엔티티가 중복되지 않습니다.
    // 그 주제는 Step 06 에서 다룹니다. 지금 두 가지를 섞어 이해하지 마십시오.
    // =================================================================
    @Test
    @DisplayName("정답 5 — distinct 유무 비교")
    void 정답5() {
        List<String> withDistinct = queryFactory
                .select(order.shippingCity)
                .distinct()
                .from(order)
                .fetch();

        List<String> withoutDistinct = queryFactory
                .select(order.shippingCity)
                .from(order)
                .fetch();

        System.out.println("distinct 있음 = " + withDistinct.size());
        System.out.println("distinct 없음 = " + withoutDistinct.size());

        assertThat(withDistinct).hasSize(6);
        assertThat(withoutDistinct).hasSize(600);
    }

    // =================================================================
    // 정답 6 — Optional 반환
    // =================================================================
    //
    // 확인) null 반환 대신 Optional 을 쓰면 무엇이 달라지는가
    //       = "없을 때 무엇을 할지" 를 호출부가 결정하도록 컴파일러가 강제한다.
    //
    // 코드는 세 줄입니다. 중요한 것은 왜 이 세 줄이 관례가 됐는가입니다.
    //
    // fetchOne() 이 null 을 돌려주면, 그 null 은 아무 흔적도 남기지 않고
    // 호출부로 흘러갑니다. 그리고 한참 뒤에 NPE 로 터집니다.
    //
    //   [Repository]  Customer c = ... .fetchOne();   // null 발생 지점
    //   [Service]     return toDto(c);                // null 통과
    //   [Controller]  model.addAttribute(dto);        // null 통과
    //   [View/직렬화]  dto.getName()                   // ← 여기서 NPE
    //
    // 스택트레이스는 마지막 줄을 가리킵니다. 하지만 진짜 원인은 첫 줄,
    // 정확히는 "사용자가 입력한 이메일이 DB 에 없다" 는 사실입니다.
    // 발생 지점과 원인 지점이 계층 세 개만큼 떨어져 있으면,
    // 로그만 보고 원인을 찾는 데 몇 시간이 걸립니다.
    //
    // Optional 은 그 거리를 0 으로 만듭니다.
    // Optional<Customer> 를 받은 호출부는 orElseThrow / orElse / ifPresent 중
    // 무엇이든 써야 하고, 그것을 쓰는 순간 "없으면 어떡하지" 를 생각하게 됩니다.
    // 즉 Optional 의 가치는 null 을 없애는 것이 아니라
    // ** 판단을 강제하고, 실패 지점을 원인 지점으로 끌어오는 것 ** 입니다.
    //
    // 주의할 점 두 가지.
    //  - Optional 은 반환 타입에만 씁니다. 필드/파라미터/컬렉션 원소에 쓰지 않습니다.
    //  - Optional.get() 은 검사 없이 쓰면 null 과 다를 바 없습니다. orElseThrow() 를 쓰십시오.
    //
    // 그리고 List 반환에는 Optional 을 씌우지 않습니다.
    // fetch() 는 0건이면 빈 리스트를 돌려주지 null 을 돌려주지 않기 때문입니다.
    // Optional<List<T>> 는 "비어 있음" 을 표현하는 방법을 둘로 늘릴 뿐입니다.
    // =================================================================
    private Optional<Customer> findByEmail(String email) {
        return Optional.ofNullable(
                queryFactory
                        .selectFrom(customer)
                        .where(customer.email.eq(email))
                        .fetchOne()
        );
    }

    @Test
    @DisplayName("정답 6 — Optional 반환")
    void 정답6() {
        // (a) 존재하는 이메일
        Customer found = findByEmail("seojun.kim@example.com")
                .orElseThrow(CustomerNotFoundException::new);
        assertThat(found.getName()).isEqualTo("김서준");

        // (b) 없는 이메일 → 예외. NPE 가 아니라 "무엇이 없는지" 를 말하는 예외입니다.
        assertThatThrownBy(() ->
                findByEmail("ghost@example.com")
                        .orElseThrow(CustomerNotFoundException::new)
        )
                .isInstanceOf(CustomerNotFoundException.class)
                .hasMessageContaining("고객을 찾을 수 없습니다");
    }

    static class CustomerNotFoundException extends RuntimeException {
        CustomerNotFoundException() {
            super("고객을 찾을 수 없습니다");
        }
    }

    // =================================================================
    // 보너스 — Wildcard.count 와 customer.count() 의 차이
    // =================================================================
    //
    // 연습문제에는 없지만 실무에서 자주 나오는 질문입니다.
    //
    //   select(Wildcard.count)      → select count(*) from customers c1_0
    //   select(customer.count())    → select count(c1_0.customer_id) from customers c1_0
    //
    // 결과 값은 이 경우 둘 다 30 으로 같습니다. PK 는 NOT NULL 이므로
    // count(pk) 와 count(*) 가 같은 값을 냅니다.
    //
    // 달라지는 경우는 NULL 이 있는 컬럼을 셀 때입니다.
    //   select(customer.phone.count())  → select count(c1_0.phone) ...  → 27
    // customers 30명 중 phone 이 NULL 인 3명은 세지 않습니다.
    // count(컬럼) 은 "NULL 이 아닌 행" 만 센다는 SQL 의 규칙이 그대로 적용됩니다.
    // (MySQL8 코스 부록 A — NULL 완전 정복과 같은 이야기입니다.)
    //
    // 실무 선택: 전체 행 수를 셀 때는 Wildcard.count 또는 pk.count() 중
    // 팀 컨벤션을 하나로 정해 쓰십시오. 중요한 것은 "무심코 NULL 있는 컬럼을 세지 않는 것" 입니다.
    // =================================================================
    @Test
    @DisplayName("보너스 — count(*) vs count(컬럼)")
    void 보너스_카운트_차이() {
        Long star = queryFactory.select(Wildcard.count).from(customer).fetchOne();
        Long pk = queryFactory.select(customer.count()).from(customer).fetchOne();
        Long phone = queryFactory.select(customer.phone.count()).from(customer).fetchOne();

        System.out.println("count(*)        = " + star);   // 30
        System.out.println("count(pk)       = " + pk);     // 30
        System.out.println("count(phone)    = " + phone);  // 27  ← NULL 3명 제외

        assertThat(star).isEqualTo(30L);
        assertThat(pk).isEqualTo(30L);
        assertThat(phone).isEqualTo(27L);
    }
}