JPQL (Java Persistence Query Language)

JOY🌱·2023년 4월 10일

🐸 JPA

목록 보기

5/8

💁‍♀️ JPQL이란,
엔티티 객체를 중심으로 개발할 수 있는 객체 지향 쿼리

SQL보다 간결하며 DBMS에 상관없이 개발이 가능
(방언을 통해 해결되며 해당 DBMS에 맞는 SQL을 실행. 특정 DBMS에 의존 X)

JPQL은 find() 메소드를 통한 조회와 다르게 항상 데이터베이스에 SQL을 실행해서 결과를 조회
(영속성 컨텍스트에 이미 존재하면 기존 엔티티를 반환하고 조회한 것은 버림)

JPQL은 엔티티 객체를 대상으로 쿼리를 질의하고 SQL은 데이터베이스의 테이블을 대상으로 질의함. 즉, JPQL은 결국 SQL로 변환됨

🙋‍ JPQL 사용 방법

작성한 JPQL(문자열)을 em.createQuery 메소드를 통해 쿼리 객체로 만듬. 쿼리 객체는 TypedQuery, Query로 두 가지가 존재
- TypedQuery : 반환할 타입을 명확하게 지정하는 방식일 때 사용(쿼리 객체의 메소드 실행 결과로 지정한 타입이 반환됨)
- Query : 반환할 타입을 명확하게 지정할 수 없을 때 사용(쿼리 객체 메소드의 실행 결과로 Object or Object[]이 반환됨)

쿼리 객체에서 제공하는 메소드 getSingleResult() 또는 getResultList()를 호출해서 쿼리를 실행하고 데이터베이스를 조회
- getSingleResult() : 결과가 정확히 한 행일 경우 사용 (없거나 많으면 예외 발생)
- getResultList() : 결과가 2행 이상일 경우 사용하며 컬렉션을 반환 (결과가 없으면 빈 컬렉션 반환)

👀 Simple

✅ TypedQuery / Query 단일메뉴조회

createQuery() getSingleResult()

◼ TypedQuery

@Test
public void TypedQuery를_이용한_단일메뉴_조회_테스트() {
		
	// when
	String jpql ="SELECT m.menuName FROM section01_menu AS m WHERE m.menuCode = 181";
	TypedQuery<String> query = entityManager.createQuery(jpql, String.class);
		
	String resultMenuName = query.getSingleResult();
		
	// then
	assertEquals("짜장바나나스무디", resultMenuName);
		
}

◼ Query

@Test
public void Query를_이용한_단일메뉴_조회_테스트() {
		
	// when
	String jpql ="SELECT m.menuName FROM section01_menu AS m WHERE m.menuCode = 181";
	Query query = entityManager.createQuery(jpql);		// 결과 값의 타입을 명시하지 않음(예측불가이기 때문)
		
	Object resultMenuName = query.getSingleResult();	// 결과 값은 Object로 반환 됨
		
	// then
	assertTrue(resultMenuName instanceof String); // String 타입의 인스턴스인지 확인
	assertEquals("짜장바나나스무디", resultMenuName);
		
}

✅ TypedQuery 단일 행 조회

@Test
public void JPQL을_이용한_단일행_조회_테스트() {
		
	// when
	String jpql = "SELECT m FROM section01_menu AS m WHERE m.menuCode = 666";
	TypedQuery<Menu> query = entityManager.createQuery(jpql, Menu.class);	// 반환 타입을 row와 매핑할 엔티티 타입으로 설정

	Menu foundMenu = query.getSingleResult();
		
	// then
	assertEquals(666, foundMenu.getMenuCode());
	System.out.println(foundMenu);
		
}

💻 Mini Console

Menu [menuCode=666, menuName=Owner산낙지크로플, menuPrice=15000, categoryCode=4, orderableStatus=Y]

✅ TypedQuery / Query 여러 행 조회

getResultList() forEach()

◼ TypedQuery

@Test
public void TypedQuery를_이용한_여러행_조회_테스트() {
		
	// when
	String jpql = "SELECT m FROM section01_menu AS m";
	TypedQuery<Menu> query = entityManager.createQuery(jpql, Menu.class);	// 반환 타입을 row와 매핑할 엔티티 타입으로 설정

	List<Menu> foundMenuList = query.getResultList();
		
	// then
	assertNotNull(foundMenuList);
	foundMenuList.forEach(System.out::println);
		
}

◼ Query

@Test
public void Query를_이용한_여러행_조회_테스트() {
		
	// when
	String jpql = "SELECT m FROM section01_menu AS m";
	Query query = entityManager.createQuery(jpql);

	List<Menu> foundMenuList = query.getResultList(); // query는 Object 타입이지만, List<Menu>로 다운캐스팅 시켜서 그대로 받기 가능
		
	// then
	assertNotNull(foundMenuList);
	foundMenuList.forEach(System.out::println);
		
}

💻 Mini Console

