📘 JPQL

• 특징
  - 대상은 객체 (테이블이 아님)
  - 영속성 컨택스트 활용 가능
  - 컴파일 시점에 엔티티-필드타입 확인 후 오류 감소

---

📖 JPQL 문법

📌 결과 조회

▶️ 타입 정하기

❶ TypeQuery

• 타입이 명확할때 ! (주로 엔티티나 특정 타입이 있을때)
• 주로 사용한다!

TypedQuery<Tutor> typeQuery1 = em.createQuery("select t from Tutor t", Tutor.class);
TypedQuery<String> typeQuery2 = em.createQuery("select t.name from Tutor t", String.class);

---

❷Query

• 반환 타입 명확하지 않을때 ( = 다양한 타입의 데이터 반환)
• Object로 반환하므로 형변환 필요할 수도

Query query = em.createQuery("select t.name, t.age from Tutor t");

▶️ 결과 조회

❶ getResultList()

• 결과가 하나 이상일 때 사용한다.
• List 반환 (결과가 없다면 빈 List 반환)

List resultList = em.createQuery("select t from Tutor t").getResultList();

---

❷ getSingleResult()

• 결과가 딱 하나일때
• 쿼리 뒤에 엔티티 클래스를 명시해준다 (반환타입)

Tutor singleResult = em.createQuery("select t from Tutor t where t.id = 1L", Tutor.class).getSingleResult();

---

📌 파라미터 바인딩

동적으로 값을 전달한다, 쿼리 재사용 가능

Tutor wonuk = em.createQuery("select t from Tutor t where t.name = ✅:name", Tutor.class)
                    .setParameter("name", "wonuk")✅파라미터 지정
                    .getSingleResult();
System.out.println("wonuk.getName() = " + wonuk.getName());
System.out.println("wonuk.getAge() = " + wonuk.getAge());

---

📌 @Embedded / @Embeddedable

▶️ JPA에서 여러 필드를 하나의 값 객체로 묶어 사용하는 어노테이션

✅@Embeddable - 값을 정의하는 쪽. 내장될 클래스 (예: Period, Address)
✅ @Embedded - 값을 사용하는 쪽. 엔티티에 포함시키는 필드 (예: Tutor.period)

▶️ 상황 예시

상황	설명
값들을 한 덩어리로 표현하고 싶을 때	기간(시작~종료), 주소(시/도/우편번호), 이름(성/이름) 등
여러 엔티티에서 중복된 값 구조가 나올 때	예: Period를 Tutor, Employee에서 함께 쓰고 싶을 때
값 자체의 비즈니스 로직을 포함할 수 있게 하고 싶을 때	Period.isWork(Date) 처럼 해당 값만의 메서드 만들 수 있음

❶ @Embedded 사용

@Entity
public class Tutor {
		
		@Id
		@GeneratedValue
		private Long id;
		
		private String name;
		
		@Embedded // ✅ Embedded 사용
		private Period period;

}

---

❷ @Embeddable 사용

@Embeddable// ✅ Embedded 정의
public class Period {
 
  @Temporal(TemporalType.DATE) <--- ✅ 날짜 매핑에 사용
  Date startDate;
 
  @Temporal(TemporalType.Date)
  Date endDate;
 
  public boolean isWork (Date date) { <--- ✅ 자체 검증 로직
	    // startDate <= date <= endDate 확인
      return (startDate == null || !date.before(startDate)) &&
             (endDate == null || !date.after(endDate));
  }
}

---

❸ 데이터 조회

id	name	start_date	end_date

• tutor 테이블에 period 가 아닌,
  period 내 필드인 startDate, endDate가 나온다

---

📌 프로젝션(Projection)

▶️ 쿼리에서 어떤 데이터를 가져올 지 선택하는 것 ( select 어떤거 할지? )

▶️ 왜 사용하는가?

• 모든 데이터를 다 가져오는 건 비효율적
• 필요한 필드만 조회하면 성능 최적화 가능
• 네트워크 비용 절감, 조회 속도 향상

❶ Entity 프로젝션

• 엔티티 전체를 통째로 조회하는 방식
• 조회된 객체는 영속성 컨텍스트에 의해 관리된다 (Dirty Checking 가능)

