JPA - NativeQuery ( SQL ) 네이티브 SQL 사용하기!

JPA - NativeQuery ( SQL ) 네이티브 SQL 사용하기!

---

JPA는 SQL이 지원하는 대부분의 문법과 SQL 함수들을 지원하지만 특정 데이터베이스에 종속적인 기능은 잘 지원하지 않는다. 하지만 때론 특정 데이터베이스에 종속적인 기능이 필요할 수도 있다. 다양한 이유로 JPQL을 사용할 수 없을 때, JPA는 SQL을 직접 사용할 수 있는 기능을 제공하는데 이것을 네이티브 SQL(네이티브쿼리)라고 한다. 즉, 사용자가 직접 데이터베이스에 날리는 쿼리를 작성하는 것이다. 그렇다면 JPA가 지원하는 네이티브 SQL과 JDBC API를 직접 사용하는 것에는 어떤 차이가 있냐? 그것은 바로 네이트브 쿼리는 엔티티를 조회할 수 있고 JPA가 지원하는 영속성 컨텍스트의 기능을 그대로 사용할 수 있다는 것이다!

---

Native Query API

---

1. //결과 타입 정의
2. public Query createNativeQuery(String sqlString, Class resultClass) {}
3. //결과 타입을 정의할 수 없을 때
4. public Query createNativeQuery(String sqlString) {}
5. //엔티티 타입이 아닌 결과 값일때
6. public Query createNativeQuery(String sqlString
7.                         ,String resultSetMapping) {}

 이렇게 세가지의 오버로딩된 메소드를 사용한다.

---

1. /*
2.  * 네이티브쿼리는 위치기반 파라미터 바인딩만 지원한다.(구현체중 일부는 이름기반 파라미터 바인딩도 지원함)
3.  */
4. public void nativeQuery() {
5.         String sql = "SELECT MEMBER_JPQL_ID,USERAGE,USERNAME,TEAM_ID FROM MEMBER_JPQL WHERE USERAGE> ?";
6.         
7.         Query nativeQuery = em.createNativeQuery(sql,MemberJPQL.class).setParameter(1, 35);
8.         
9.         List<MemberJPQL> resultList = nativeQuery.getResultList();
10.         
11.         System.out.println("====================nativeQuery=====================");
12.         
13.         for(MemberJPQL m : resultList) {
14.                 System.out.println(m.toString());
15.         }
16.         
17.         System.out.println("====================nativeQuery=====================");
18. }

리턴타입이 엔티티일 경우이다. em.createNativeQuery(SQL문장,리턴타입클래스)로 Query객체를 만들어낸다. 위의 예제를 보면 JPQL과 다를 것은 쿼리를 직접작성하냐 안하냐의 차이지 대부분의 로직은 비슷하다.(JPA가 자동으로 생성해주는 SQL를 사용자가 직접 작성한 것뿐 더이상의 차이는 거의없다.)

그리고 Native Query에서는 반환타입이 명시되어도 Query 객체로 반환받는다는 점을 유의하자.

다음은 결과 매핑 사용 예제이다.

1. @Entity
2. @Table(name = "MEMBER_JPQL")
3. //@Getter
4. //@Setter
5. @ToString
6. @SqlResultSetMapping(name = "memberWithOrderCount",
7.                                         entities = {@EntityResult(entityClass = MemberJPQL.class)},
8.                                         columns = {@ColumnResult(name = "ORDER_COUNT")})
9. public class MemberJPQL {....}

1. /*
2.  * ResultMapping
3.  */
4. public void nativeQuery2() {
5.         String sql = "SELECT M.MEMBER_JPQL_ID AS ID,USERAGE AS AGE,USERNAME,TEAM_ID,I.ORDER_COUNT "
6.                                 + "FROM MEMBER_JPQL M JOIN  "
7.                                                 + "(SELECT IM.MEMBER_JPQL_ID, COUNT(*) AS ORDER_COUNT "
8.                                                 + "FROM ORDER_JPQL O, MEMBER_JPQL IM "
9.                                                 + "WHERE O.MEMBER_JPQL_ID = IM.MEMBER_JPQL_ID) I "
10.                                 + "ON M.MEMBER_JPQL_ID = I.MEMBER_JPQL_ID";
11.                                 
12.         Query nativeQuery = em.createNativeQuery(sql,"memberWithOrderCount");
13.         
14.         List<Object[]> resultList = nativeQuery.getResultList();
15.         
16.         System.out.println("====================nativeQuery2=====================");
17.         
18.         for(Object[] m : resultList) {
19.                 System.out.println(m[0].toString());
20.                 System.out.println(m[1]);
21.         }
22.         
23.         System.out.println("====================nativeQuery2=====================");
24. }

특별한 것은 없다. 엔티티클래스에 네이티브 쿼리로 받을 반환 타입을 명시해주었고, 네이티브 쿼리를 사용한 쪽에서는 반환타입을 엔티티클래스에 작성한 반환타입 이름 값을 문자열로 넘겨주었다. 그래서 반환된 Object[]에서 Object[0]은 회원엔티티로 매핑되고, Object[1]은 스칼라타입으로 ORDER_COUNT를 담고있다.