Menu [menuCode=61, menuName=짜장바나나스무디, menuPrice=20000, categoryCode=7, orderableStatus=Y]
Menu [menuCode=81, menuName=치즈똥아이스크림, menuPrice=7000, categoryCode=7, orderableStatus=Y]
Menu [menuCode=101, menuName=미공개계절메뉴, menuPrice=10000, categoryCode=5, orderableStatus=Y]
...

✅ 연산자를 활용한 조회

◼ DISTINCT

@Test
public void distinct를_활용한_중복제거_여러_행_조회_테스트() {
		
	// when
	String jpql = "SELECT DISTINCT m.categoryCode FROM section01_menu AS m";
	TypedQuery<Integer> query = entityManager.createQuery(jpql, Integer.class);
	List<Integer> categoryCodeList = query.getResultList();
		
	// then
	assertNotNull(categoryCodeList);
	categoryCodeList.forEach(System.out::println);
		
}

◼ IN

@Test
public void in_연산자를_활용한_조회_테스트() {
		
	/* categoryCode가 6, 10인 메뉴 목록 조회 출력 */
	// when
	String jpql = "SELECT m FROM section01_menu AS m WHERE m.categoryCode IN (6, 10)";
	Query query = entityManager.createQuery(jpql);
	List<Menu> menuList = query.getResultList();
		
	// then
	assertNotNull(menuList);
	menuList.forEach(System.out::println);

}

◼ LIKE

@Test
public void like_연산자를_활용한_조회_테스트() {
		
	/* 마늘이 들어가는 메뉴명을 가진 메뉴 목록 조회 출력 */
	// when
	String jpql = "SELECT m FROM section01_menu AS m WHERE menuName LIKE '%마늘%'";
	Query query = entityManager.createQuery(jpql);
	List<Menu> menuList = query.getResultList();
		
	// then
	assertNotNull(menuList);
	menuList.forEach(System.out::println);
		
}

👀 Parameter

setParameter()

🙋‍ 파라미터 바인딩 하는 방법

이름 기준 파라미터(named parameters)
: 다음에 이름 기준 파라미터를 지정

위치 기준 파라미터(positional parameters)
? 다음에 값을 주고 위치 값은 1부터 시작

✅ 이름 기준 파라미터

@Test
public void 이름_기준_파라미터_바인딩_메뉴_목록_조회_테스트() {
		
	// given
	String menuNameParameter = "치즈똥아이스크림";
		
	// when
	String jpql = "SELECT m FROM section02_menu m WHERE m.menuName = :menuName";
		
	List<Menu> menuList = entityManager.createQuery(jpql, Menu.class)
									   .setParameter("menuName", menuNameParameter) // jpql 쿼리문 안의 :menuName과 동일하게 작성해야함
									   .getResultList();
		
	// then
	assertNotNull(menuList);
	menuList.forEach(System.out::println);
		
}

💻 Mini Console

Menu [menuCode=81, menuName=치즈똥아이스크림, menuPrice=7000, categoryCode=7, orderableStatus=Y]

✅ 위치 기준 파라미터

@Test
public void 위치_기준_파라미터_바인딩_메뉴_목록_조회_테스트() {
		
	// given
	String menuNameParameter = "아보카도스무디";
		
	// when
	String jpql = "SELECT m FROM section02_menu m WHERE m.menuName = ?1";
		
	List<Menu> menuList = entityManager.createQuery(jpql, Menu.class)
				   					   .setParameter(1, menuNameParameter) // jpql 쿼리문 안의 ?1에 들어갈 위치 및 변수 작성
				   					   .getResultList();

	// then
	assertNotNull(menuList);
	menuList.forEach(System.out::println);
		
}

💻 Mini Console

Menu [menuCode=999, menuName=아보카도스무디, menuPrice=20000, categoryCode=333, orderableStatus=Y]

👀 Projection

💁‍♀️ Projection이란,
SELECT 절에 조회할 대상을 지정하는 것
(SELECT {프로젝션 대상} FROM)

🙋‍ 프로젝션 대상의 방식

엔티티 프로젝션

원하는 객체를 바로 조회할 수 있음

조회된 엔티티는 '영속성 컨텍스트'가 관리 (엔티티 프로젝션만!)

임베디드 타입 프로젝션

엔티티와 거의 비슷하게 사용되며 조회의 시작점이 될 수 없음
=> from 절에 사용 불가

주로 많이 사용하는 요소들만을 조회할 때 많이 사용

임베디드 타입은 영속성 컨텍스트에서 관리되지 않음

스칼라 타입 프로젝션

숫자, 문자, 날짜 같은 기본 데이터 타입

스칼라 타입은 영속성 컨텍스트에서 관리되지 않음

new 명령어를 활용한 프로젝션

다양한 종류의 단순 값들을 DTO로 바로 조회하는 방식으로 new 패키지명.DTO명을 쓰면 해당 DTO로 바로 반환받을 수 있음

