Chapter 12. 객체지향 쿼리 언어

SELECT m FROM Member AS m WHERE m.username = 'Hello'

// 반환 타입이 명확할 때 → TypedQuery
TypedQuery<Member> query =
    em.createQuery(
        "SELECT m FROM Member m",
        Member.class);
List<Member> list = query.getResultList();

// 반환 타입이 불명확할 때 → Query
Query query =
    em.createQuery(
        "SELECT m.username, m.age FROM Member m");
List resultList = query.getResultList();

for (Object o : resultList) {
    Object[] row = (Object[]) o;
    String username = (String) row[0];
    Integer age = (Integer) row[1];
}

// 이름 기준 (권장)
em.createQuery(
    "SELECT m FROM Member m WHERE m.username = :name",
    Member.class)
  .setParameter("name", "kim")
  .getResultList();

// 위치 기준
em.createQuery(
    "SELECT m FROM Member m WHERE m.username = ?1",
    Member.class)
  .setParameter(1, "kim")
  .getResultList();

// Object[] 로 조회 (번거로움)
List<Object[]> list = em.createQuery(
    "SELECT m.username, m.age FROM Member m")
    .getResultList();

for (Object[] row : list) {
    String username = (String) row[0];
    Integer age = (Integer) row[1];
}

// NEW 명령어로 DTO 직접 매핑 (권장)
List<MemberDTO> list = em.createQuery(
    "SELECT new jpabook.dto.MemberDTO(m.username, m.age) " +
    "FROM Member m", MemberDTO.class)
    .getResultList();

em.createQuery("SELECT m FROM Member m ORDER BY m.age DESC",
    Member.class)
  .setFirstResult(10)  // 시작 위치 (0부터)
  .setMaxResults(20)   // 조회할 데이터 수
  .getResultList();

// 통계 쿼리 예시
Long count = em.createQuery(
    "SELECT COUNT(m) FROM Member m", Long.class)
    .getSingleResult();

Double avgAge = em.createQuery(
    "SELECT AVG(m.age) FROM Member m", Double.class)
    .getSingleResult();

// 내부 조인
SELECT m FROM Member m
  INNER JOIN m.team t
  WHERE t.name = '팀A'

// 외부 조인
SELECT m FROM Member m
  LEFT JOIN m.team t

// 세타 조인 (WHERE 절, 내부 조인만)
SELECT COUNT(m) FROM Member m, Team t
  WHERE m.username = t.name

// 페치 조인 문법
SELECT m FROM Member m JOIN FETCH m.team

// N+1 문제 발생 (LAZY 로딩)
List<Member> members = em.createQuery(
    "SELECT m FROM Member m", Member.class)
    .getResultList();

// 회원마다 팀 접근 시 SQL 추가 실행 → N+1 문제!
for (Member m : members) {
    System.out.println(m.getTeam().getName());
}

// 페치 조인으로 해결 (SQL 1번)
List<Member> members = em.createQuery(
    "SELECT m FROM Member m JOIN FETCH m.team",
    Member.class)
    .getResultList();

// 이미 실제 엔티티가 로딩됨 → 추가 SQL 없음
for (Member m : members) {
    System.out.println(m.getTeam().getName());
}

-- 페치 조인 실행 SQL
SELECT M.*, T.*
FROM MEMBER M
INNER JOIN TEAM T ON M.TEAM_ID = T.ID

// 일대다 페치 조인 시 데이터 중복 발생
SELECT t FROM Team t JOIN FETCH t.members

// DISTINCT로 중복 제거
SELECT DISTINCT t FROM Team t JOIN FETCH t.members

SELECT m.username   // 상태 필드
  FROM Member m
  JOIN m.team t     // 단일 값 연관 필드
  JOIN m.orders o   // 컬렉션 값 연관 필드

// 묵시적 조인 발생 (SQL에서 INNER JOIN)
SELECT m.team.name FROM Member m

// 명시적 조인 권장 (제어 가능)
SELECT t.name FROM Member m JOIN m.team t

// 컬렉션에서 바로 경로 탐색 → 오류!
SELECT t.members.username FROM Team t

// 조인으로 별칭을 얻어서 탐색 → 정상
SELECT m.username FROM Team t JOIN t.members m

// 나이가 평균보다 많은 회원
SELECT m FROM Member m
WHERE m.age > (SELECT AVG(m2.age) FROM Member m2)

// 팀A 소속인 회원 (EXISTS)
SELECT m FROM Member m
WHERE EXISTS (
    SELECT t FROM m.team t WHERE t.name = '팀A'
)

-- 기본 CASE
SELECT
    CASE WHEN m.age <= 10 THEN '학생요금'
         WHEN m.age >= 60 THEN '경로요금'
         ELSE '일반요금'
    END
FROM Member m

-- COALESCE (null이 아닌 첫 번째 값)
SELECT COALESCE(m.username, '이름 없음')
FROM Member m

-- NULLIF (두 값이 같으면 null)
SELECT NULLIF(m.username, '관리자')
FROM Member m

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "DTYPE")
public abstract class Item { ... }