어노테이션을 보면 속성 값이 entities,columns로 된것으로 보아 여러개의 엔티티,칼럼을 매핑할 수 있다. 그리고 @SqlResultSetMappings 어노테이션이 있기 때문에 여러개의 매핑타입을 만들 수 있다.

그런데 대부분 엔티티 클래스의 id클래스의 필드명은 "id"로 거의 동일하게 하는 경우도 많다. 그래서 조회를 하면 칼럼명이 중복나는 경우가 생기게 된다. 그때는 필드매핑까지 포함하여서 조회가능하다.

1. @Entity
2. @Table(name = "MEMBER_JPQL")
3. //@Getter
4. //@Setter
5. @ToString
6. @SqlResultSetMappings({
7.         @SqlResultSetMapping(name = "memberWithOrderCount",
8.                         entities = {@EntityResult(entityClass = MemberJPQL.class)},
9.                         columns = {@ColumnResult(name = "ORDER_COUNT")}
10.         )
11.         ,@SqlResultSetMapping(name = "memberInfo",
12.                         entities = {
13.                                         @EntityResult(entityClass=MemberJPQL.class,
14.                                         fields = {
15.                                                         @FieldResult(name = "id",column = "member_id")
16.                                                         ,@FieldResult(name = "age",column = "client_age")
17.                                         })
18.                         }
19.         )
20.         
21. })
22. public class MemberJPQL {...}

1. public void nativeQuery3() {
2.         String sql = "select MEMBER_JPQL_ID as member_id,USERAGE as client_age "
3.                         + "from member_jpql where USERNAME = '여성게1'";
4.         
5.         Query nativeQuery = em.createNativeQuery(sql,"memberInfo");
6.         
7.         List<MemberJPQL> resultList = nativeQuery.getResultList();
8.         
9.         System.out.println("====================nativeQuery3=====================");
10.         
11.         for(MemberJPQL m : resultList) {
12.                 System.out.println(m.toString());
13.         }
14.         
15.         System.out.println("====================nativeQuery3=====================");
16. }

부득이하게 조회할 컬럼명을 별칭으로 주었을 경우, 엔티티 클래스와 매핑이 되지 않는다. 그럴때 엔티티클래스에 필드매핑을 이용한다.

@FieldResult(name = "id",column = "member_id")

name이 엔티티클래스의 필드명이고, column이 조회하였을 때 반환되는 컬럼명이다.

마지막으로 이전에 다루었던 정적쿼리(@NamedQuery)처럼 네이티브 쿼리로 정적쿼리처럼 엔티티클래스에 정의할 수 있다.

▶︎▶︎▶︎JPA - @NamedQuery , 정적 쿼리

@Entity

1. @Table(name = "MEMBER_JPQL")
2. //@Getter
3. //@Setter
4. @ToString
5. @SqlResultSetMappings({
6.         @SqlResultSetMapping(name = "memberWithOrderCount",
7.                         entities = {@EntityResult(entityClass = MemberJPQL.class)},
8.                         columns = {@ColumnResult(name = "ORDER_COUNT")}
9.         )
10.         ,@SqlResultSetMapping(name = "memberInfo",
11.                         entities = {
12.                                         @EntityResult(entityClass=MemberJPQL.class,
13.                                         fields = {
14.                                                         @FieldResult(name = "id",column = "member_id")
15.                                                         ,@FieldResult(name = "age",column = "client_age")
16.                                         })
17.                         }
18.         )
19.         
20. })
21. @NamedNativeQueries({
22.         @NamedNativeQuery(name = "Member.memberSQL",
23.                                                 query = "select member_jpql_id,userage,username,team_id "
24.                                                                 + "from member_jpql "
25.                                                                 + "where username = ?",
26.                                                 resultClass=MemberJPQL.class)
27.         ,@NamedNativeQuery(name = "Member.memberSQL2",
28.                         query = "select MEMBER_JPQL_ID as member_id,USERAGE as client_age "
29.                                         + "from member_jpql where USERNAME = ?",
30.                         resultSetMapping = "memberInfo")
31. })
32. public class MemberJPQL {}

1. public void nativeQuery4() {
2.         
3.         Query nativeQuery = em.createNamedQuery("Member.memberSQL",MemberJPQL.class)
4.                         .setParameter(1, "여성게1");
5.         
6.         List<MemberJPQL> resultList = nativeQuery.getResultList();
7.         
8.         System.out.println("====================nativeQuery4=====================");
9.         
10.         for(MemberJPQL m : resultList) {
11.                 System.out.println(m.toString());
12.         }
13.         
14.         System.out.println("====================nativeQuery4=====================");
15. }
16. public void nativeQuery5() {
17.         
18.         Query nativeQuery = em.createNamedQuery("Member.memberSQL2")
19.                         .setParameter(1, "여성게1");
20.         
21.         List<MemberJPQL> resultList = nativeQuery.getResultList();
22.         
23.         System.out.println("====================nativeQuery5=====================");
24.         
25.         for(MemberJPQL m : resultList) {
26.                 System.out.println(m.toString());
27.         }
28.         
29.         System.out.println("====================nativeQuery5=====================");
30. }

em.createNativeQuery()에서 다루던 것을 어노테이션으로 다 가져다 놓았다고 보면된다. 그리고 조금 특이한 것은 @NamedQuery와 같이 em.createNamedQuery()를 사용한다는 것이다.