new 명령어를 사용한 클래스의 객체는 엔티티가 아니므로 영속성 컨텍스트에서 관리되지 않음

✅ 엔티티 프로젝션

◼ 단일 엔티티

@Test
public void 단일_엔티티_프로젝션_테스트() {
    	
    // when
    String jpql = "SELECT m FROM section03_menu m";
    List<Menu> menuList = entityManager.createQuery(jpql, Menu.class).getResultList();
    	
    // then
    assertNotNull(menuList);
    /* 엔티티 프로젝션은 영속성 컨텍스트에서 관리하는 객체가 됨 */
    EntityTransaction tran = entityManager.getTransaction();
    tran.begin();
    menuList.get(1).setMenuName("test");
    tran.commit();
    	
}

◼ 양방향 연관관계 엔티티

/* BiDirectionCategory 엔티티 */ 
@Entity(name="section03_bidirection_category")
@Table(name="TBL_CATEGORY")
public class BiDirectionCategory {

    @Id
    @Column(name="CATEGORY_CODE")
    private int categoryCode;

    @Column(name="CATEGORY_NAME")
    private String categoryName;

    @Column(name="REF_CATEGORY_CODE")
    private Integer refCategoryCode;

    @OneToMany(mappedBy = "category")
    private List<BiDirectionMenu> menuList;
    
    /* 생성자, getter&setter, toString(반드시 menuList 출력 부분은 제거할 것) */
    
}

/* BiDirectionMenu 엔티티 */
@Entity(name="section03_bidirection_menu")
@Table(name="TBL_MENU")
public class BiDirectionMenu {

    @Id
    @Column(name="MENU_CODE")
    private int menuCode;

    @Column(name="MENU_NAME")
    private String menuName;

    @Column(name="MENU_PRICE")
    private int menuPrice;

    @ManyToOne
    @JoinColumn(name="CATEGORY_CODE")
    private BiDirectionCategory category;

    @Column(name="ORDERABLE_STATUS")
    private String orderableStatus;
    
    /* 생성자, getter&setter, toString */

}

@Test
public void 양방향_연관관계_엔티티_프로젝션_테스트() {
    	
    // given
    int menuCodeParameter = 3;
    	
    // when
    String jpql = "SELECT m.category FROM section03_bidirection_menu m WHERE m.menuCode = :menuCode";
    BiDirectionCategory categoryOfMenu = entityManager.createQuery(jpql, BiDirectionCategory.class)
    												  .setParameter("menuCode", menuCodeParameter)
    												  .getSingleResult();
    	
    // then
    assertNotNull(categoryOfMenu);
    System.out.println(categoryOfMenu);
    /* 양방향 연관관계에 있는 엔티티의 경우 역방향 객체 그래프 탐색이 가능 */
    assertNotNull(categoryOfMenu.getMenuList());
    categoryOfMenu.getMenuList().forEach(System.out::println);
    	
}

💻 Mini Console

BiDirectionMenu{menuCode=143, menuName='크림치즈떡', menuPrice=6000, category=BiDirectionCategory{categoryCode=10, categoryName='기타', refCategoryCode=2}, orderableStatus='Y'}
BiDirectionMenu{menuCode=2, menuName='우럭뽈살젤리', menuPrice=5000, category=BiDirectionCategory{categoryCode=10, categoryName='기타', refCategoryCode=2}, orderableStatus='Y'}
...

✅ 임베디드 타입 프로젝션

@Embedded @Embeddable

/* EmbeddedMenu 엔티티 */
@Entity(name="section03_embedded_menu")
@Table(name="TBL_MENU")
public class EmbeddedMenu {
	
	@Id							
	@Column(name="MENU_CODE")
	private int menuCode;
	
	@Embedded // 값 타입을 사용하는 곳에 적음
	private MenuInfo menuInfo;
	
	@Column(name="CATEGORY_CODE")
	private int categoryCode;
	@Column(name="ORDERABLE_STATUS")
	private String orderableStatus;
    
    /* 기본 셋팅 */
    
}

/* MenuInfo 클래스 */
/* 임베디드 타입(embedded type, 복합 값 타입 또는 내장 타입) 
 * 새로운 값 타입을 직접 정의한 것으로 주로 기본 값 타입을 모아서 만든 하나의 타입을 말함.
 * 엔티티의 필드 중 일부분을 하나의 임베디드 타입으로 정의하면 알아보기 쉽고, 재사용성이 높게 디자인 할 수 있어 유지보수에 용이
 * */
@Embeddable // 값 타입을 정의하기 위한 어노테이션
public class MenuInfo {

	/* '메뉴명'과 '가격'이 많이 사용된다는 가정 하에 임베디드 타입 예시 작성 */
	@Column(name="MENU_NAME")
	private String menuName;
	
	@Column(name="MENU_PRICE")
	private int menuPrice;
    
    /* 기본 셋팅 */
    
}