@Entity @DiscriminatorValue("B")
public class Book extends Item { ... }

-- TYPE: 특정 자식 타입만 조회
SELECT i FROM Item i
WHERE TYPE(i) IN (Book, Movie)

-- TREAT: 부모를 자식 타입으로 캐스팅 (JPA 2.1)
SELECT i FROM Item i
WHERE TREAT(i AS Book).author = 'kim'

@Entity
@NamedQuery(
    name = "Member.findByUsername",
    query = "SELECT m FROM Member m " +
            "WHERE m.username = :username")
public class Member { ... }

// 사용
List<Member> members = em.createNamedQuery(
    "Member.findByUsername", Member.class)
    .setParameter("username", "kim")
    .getResultList();

// 엔티티 직접 사용 (둘 다 같은 SQL)
SELECT COUNT(m) FROM Member m
SELECT COUNT(m.id) FROM Member m

-- 실행 SQL (동일)
SELECT COUNT(m.id) FROM MEMBER m

// JPQL: SELECT m FROM Member m
//       WHERE m.username = '회원1'
//       ORDER BY m.age DESC

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Member> cq = cb.createQuery(Member.class);

Root<Member> m = cq.from(Member.class);

cq.select(m)
  .where(cb.equal(m.get("username"), "회원1"))
  .orderBy(cb.desc(m.get("age")));

List<Member> result = em.createQuery(cq).getResultList();

JPAQuery query = new JPAQuery(em);
QMember m = QMember.member;

List<Member> members = query
    .from(m)
    .where(m.name.eq("회원1"))
    .orderBy(m.name.desc())
    .list(m);

QItem item = QItem.item;

List<Item> list = query
    .from(item)
    .where(item.name.eq("좋은상품")
        .and(item.price.gt(20000)))
    .list(item);

QOrder order = QOrder.order;
QMember member = QMember.member;

// 페치 조인
query.from(order)
     .innerJoin(order.member, member).fetch()
     .list(order);

BooleanBuilder builder = new BooleanBuilder();

if (name != null) {
    builder.and(item.name.contains(name));
}
if (price != null) {
    builder.and(item.price.gt(price));
}

query.from(item)
     .where(builder)
     .list(item);

// 프로퍼티 접근 (Setter)
List<ItemDTO> result = query.from(item)
    .list(Projections.bean(ItemDTO.class,
        item.name.as("username"),
        item.price));

// 생성자 사용
List<ItemDTO> result = query.from(item)
    .list(Projections.constructor(ItemDTO.class,
        item.name, item.price));

// Criteria - 복잡하고 장황
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Member> cq = cb.createQuery(Member.class);
Root<Member> m = cq.from(Member.class);
cq.select(m)
  .where(cb.equal(m.get("username"), "kim"))
  .orderBy(cb.desc(m.get("age")));

// QueryDSL - 직관적이고 간결
QMember m = QMember.member;
query.from(m)
     .where(m.username.eq("kim"))
     .orderBy(m.age.desc())
     .list(m);

// 엔티티 조회 (영속성 컨텍스트에서 관리됨)
List<Member> members = em.createNativeQuery(
    "SELECT ID, AGE, NAME, TEAM_ID " +
    "FROM MEMBER WHERE AGE > ?",
    Member.class)
    .setParameter(1, 20)
    .getResultList();

// 재고 10개 미만인 상품 가격 10% 인상
int count = em.createQuery(
    "UPDATE Product p " +
    "SET p.price = p.price * 1.1 " +
    "WHERE p.stockAmount < :stock")
    .setParameter("stock", 10)
    .executeUpdate();

// 가장 실용적인 패턴
int count = em.createQuery(
    "UPDATE Product p SET p.price = p.price * 1.1")
    .executeUpdate();

em.clear();  // 영속성 컨텍스트 초기화

// 이후 조회 시 DB에서 새로운 값을 가져옴
Product product = em.find(Product.class, productId);

// em.find() - 두 번째는 1차 캐시에서 반환
Member m1 = em.find(Member.class, 1L);  // DB 조회
Member m2 = em.find(Member.class, 1L);  // 1차 캐시

// JPQL - 매번 DB 조회, 하지만 같은 인스턴스 반환
Member m1 = em.createQuery(
    "SELECT m FROM Member m WHERE m.id = :id",
    Member.class)
    .setParameter("id", 1L)
    .getSingleResult();  // DB 조회

Member m2 = em.createQuery(
    "SELECT m FROM Member m WHERE m.id = :id",
    Member.class)
    .setParameter("id", 1L)
    .getSingleResult();  // DB 조회 (항상)

// m1 == m2 → true (동일성 보장)

// AUTO (기본값) - 커밋 또는 쿼리 실행 직전에 플러시
em.setFlushMode(FlushModeType.AUTO);

// COMMIT - 커밋 시에만 플러시
em.setFlushMode(FlushModeType.COMMIT);

// JPA를 우회하기 전에 수동 플러시
em.flush();

// JDBC 직접 사용
Session session = em.unwrap(Session.class);
session.doWork(connection -> {
    // JDBC 작업 ...
});