Tutor tutor = new Tutor("wonuk", 100);
em.persist(tutor);

// 영속성 컨텍스트 초기화 → 조회한 tutor는 더 이상 관리되지 않음
em.flush();
em.clear();

// Tutor 엔티티 전체 조회
List<Tutor> tutorList = em.createQuery("select t from Tutor t", Tutor.class).getResultList();
Tutor wonuk = tutorList.get(0);

// 엔티티가 다시 영속성 컨텍스트에 들어와서 변경 감지 가능
wonuk.setName("wonuk2");

• 🧷 연관 엔티티 조회: 묵시적 vs 명시적 JOIN

  // 묵시적 JOIN → JPQL에서는 작성하지 않았지만 내부적으로 JOIN 발생
  Company company = em.createQuery(
      "select t.company from Tutor t", Company.class
  ).getSingleResult();
  
  // 명시적 JOIN → 쿼리에서 JOIN을 명확히 선언
  Company companyV2 = em.createQuery(
      "select t from Tutor t join t.company", Company.class
  ).getSingleResult();

  • 💡 묵시적 JOIN은 SQL을 예측하기 어려워 위험함
    → 명시적으로 JOIN을 선언하는 것이 좋다.

---

❷ Embedded 프로젝션

List<Period> periods = em.createQuery(
	"select t.period from Tutor t", Period.class).getResultList();

* `select p from Period p` → ❌ 불가능
* Embedded 객체는 독립적인 엔티티가 아니기 때문

---

✔️ 조건 검색 예시

// Embedded 내부 필드 접근 가능
"select t from Tutor t where t.period.startDate < :today"

✔️ 상속 구조 → 직관적

"select t from Tutor t where t.startDate < :today"
// → 이건 period 없이 바로 접근 가능 (MappedSuperclass의 경우)

---

❸ Scalar 프로젝션

• 엔티티가 아닌 단일 필드(문자열, 숫자 등) 또는 여러 필드만 조회할 때

List<Object[]> resultList = em.createQuery(
    "select t.name, t.age from Tutor t"
).getResultList();

Object[] result = resultList.get(0);
System.out.println("이름: " + result[0]);  // name
System.out.println("나이: " + result[1]);  // age

📌 결과는 Object[] 배열로 리턴되므로, 형변환 필요

• 💡 확장 → DTO 프로젝션

  // DTO에 생성자 필요: public TutorDto(String name, int age)
  List<TutorDto> dtos = em.createQuery(
     "select new com.example.TutorDto(t.name, t.age) from Tutor t", TutorDto.class ).getResultList();

  Scalar 프로젝션을 더 명확하게 사용하고 싶다면 DTO에 직접 매핑하는 방법이 가장 깔끔하고 안전

---

📌 페이징(Paging)

▶️ JPQL은 기본적으로 LIMIT, OFFSET 같은 SQL 문법을 직접 쓰지 않고
JPA가 제공하는 메서드로 페이징 처리를 한다.

▶️ 사용 메서드

메서드	설명
setFirstResult(int)	조회 시작 위치 (OFFSET)
setMaxResults(int)	가져올 데이터 개수 (LIMIT)

---

List<Tutor> tutorList = em.createQuery(
  "select t from Tutor t order by t.age desc", Tutor.class
)
.setFirstResult(5)     // 6번째 데이터부터 조회 (OFFSET = 5)
.setMaxResults(10)     // 총 10개 조회 (LIMIT = 10)
.getResultList();

for (Tutor tutor : tutorList) {
  System.out.println("tutor = " + tutor.getId() + ", " + tutor.getName() + ", " + tutor.getAge());
}

• order by t.age desc
  → 나이 순서대로 내림차순 정렬 (가장 나이 많은 튜터부터)
• setFirstResult(5)
  → 6번째 데이터부터 시작
• setMaxResults(10)
  → 10개 데이터만 조회

---

📘 fetch join

JPA에서의 N+1 문제를 해결한다

---

📖 fetch join 사용법

📌 Entity fetch join (N:1, 1:1)

▶️ 지연로딩(LAZY) 설정된 연관 엔티티를 JOIN과 동시에 한 번에 가져오는 방법

String query = "select t from Tutor t join fetch t.company";