@Test
public void 임베디드_타입_프로젝션_테스트() {
    	
    // when
    String jpql = "SELECT m.menuInfo FROM section03_embedded_menu m";
    List<MenuInfo> menuInfoList = entityManager.createQuery(jpql, MenuInfo.class).getResultList();
    	
    // then
    assertNotNull(menuInfoList);
    menuInfoList.forEach(System.out::println);
    	
}

💻 Mini Console

MenuInfo [menuName=JPA산 짬뽕맛 막걸리, menuPrice=15000]
MenuInfo [menuName=아보카도스무디, menuPrice=20000]
MenuInfo [menuName=짜장바나나스무디, menuPrice=20000]
MenuInfo [menuName=치즈똥아이스크림, menuPrice=7000]
...

✅ 스칼라 타입 프로젝션

◼ TypedQuery를 이용한 스칼라 타입 (단일행)

@Test
public void TypedQuery를_이용한_스칼라_타입_프로젝션_테스트() {
    	
    // when
    String jpql = "SELECT c.categoryName FROM section03_category c";
    List<String> categoryNameList = entityManager.createQuery(jpql, String.class).getResultList();
    	
    // then
    assertNotNull(categoryNameList);
    categoryNameList.forEach(System.out::println);
   }

◼ Query를 이용한 스칼라 타입 (다중열)

/* 조회하려는 컬럼 값이 1개인 경우 TypeQuery로 반환 타입을 단일 값에 대해 지정할 수 있지만 다중 열 컬럼을 조회하는 경우 타입을 지정하지 못 함 
 * 그때는 TypedQuery 대신 Query를 사용하여 Object[]로 행의 정보를 반환 받아 사용
 * */
@Test
public void Query를_이용한_스칼라_타입_프로젝션_테스트() {
    	
    // when
    String jpql = "SELECT c.categoryCode, c.categoryName FROM section03_category c";
    List<Object[]> categoryList = entityManager.createQuery(jpql).getResultList();
    	
    // then
    /* row : forEach를 사용 시, Object[]의 한 행씩 출력이 되므로 그것(row)을 for문으로 다시 column 까지 출력 */
    assertNotNull(categoryList);
    categoryList.forEach(row -> { 
    	for(Object column : row) 
    		System.out.print(column + " "); 
    });
}
    
/* Object를 일일히 인덱스별로 처리하거나 다운캐스팅 하는 것은 번거롭기 때문에 new 명령어를 활용한 프로젝션을 더 많이 활용 */

💻 Mini Console

1 식사 2 음료 3 디저트 4 한식 5 중식 6 일식 7 퓨전 ...

✅ new 명령어를 활용한 프로젝션

/* CategoryInfo 클래스 */
/* 이 클래스는 엔티티로 설정하지 않음
 * 다만 여러 컬럼 정보를 의미 있는 단위로 묶기 위한 용도의 클래스 ('4. new 명령어를 활용한 프로젝션'에 사용됨) */
public class CategoryInfo {

	private int categoryCode;
	private String categoryName;
    
    /* 기본 셋팅 */
    
}

@Test
public void new_명령어를_활용한_프로젝션_테스트() {
    	
    // when
    /* CategoryInfo 클래스의 매개변수 생성자를 호출해서 해당 값으로 반환받음
     * (FROM 절은 해당 컬럼이 실제로 존재하는 엔티티명을 작성) */
    String jpql = "SELECT new com.greedy.section03.projection.CategoryInfo(c.categoryCode, c.categoryName) FROM section03_category c";
    List<CategoryInfo> categoryInfoList = entityManager.createQuery(jpql, CategoryInfo.class).getResultList();
    	
    // then
    assertNotNull(categoryInfoList);
    categoryInfoList.forEach(System.out::println);
    	
}

💻 Mini Console

CategoryInfo [categoryCode=1, categoryName=식사]
CategoryInfo [categoryCode=2, categoryName=음료]
CategoryInfo [categoryCode=3, categoryName=디저트]
...

👀 Paging

✅ Paging API 활용

setFirstResult() setMaxResults()

@Test
public void 페이징_API를_이용한_조회_테스트() {
    	
    // given
    int offset = 15;	// 조회를 건너 뛸 행의 수 (limit이 5라는 가정하에, 0이면 첫 페이지, 5면 두 번째 페이지)
    int limit = 5;		// 조회할 행의 수
    	
    // when
    String jpql = "SELECT m FROM section04_menu m ORDER BY m.menuCode DESC";
    	
    /* 쿼리 실행 결과를 보면 offset과 limit을 활용하는 문법으로 실행되어 있는데, 이는 오라클 12버전 이후 추가된 문법
     * 오라클 11이하 버전에서는 rownum을 이용한 인라인뷰 방식으로 쿼리가 동작 */
    /* TypedQuery에 offset과 limit을 set 하기 */
    List<Menu> menuList = entityManager.createQuery(jpql, Menu.class)
    								   .setFirstResult(offset)	// 조회를 시작할 위치(0부터 시작)
    								   .setMaxResults(limit)	// 조회할 데이터의 수
    								   .getResultList();
    	
    // then
    assertNotNull(menuList);
    menuList.forEach(System.out::println);
}

💻 Mini Console

Menu [menuCode=101, menuName=미공개계절메뉴, menuPrice=10000, categoryCode=5, orderableStatus=Y]
Menu [menuCode=81, menuName=치즈똥아이스크림, menuPrice=7000, categoryCode=7, orderableStatus=Y]
Menu [menuCode=61, menuName=짜장바나나스무디, menuPrice=20000, categoryCode=7, orderableStatus=Y]
Menu [menuCode=21, menuName=돌미나리백설기, menuPrice=5000, categoryCode=11, orderableStatus=Y]
Menu [menuCode=20, menuName=마라깐쇼한라봉, menuPrice=22000, categoryCode=5, orderableStatus=Y]

👀 Group function

🙋‍ JPQL의 그룹함수(COUNT, MAX, MIN, SUM, AVG) 사용 시 주의사항

그룹함수의 반환 타입은 결과 값이 정수면 Long, 실수면 Double로 반환됨

값이 없는 상태에서 count를 제외한 그룹 함수는 null이 되고 count만 0이 됨
따라서 반환 값을 담기 위해 선언하는 변수 타입을 기본 자료형으로 하게 되면, 조회 결과를 언박싱 할 때 NPE가 발생 (Wrapper 클래스로 변경할 것)

그룹 함수의 반환 자료형은 Long or Double형이기 대문에 Having절에서 그룹 함수 결과 값과 비교하기 위한 파라미터 타입은 Long or Double로 해야함

✅ COUNT

@Test
public void 특정_카테고리의_등록된_메뉴_수_조회() {
    	
    // given
    int categoryCodeParameter = 4; 
    	
    // when
    String jpql = "SELECT COUNT(m.menuPrice) FROM section05_menu m WHERE m.categoryCode = :categoryCode";
    long countOfMenu = entityManager.createQuery(jpql, Long.class) /* 반환값은 정수일테니 Long */
    								.setParameter("categoryCode", categoryCodeParameter)
    								.getSingleResult();
    	
    // then
    assertTrue(countOfMenu >= 0);
    System.out.println(countOfMenu); /* 없는 카테고리를 입력해도 0 출력 (NPE 발생 X) */
}

✅ SUM

COUNT 이외의 그룹함수 사용 예시

assertThrows() assertDoesNotThrow()

@Test
public void count를_제외한_다른_그룹함수의_조회결과가_없는_경우_테스트() {
    	
    // given
    int categoryCodeParameter = 2; 
    	
    // when
    String jpql = "SELECT SUM(m.menuPrice) FROM section05_menu m WHERE m.categoryCode = :categoryCode";
    	
    // then
    /* NPE가 발생한다고 예상 */
    assertThrows(NullPointerException.class, () -> {
    		
    	/* 반환 값을 담을 변수의 타입을 기본 자료형으로 하는 경우 Wrapper 타입을 언박싱 하는 과정에서 NPE가 발생하게 됨 */
    	long sumOfPrice = entityManager.createQuery(jpql, Long.class)
    								   .setParameter("categoryCode", categoryCodeParameter)
    								   .getSingleResult();
    		
    });
    /* NPE가 발생하지않음을 예상 */
    assertDoesNotThrow(() -> {
    		
    	/* 반환 값을 담는 변수를 Wrapper 타입으로 선언해야 null 값이 반환 되어도 NPE가 발생하지 않음 */
    	Long sumOfPrice = entityManager.createQuery(jpql, Long.class)
    								   .setParameter("categoryCode", categoryCodeParameter)
    								   .getSingleResult();
    		
    });
}

✅ GROUP BY와 HAVING절을 이용한 SUM

@Test
public void groupby절과_having절을_사용한_조회_테스트() {
    	
    // given
    long minPrice = 50000L;		// 그룹 함수의 반환 타입을 Long이므로 비교를 위한 파라미터도 Long 타입을 사용해야함

    // when
    String jpql = "SELECT m.categoryCode, SUM(m.menuPrice) "
    			+ " FROM section05_menu m "
    			+ " GROUP BY m.categoryCode "
    			+ " HAVING SUM(m.menuPrice) >= :minPrice";
    	
    List<Object[]> sumPriceOfCategoryList = entityManager.createQuery(jpql, Object[].class)
    													 .setParameter("minPrice", minPrice)
    													 .getResultList();
    	
    // then
    assertNotNull(sumPriceOfCategoryList);
    sumPriceOfCategoryList.forEach(row -> {
    	for(Object column : row) System.out.print(column + " ");
    });
    	
}

💻 Mini Console

6 64000 7 77000 10 54000 4 80000

👀 Join

🙋‍ JOIN의 종류

일반 JOIN : 일반적인 SQL 조인을 의미(내부 조인, 외부 조인, 컬렉션 조인, 세타 조인)