❶ Tutor가 Company를 참조하고 있고,
❷ t.getCompany().getName() 로 접근하면 원래는 쿼리 또 날아가야하는데
❸ fetch join을 쓰면 그 전에 미리 Company까지 같이 가져온다
→ 쿼리 한 번으로 둘 다 가져오니까 N+1 문제 해결!

• ✅ 장점: 깔끔하게 한 번에 가져와서 성능 좋음
• ⚠️ 주의: 무조건 다 들고오니까 필요 없을 땐 오히려 과하게 가져올 수도

---

📌 Collection fetch join

▶️ 한 엔티티가 여러 개를 갖고 있는 컬렉션(예: 회사 → 튜터 목록)을 한 번에 가져오는 방식

String query = "select c from Company c join fetch c.tutorList";

❶ Company 하나에 Tutor 여러 명 붙어있으면,
❷ SQL은 Tutor 수만큼 Company가 중복돼서 나온다
→ 근데 JPA는 알아서 같은 Company는 한 번만 만들어준다!

• ✅ 장점: N+1 문제 없이 Company와 Tutor를 한 번에 다 가져옴
• ⚠️ 단점: 페이징(setFirstResult, setMaxResults) 안 됨
  → 전부 다 불러온 다음 자바 메모리에서 잘라버림 (데이터 많으면 위험)

---

📌 @BatchSize

▶️ 지연로딩은 유지하면서, 한 번에 여러 개를 IN 쿼리로 가져오는 방식

@BatchSize(size = 100)
@OneToMany(mappedBy = "company")
private List<Tutor> tutorList;

❶ 예를 들어 Company 2개가 있을 때,
❷ 각 Company의 tutorList를 조회하려고 하면
❸ Tutor를 하나씩 쿼리하는 게 아니라
→ Tutor WHERE company_id IN (1, 2) 이런 쿼리로 한 번에!

✅ 장점: 페이징 가능! 쿼리도 줄어듦
⚠️ 주의: 한 번에 너무 많이 로딩하면 메모리 터질 수도 있으니 size 조절 중요

---

🌟 JPQL 실습 코드

- 쿼리 예시

❶ Repository의 튜터별 학생 수 메서드

public interface TutorRepository extends JpaRepository<Tutor, Long> {

    @Query("select new com.example.springjpql.dto.TutorStudentCountDto(t.name, count(s)) " +
            "from Tutor t join t.students s group by t.name")
    List<TutorStudentCountDto> findTutorStudentCounts();
}

❷ Repository의 학생 조건부 검색 메서드

@Query("select new com.example.springjpql.dto.StudentDto(s.name, s.age) " +
        "from Student s where s.name like %:keyword% " +
        "and s.age >= :minAge and s.age <= :maxAge")
List<StudentDto> findByNameContainingAndAgeBetween(
        @Param("keyword") String keyword,
        @Param("minAge") int minAge,
        @Param("maxAge") int maxAge
);

- 테스트 데이터 추가하기

❶ 프로필 설정하기 ( application.yml )

profiles:
  active: dev ✅

❷ 테스트용 데이터 추가 ( config 패키지 )

• @PostConstruct 로 Application 최초 실행 시에만 초기화 하도록 설정
• @Profile("dev") dev 프로필에서만 동작하도록 설정

@Slf4j
@Component
@Profile("dev") ✅
public class DataInitializer {

    @Autowired
    private TutorRepository tutorRepository;

    @Autowired
    private StudentRepository studentRepository;

    @PostConstruct ✅
    public void init() {
        // Tutor 데이터 초기화
        Tutor tutor1 = new Tutor("tutor1");
        Tutor tutor2 = new Tutor("tutor2");
        Tutor tutor3 = new Tutor("tutor3");

        tutorRepository.save(tutor1);
        tutorRepository.save(tutor2);
        tutorRepository.save(tutor3);

        // Student 데이터 초기화
        for (int i = 0; i < 30; i++) {
            Student student = new Student("student" + i, 20 + i);
            // 튜터를 순차적으로 할당
            if (i % 3 == 0) {
                student.setTutor(tutor1);
            } else if (i % 3 == 1) {
                student.setTutor(tutor2);
            } else {
                student.setTutor(tutor3);
            }
            studentRepository.save(student);
        }
        log.info("===== Test Data Initialized =====");
    }
}