페치 JOIN : JPQL에서 성능 최적화를 위해 제공하는 기능으로 연관 된 엔티티나 컬렉션을 한 번에 조회 가능
- 지연 로딩이 아닌 즉시 로딩을 수행하며 JOIN FETCH 명령어를 사용

✅ 일반 JOIN

/* Category 엔티티 */
@Entity(name="section06_category")
@Table(name="TBL_CATEGORY")
public class Category {

    @Id
    @Column(name="CATEGORY_CODE")
    private int categoryCode;

    @Column(name="CATEGORY_NAME")
    private String categoryName;

    @Column(name="REF_CATEGORY_CODE")
    private Integer refCategoryCode;

    @OneToMany(mappedBy = "category")
    private List<Menu> menuList;
    
     /* 생성자, getter&setter, toString(반드시 menuList 출력 부분은 제거할 것) */

}

/* Menu 엔티티 */
@Entity(name="section06_menu")
@Table(name="TBL_MENU")
public class Menu {

    @Id
    @Column(name="MENU_CODE")
    private int menuCode;

    @Column(name="MENU_NAME")
    private String menuName;

    @Column(name="MENU_PRICE")
    private int menuPrice;

    @ManyToOne
    @JoinColumn(name="CATEGORY_CODE")
    private Category category;

    @Column(name="ORDERABLE_STATUS")
    private String orderableStatus;
    
    /* 생성자, getter&setter, toString(반드시 menuList 출력 부분은 제거할 것) */
    
}

◼ 내부 JOIN

@Test
public void 내부조인을_이용한_조회_테스트() {
    	
    /* Menu 엔티티에 대한 조회만 일어나고 Category 엔티티에 대한 조회는 나중에 필요할 때 일어남 
     * select의 대상은 영속화하여 가져오지만 join의 대상은 영속화하여 가져오지 않음 */
    	
    // when
    String jpql = "SELECT m FROM section06_menu m JOIN m.category c";
    List<Menu> menuList = entityManager.createQuery(jpql, Menu.class).getResultList();
    	
    // then
    assertNotNull(menuList);
    menuList.forEach(System.out::println);
}

◼ 외부 JOIN

@Test
public void 외부조인을_이용한_조회_테스트() {
    	
    // when
    String jpql = "SELECT m.menuName, c.categoryName"
    			+ " FROM section06_menu m"
    			+ " RIGHT JOIN m.category c"
    			+ " ORDER BY m.category.categoryCode"; /* category 필드의 categoryCode를 가져오기 가능 */
    List<Object[]> menuList = entityManager.createQuery(jpql, Object[].class).getResultList();
    	
    // then
    assertNotNull(menuList);
    menuList.forEach(row -> {
    	Stream.of(row).forEach(col -> System.out.print("[" + col + "]")); /* Object 배열(row)을 스트림으로 만들고 forEach로 처리 */
    	System.out.println(); /* 하나의 행이 출력되면 개행 */
    });
}

💻 Mini Console

[JPA산 짬뽕맛 막걸리][퓨전]
[짜장바나나스무디][퓨전]
[치즈똥아이스크림][퓨전]
[상큼오이라떼][커피]
...

◼ 컬렉션 JOIN

@Test
public void 컬렉션조인을_이용한_조회_테스트() {
    	
    /* 컬렉션 조인은 의미상 분류 된 것으로 컬렉션을 지니고 있는 엔티티를 기준으로 조인하는 것을 말함 */
    	
    // when
    String jpql = "SELECT c.categoryName, m.menuName"
    			+ " FROM section06_category c"
    			+ " LEFT JOIN c.menuList m"; /* category 엔티티의 menuList라는 컬렉션을 조인 */
    List<Object[]> categoryList = entityManager.createQuery(jpql, Object[].class).getResultList();
    	
    // then
    assertNotNull(categoryList);
    categoryList.forEach(row -> {
    	Stream.of(row).forEach(col -> System.out.print("[" + col + "]")); /* Object 배열(row)을 스트림으로 만들고 forEach로 처리 */
    	System.out.println(); /* 하나의 행이 출력되면 개행 */
    });
}

💻 Mini Console

[퓨전][JPA산 짬뽕맛 막걸리]
[지중해][아보카도스무디]
[퓨전][짜장바나나스무디]
[퓨전][치즈똥아이스크림]

◼ 세타 JOIN

@Test
public void 세타조인을_이용한_조회_테스트() {
    	
    /* 세타 조인은 조인되는 모든 경우의 수를 다 반환하는 크로스 조인과 같음
     * FROM 절에 엔티티를 나열하는 방식으로 크로스 조인 사용 가능 
     * */
    	
    // when
    String jpql = "SELECT c.categoryName, m.menuName"
    			+ " FROM section06_category c, section06_menu m"; /* FROM 절에 두 엔티티 모두 작성 */
    List<Object[]> categoryList = entityManager.createQuery(jpql, Object[].class).getResultList();
    	
    // then
    assertNotNull(categoryList);
    categoryList.forEach(row -> {
    	Stream.of(row).forEach(col -> System.out.print("[" + col + "]")); /* Object 배열(row)을 스트림으로 만들고 forEach로 처리 */
    	System.out.println(); /* 하나의 행이 출력되면 개행 */
    });
}

✅ 페치 JOIN

@Test
public void 페치조인을_이용한_조회_테스트() {
    	
    /* 페치 조인을 하면 처음 SQL 실행 후 로딩할 때 조인 결과를 다 조회한 뒤에 사용하는 방식이기 대문에 쿼리 실행 횟수가 줄어들게 됨
     * 대부분의 경우 성능 향상 ! 
     * */
    	
    // when
    String jpql = "SELECT m FROM section06_menu m JOIN FETCH m.category c"; /* JOIN 뒤에 FETCH 추가 */
    List<Menu> menuList = entityManager.createQuery(jpql, Menu.class).getResultList();
    	
    // then
    assertNotNull(menuList);
    menuList.forEach(System.out::println);
    	
    /* 검색 조건(where절)에서만 사용한다면 굳이 FETCH 조인을 사용할 필요없음
     * 하지만 select절에서 조회할 컬럼이라면 FETCH 조인을 사용하여 SELECT문 첫 실행 시, 한꺼번에 조회해올 수 있도록 하여
     * 성능면에서 효율적일 수 있도록 함 (즉, 목적에 따라 FETCH가 효율적일 수 있지만 항상은 아님) */
}

👀 Sub query

💁‍♀️ JPQL도 SQL처럼 서브 쿼리를 지원하지만 select, from 절에서는 사용할 수 없고 where, having절에서만 사용 가능

✅ 서브쿼리를 이용한 조회

@Test
public void 서브쿼리를_이용한_메뉴_조회_테스트() {
    	
    // given
    String categoryNameParameter = "한식";
    	
    // when
    String jpql = "SELECT m "
    			+ "FROM section07_menu m "
    			+ "WHERE m.categoryCode = (SELECT c.categoryCode "
    									+ "FROM section07_category c "
    									+ "WHERE c.categoryName = :categoryName)";
    List<Menu> menuList = entityManager.createQuery(jpql, Menu.class)
    								   .setParameter("categoryName", categoryNameParameter)
    								   .getResultList();
    	
    // then
    assertNotNull(menuList);
    menuList.forEach(System.out::println);
}

👀 Named query

🙋‍ 동적쿼리? 정적쿼리?

동적쿼리 : 현재 사용 중인 방식처럼 EntityManager가 제공하는 메소드를 이용하여 JPQL을 문자열로 런타임 시점에 동적으로 쿼리를 만드는 방식
(동적으로 만들어질 쿼리를 위한 조건식이나 반복문은 자바 코드를 이용할 수 있음)

정적쿼리 : 미리 쿼리를 정의하고 변경하지 않고 사용하는 쿼리를 말하며 미리 정의한 코드는 이름을 부여해서 사용하게 됨
이를 NamedQuery라고 함. 어노테이션 방식과 xml 방식 두 가지가 있는데 쿼리가 복잡할수록 xml 방식이 선호됨.

✅ 동적 쿼리

🙋‍ 동적 SQL을 작성하기에 JPQL은 많이 어려움. 컴파일 에러가 발생하는 것이 아니기 때문에 쿼리를 매번 실행해서 확인해야하는 불편함이 있음
Criteria나 queryDSL을 활용하면 보다 편리하게 작성할 수 있으며, 쿼리 작성 시 컴파일 에러로 잘못 된 부분을 확인할 수 있어 작성하기도 편함
마이바티스를 혼용하거나 마이바티스의 구문 빌더 API를 활용해도 좋음

@Test
public void 동적쿼리를_이용한_조회_테스트() {
    	
    // given
    /* Menu 테이블에 있는 모든 값 가져옴 */
//  String searchName = ""; 
//  int searchCategoryCode = 0;
    	
    /* 카테고리 상관없이 치즈가 포함된 모든 메뉴 가져옴 */
//  String searchName = "치즈";
//  int searchCategoryCode = 0;
    	
    /* 7번 카테고리의 치즈가 포함된 메뉴들 가져옴 */
    String searchName = "치즈";
    int searchCategoryCode = 7;
    	
    // when
    StringBuilder jpql = new StringBuilder("SELECT m FROM section08_menu m "); /* 이 값으로 초기화 해두고 다른 구문들을 append할 것 */
    if(searchName != null && !searchName.isEmpty() && searchCategoryCode > 0) {
    	jpql.append("WHERE ");
    	jpql.append("m.menuName LIKE '%' || :menuName || '%' ");
    	jpql.append("AND ");
    	jpql.append("m.categoryCode = :categoryCode ");
    } else {
    	/* 둘 중에 하나만 있을 경우 */
    	if(searchName != null && !searchName.isEmpty()) {
    		jpql.append("WHERE ");
    		jpql.append("m.menuName LIKE '%' || :menuName || '%' ");
    	} else if(searchCategoryCode > 0) {
    		jpql.append("WHERE ");
    		jpql.append("m.categoryCode = :categoryCode ");
    	}
    }
    	
    TypedQuery<Menu> query = entityManager.createQuery(jpql.toString(), Menu.class); /* jpql을 toString()하여 쿼리 만들기 */
    	
    if(searchName != null && !searchName.isEmpty() && searchCategoryCode > 0) {
    	query.setParameter("menuName", searchName);
    	query.setParameter("categoryCode", searchCategoryCode);
    		
    } else {
    	/* 둘 중에 하나만 있을 경우 */
    	if(searchName != null && !searchName.isEmpty()) {
    		query.setParameter("menuName", searchName);
    	} else if(searchCategoryCode > 0) {
    		query.setParameter("categoryCode", searchCategoryCode);
    	}
    }
    	
    List<Menu> menuList = query.getResultList();
    	
    // then
    assertNotNull(menuList);
    menuList.forEach(System.out::println);
    	
}

✅ 정적 쿼리 (NamedQuery)

◼ 어노테이션 기반

@NamedQueries @NamedQuery name query

/* Menu 엔티티 */
@Entity(name="section08_menu")
@Table(name="TBL_MENU")
/* 네임드쿼리 지정 */
@NamedQueries({
	@NamedQuery(name="section08_menu.selectMenuList", query="SELECT m FROM section08_menu m")
})
public class Menu {

}

@Test
public void 어노테이션_기반_네임드쿼리를_이용한_조회_테스트() {
    	
    // when
    /* createNamedQuery()를 사용하여 정해둔 네임드쿼리를 name을 불러옴 */
    List<Menu> menuList = entityManager.createNamedQuery("section08_menu.selectMenuList", Menu.class).getResultList();
    
    // then
    assertNotNull(menuList);
    menuList.forEach(System.out::println);
}

◼ XML 기반

조금 더 복잡한 형태의 쿼리를 작성해야하는 경우에는 xml 방식을 더 선호
(문자열로 쿼리를 작성하기 복잡하기 때문)

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://xmlns.jcp.org/xml/ns/persistence/orm" version="2.1">
	<named-query name="section08_menu.selectMenuNameByCode">
		<query>
			SELECT
			       m
			  FROM section08_menu m
			 WHERE m.menuCode = :menuCode
		</query>
	</named-query>
</entity-mappings>

persistence.xml

@Test
public void xml_기반_네임드쿼리를_이용한_조회_테스트() {
    	
    // given
    int menuCodeParameter = 81;
    	
    // when
    Menu foundMenu = entityManager.createNamedQuery("section08_menu.selectMenuNameByCode", Menu.class) /* xml파일 안의 쿼리문의 name 속성과 일치시켜야함 */
    							  .setParameter("menuCode", menuCodeParameter)
    							  .getSingleResult();
    
    	// then
    	assertNotNull(foundMenu);
    	System.out.println("foundMenu : " + foundMenu);
    }

JOY🌱

Tiny little habits make me

이전 포스트

연관 관계 매핑(Association Mapping)

다음 포스트

JPQL (Java Persistence Query Language)

🐸 JPA

👀 Simple

✅ TypedQuery / Query 단일메뉴조회

◼ TypedQuery

◼ Query

✅ TypedQuery 단일 행 조회

✅ TypedQuery / Query 여러 행 조회

◼ TypedQuery

◼ Query

✅ 연산자를 활용한 조회

◼ DISTINCT

◼ IN

◼ LIKE

👀 Parameter

✅ 이름 기준 파라미터

✅ 위치 기준 파라미터

👀 Projection

✅ 엔티티 프로젝션

◼ 단일 엔티티

◼ 양방향 연관관계 엔티티

✅ 임베디드 타입 프로젝션

✅ 스칼라 타입 프로젝션

◼ TypedQuery를 이용한 스칼라 타입 (단일행)

◼ Query를 이용한 스칼라 타입 (다중열)

✅ new 명령어를 활용한 프로젝션

👀 Paging

✅ Paging API 활용

👀 Group function

✅ COUNT

✅ SUM

COUNT 이외의 그룹함수 사용 예시

✅ GROUP BY와 HAVING절을 이용한 SUM

👀 Join

✅ 일반 JOIN

◼ 내부 JOIN

◼ 외부 JOIN

◼ 컬렉션 JOIN

◼ 세타 JOIN

✅ 페치 JOIN

👀 Sub query

✅ 서브쿼리를 이용한 조회

👀 Named query

✅ 동적 쿼리

✅ 정적 쿼리 (NamedQuery)

◼ 어노테이션 기반

◼ XML 기반

menu-query.xml

persistence.xml

연관 관계 매핑(Association Mapping)

네이티브 쿼리 (Native Query)

0개의 댓글