객체지향 쿼리 언어1 - 기본 문법

 

소개

 

※ JPA 는 다양항 쿼리 방법을 지원한다.

 

- JPQL

- JPA Criteria

- QueryDSL

- 네이티브 SQL

- JDBC API 를 직접 사용, MyBatis, SpringJdbcTemplate 를 함께 사용

 

 

※ JPQL

 

가장 단순한 조회 방법

- EntityManager.find()

- 객체 그래프 탐색 (ex : a.getB().getC())

 

만약 나이가 18살 이상인 회원을 모두 검색하고 싶은 경우?

결국 문제는 검색 쿼리이다.

검색을 할 때도 테이블이 아닌 엔티티 객체를 대상으로 검색해야 한다.

모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능하다.

애플리케이션이 필요한 데이터만 DB 에서 불러오려면 결국 검색 조건이 포함된 SQL 이 필요하다.

 

따라서, JPA 는 SQL 을 추상화한 JPQL 이라는 객체 지향 쿼리 언어를 제공한다.

SQL 과 문법이 유사하며 SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN 을 지원한다.

JPQL 은 엔티티 객체를 대상으로 쿼리한다.

SQL 은 데이터베이스 테이블을 대상으로 쿼리한다.

 

List<Member> result = em.createQuery(
        "select m From Member m where m.username like '%kim%'",
        Member.class
).getResultList();

for (Member member : result) {
    System.out.println("member = " + member);
}

 

실제로 실행된 SQL 쿼리는 위와 같으며 적절하게 변환되어 실행이 되어진다.

 

JPQL 은 테이블이 아닌 객체를 대사으로 검색하는 객체 지향 쿼리이다.SQL 을 추상화해서 특정 데이터베이스 SQL 에 의존하지 않는다.따라서 JPQL 을 한마디로 정의하면 객체 지향 SQL 이다.

 

 

※ Criteria

 

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

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

CriteriaQuery<Member> cq = query.select(m).where(cb.equal(m.get("username"), "kim"));
List<Member> resultList = em.createQuery(cq)
                .getResultList();

 

문자가 아닌 자바코드로 JPQL 을 작성할 수 있다.

JPQL 빌더 역할로 JPA 공식 기능이다.

단점으로 너무 복잡하고 실용성이 없다!

따라서, Criteria 대신에 QueryDSL 사용을 권장한다.

 

 

※ QueryDSL

 

//JPQL 
//select m from Member m where m.age > 18
JPAFactoryQuery query = new JPAQueryFactory(em);
QMember m = QMember.member; 
List<Member> list =  
    query.selectFrom(m)
         .where(m.age.gt(18)) 
         .orderBy(m.name.desc())
         .fetch();

 

문자가 아닌 자바코드로 JPQL 을 작성할 수 있다.

JPQL 빌더 역할을 하며 컴파일 시점에 문법 오류를 찾을 수 있다.

동적쿼리 작성이 편리하며 단순하고 쉽다.

따라서 실무에서 사용을 권장한다고 한다.

 

 

※ 네이티브 SQL 

 

String sql =  
    “SELECT ID, AGE, TEAM_ID, NAME FROM MEMBER WHERE NAME = ‘kim’";
    
List<Member> resultList =  
            em.createNativeQuery(sql, Member.class).getResultList();

 

JPA 가 제공하는 SQL 을 직접 사용하는 기능이다.

JPQL 로 해결할 수 없는 특정 데이터베이스에 의존적인 기능이다.

JPA 를 사용하면서 JDBC 커넥션을 직접 사용하거나, 스프링 JdbcTemplate, 마이바티스등을 함꼐 사용 가능하다.

단, 영속성 컨텍스트를 적절한 시점에 강제로 flush 가 필요하다.

 

 

JPQL(Java Persistence Query Language)

 

※ JPQL

 

JPQL 은 객체지향 쿼리 언어이다.

따라서 테이블을 대상으로 쿼리하는 것이 아닌, 엔티티 객체를 대상으로 쿼리한다.

JPQL 은 SQL 을 추상화해서 특정 데이터베이스 SQL 에 의존하지 않는다.

따라서, JPQL 은 결국 SQL 로 변환된다.

 

 

우선, 위 구조로 클래스를 생성한다.

 

MEMBER

@Entity
public class Member {

    @Id @GeneratedValue
    private Long id;
    private String username;
    private int age;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;
    
    ...
}

 

TEAM

@Entity
public class Team {

    @Id @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();
    
    ...
}

 

ORDER

@Entity
@Table(name = "ORDERS")
public class Order {

    @Id @GeneratedValue
    private Long id;
    private int orderAmount;

    @Embedded
    private Address address;

    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    Product product;
    
    ...
}

 

ADDRESS

@Embeddable
public class Address {

    private String city;
    private String street;
    private String zipcode;
    
    ...
}

 

PRODUCT

@Entity
public class Product {

    @Id @GeneratedValue
    private Long id;
    private String name;
    private int price;
    private int stockAmount;
    
    ...
}

 

※ JPQL 문법

 

 

select m from Member as m where m.age > 18

엔티티와 속성은 대소문자를 구분한다. (Member, age)

JPQL 키워드는 대소문자를 구분하지 않는다. (SELECT, FROM, where)

엔티티 이름을 사용하며, 테이블 이름이 아니다.

별칭은 필수이다. (as 는 생략 가능)

 

 

※ 집합과 정렬

 

 

 

※ TypeQuery, Query

 

-TypeQuery : 반환 타입이 명확할 때 사용한다.

- Query : 반환 타입이 명확하지 않을 때 사용한다.

 

Member member = new Member();
member.setUsername("member1");
member.setAge(10);
em.persist(member);

TypedQuery<Member> query1 = em.createQuery("select m from Member m", Member.class);
TypedQuery<String> query2 = em.createQuery("select m.username from Member m", String.class);
Query query3 = em.createQuery("select m.username, m.age from Member m");

 

createQuery 에서 두 번째 인자로 명시적으로 클래스 명을 지정하게 될 경우 TypeQuery 이다.

그러나, 지정되지 않을 경우에는 반환 타입이 명확하지 않으므로 Query 이다.

 

 

※ 결과 조회 API

 

- query.getResultList() : 결과가 하나 이상일 때 리스트를 반환한다.

   결과가 없으면 빈 리스트를 반환하며 null 값이 아니다. (null 처리를 할 필요 x)

 

- query.getSingleResult() : 결과가 정확히 하나이며, 단일 객체를 반환한다.

   결과가 없으면? ->  javax.persistence.NoResultException 

   둘 이상일 경우? ->  javax.persistence.NonUniqueResultException

 

 

※ 파라미터 바인딩 - 이름 기준

 

Member member = new Member();
member.setUsername("member1");
member.setAge(10);
em.persist(member);

TypedQuery<Member> query = em.createQuery("select m from Member m where m.username = :username", Member.class);
query.setParameter("username" , "member1");
Member singleResult = query.getSingleResult();
System.out.println("singleResult = " + singleResult.getUsername());

 

 

프로젝션

 

※ 프로젝션 

 

SELECT 절에 조회할 대상을 지정하는 것을 말한다.

프로젝션 대상으로 엔티티, 임베디드 타입, 스칼라 타입(숫자, 문자등 기본 데이터 타입) 이다.

 

- SELECT m FROM Member m  =>  엔티티 프로젝션

- SELECT m.team FROM Member m  =>  엔티티 프로젝션

- SELECT m.address FROM Member m  =>  임베디드 타입 프로젝션

- SELECT m.username, m.age FROM Member m  =>  스칼라 타입 프로젝션

 

참고로 DISTINCT 로 중복 제거가 가능하다.

 

Member member = new Member();
member.setUsername("member1");
member.setAge(10);
em.persist(member);

em.flush();
em.clear();

List<Member> result = em.createQuery("select m from Member m", Member.class)
        .getResultList();

Member findMember = result.get(0);
findMember.setAge(20);

 

정상적으로 업데이트 쿼리가 수행되었다.

즉, createQuery 로 가져온 리스트는 영속성 컨텍스트에서 관리가 되고 있다는 것을 알 수 있다.

따라서 리스트의 원소(객체)를 가져와서 변경하게 될 경우 관리가 된다.

 

 

※ 프로젝션 - 여러 값 조회

 

SELECT m.username, m.age FROM Member m

- Query 타입으로 조회한다.

- Object[] 타입으로 조회한다.

- new 명령어로 조회한다.

 

• 단순 값을 DTO 로 바로 조회 (SELECT new jpabook.jpql.UserDTO(m.username, m.age) FROM Member m
• 패키지 명을 포함한 전체 클래스 명을 입력
• 순서와 타입이 일치하는 생성자 필요

 

Member member = new Member();
member.setUsername("member1");
member.setAge(10);
em.persist(member);

em.flush();
em.clear();

List resultList = em.createQuery("select m.username, m.age from Member m")
        .getResultList();

Object o = resultList.get(0);
Object[] result = (Object[])o;
System.out.println("username = " + result[0]);
System.out.println("age = " + result[1]);

 

위와 같이 Query 타입으로 조회해서 가져올 수 있다.

 

DTO 로 바로 조회하는 방법도 있는데 username, age 필드를 포함한 MemberDTO 를 생성한다.

public class MemberDTO {

    private String username;
    private int age;

    public MemberDTO(String username, int age) {
        this.username = username;
        this.age = age;
    }
    
    ...
}

 

그러면 DTO 를 활용하여 new 명령어로 조회할 수 있다.

Member member = new Member();
member.setUsername("member1");
member.setAge(10);
em.persist(member);

em.flush();
em.clear();

List<MemberDTO> result = em.createQuery("select new hellojpa.ch10.MemberDTO(m.username, m.age) from Member m", MemberDTO.class)
        .getResultList();

MemberDTO memberDTO = result.get(0);
System.out.println("username = " + memberDTO.getUsername());
System.out.println("age = " + memberDTO.getAge());

 

이때 주의할 점은 new hellojpa.ch10.MemberDTO 에서 경로를 확실하게 해줘야 한다.

 

 

페이징

 

※ 페이징 API

 

JPA 는 페이징을 다음 두 API 로 추상화할 수 있다.- setFirstResult(int startPosition) : 조회 시작 위치 (0부터 시작)- setMaxResults(int maxResult) : 조회할 데이터 수

 

 

for (int i = 0; i < 100; i++) {
    Member member = new Member();
    member.setUsername("member" + i);
    member.setAge(i);
    em.persist(member);
}

em.flush();
em.clear();

List<Member> result = em.createQuery("select m from Member m order by m.age desc", Member.class)
        .setFirstResult(20)
        .setMaxResults(10)
        .getResultList();

System.out.println("result.size = " + result.size());
for (Member member1 : result) {
    System.out.println("member1 = " + member1);
}

 

 

조인

 

- 내부 조인 : SELECT m FROM Member m [INNER] JOIN m.team t

- 외부 조인 : SELECT m FROM Member m LEFT [OUTER] JOIN m.team t

- 세타 조인 : select count(m) from Member m, Team t where m.username = t.name

 

Team team = new Team();
team.setName("teamA");
em.persist(team);

Member member = new Member();
member.setUsername("member");
member.setAge(10);
member.setTeam(team);

em.persist(member);

em.flush();
em.clear();

String query = "select m from Member m inner join m.team t";
List<Member> result = em.createQuery(query, Member.class)
        .getResultList();

tx.commit();

 

정상적으로 inner join 이 완료된 모습이다.

 

Team team = new Team();
team.setName("teamA");
em.persist(team);

Member member = new Member();
member.setUsername("member");
member.setAge(10);
member.setTeam(team);

em.persist(member);

em.flush();
em.clear();

String query = "select m from Member m, Team t where m.username = t.name";
List<Member> result = em.createQuery(query, Member.class)
        .getResultList();

tx.commit();

 

이번엔 cross join 으로 세타조인이 정상적으로 수행이 되었다.

 

 

※ 조인 - ON 절

 

ON 절을 활용한 조인 (JPA 2.1 부터 지원)

- 조인 대상을 필터링한다.

- 연관관계가 없는 엔티티를 외부 조인 가능하다.

 

예를 들어 회원과 팀을 조인하면서 팀 이름이 A 인 팀만 조인한다.

이 때 조인 대상을 필터링한다.

- JPQL : SELECT m, t FROM Member m LEFT JOIN m.team t on t.name = 'A'

- SQL : SELECT m.*, t.* FROM Member m LEFT JOIN Team t ON M.TEAM_ID = t.id and t.name = 'A'

 

Team team = new Team();
team.setName("teamA");
em.persist(team);

Member member = new Member();
member.setUsername("member");
member.setAge(10);
member.setTeam(team);

em.persist(member);

em.flush();
em.clear();

String query = "select m from Member m left join m.team t on t.name = 'teamA'";
List<Member> result = em.createQuery(query, Member.class)
        .getResultList();

tx.commit();

 

예를 들어 회원의 이름과 팀의 이름이 같은 대상을 외부 조인한다.

이 때 연관관계가 없는 엔티티를 외부 조인한다.

- JPQL : SELECT m, t FROM Member m LEFT JOIN Team t on m.username = t.name 

- SQL : SELECT m.*, t.* FROM Member m LEFT JOIN Team t ON m.username = t.name

 

Team team = new Team();
team.setName("teamA");
em.persist(team);

Member member = new Member();
member.setUsername("teamA");
member.setAge(10);
member.setTeam(team);

em.persist(member);

em.flush();
em.clear();

String query = "select m from Member m left join Team t on m.username = t.name";
List<Member> result = em.createQuery(query, Member.class)
        .getResultList();

tx.commit();

 

 

서브 쿼리

 

※ 서브 쿼리

 

나이가 평균보다 많은 회원

=> select m from member m where m.age > (select avg(m2.age) from Member m2)

 

한 건이라도 주문한 고객

=> select m from Member m where (select count(o) from Order o where m = o.member) > 0

 

 

※ 서브 쿼리 지원 함수

 

[NOT] EXISTS (subquery) : 서브쿼리에 결과가 존재하면 참이다.- {ALL | ANY | SOME} (subquery)- ALL : 모두 만족하면 참- ANY, SOME : 같은 의미로 조건을 하나라도 만족하면 참

 

[NOT] IN (subquery) : 서브쿼리의 결과 중 하나라도 같은 것이 있으면 참이다.

 

예를 들어 팀A 소속인 회원을 찾으려고 한다.

=> select m from Member m where exists (select t from m.team t where t.name = '팀A')

 

예를 들어 전체 상품 각각의 재고보다 주문량이 많은 주문들을 찾으려고 한다.

=> select o from Order o where o.orderAmount > ALL (select p.stockAmount from Product p)

 

예를 들어 어떤 팀이든 팀에 소속된 회원을 찾으려고 한다.

=> select m from Member m where m.team = ANY (select t from Team t)

 

 

※ JPA 서브 쿼리 한계

 

JPA 는 WHERE, HAVING 절에서만 서브 쿼리 사용이 가능하다.

SELECT 절도 가능하긴 하다. (하이버네이트에서 지원)

FROM 절의 서브 쿼리는 현재 JPQL 에서 불가능하다. (조인으로 풀 수 있으면 풀어서 해결)

 

 

JPQL 타입 표현

 

- 문자 : 'HELLO', 'She''s' (안에 ' 를 넣고 싶은 경우 '')

- 숫자 : 10L(Long), 10D(Double), 10F(Float)

- Boolean : TRUE, FALSE

- ENUM : jpabook.MemberType.Admin (패키지 명 포함)

- 엔티티 타입 : TYPE(m) = Member (상속 관계에서 사용)

 

ENUM 을 쓰는 방법은 다음과 같다.

Team team = new Team();
team.setName("teamA");
em.persist(team);

Member member = new Member();
member.setUsername("teamA");
member.setAge(10);
member.setTeam(team);
member.setType(MemberType.ADMIN);

em.persist(member);

em.flush();
em.clear();

String query = "select m.username, 'HELLO', true From Member m " +
        "where m.type = hellojpa.ch10.MemberType.ADMIN";
List<Object[]> result = em.createQuery(query)
        .getResultList();

for (Object[] objects : result){
    System.out.println("objects = " + objects[0]);
    System.out.println("objects = " + objects[1]);
    System.out.println("objects = " + objects[2]);
    System.out.println("=======================");
}

tx.commit();

 

현재 MemberType 은 hellojpa 패키지 아래의 ch10 패키지 아래에 존재한다.

따라서 where 문에서 hellojpa.ch10.MemberType 에서 enum 값을 가져오도록 해야 한다.

 

파라메터 바인딩을 하여 처리하는 방법도 있다.

String query = "select m.username, 'HELLO', true From Member m " +
        "where m.type = :userType";
List<Object[]> result = em.createQuery(query)
        .setParameter("userType", MemberType.ADMIN)
        .getResultList();

 

엔티티 타입을 명시하여 가져오는 방법도 있다.

em.createQuery("select i from item i where type(i) = Book ", Item.class)
    .getResultList();

 

 

조건식(CASE)

 

- 기본 CASE 

String query =
        "select " +
                "case when m.age <= 10 then '학생요금'" +
                "     when m.age >= 60 then '경로요금'" +
                "     else '일반요금' " +
                "end " +
                "from Member m";
List<String> result = em.createQuery(query, String.class)
                .getResultList();

 

case 문이 끝나면 end 를 붙여줘야 한다.

 

- COALESCE : 하나씩 조회해서 null 이 아니면 반환한다.

- NULLIF : 두 값이 같으면 null 을 반환하고, 다르면 첫번째 값을 반환한다.

 

COALESCE 에 대한 사용법은 다음과 같다.

Team team = new Team();
team.setName("team A");
em.persist(team);

Member member = new Member();
member.setUsername(null);
member.setAge(10);
member.setTeam(team);
member.setType(MemberType.ADMIN);

em.persist(member);

em.flush();
em.clear();

String query = "select coalesce(m.username, '이름 없는 회원') from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();

for (String result : results) {
    System.out.println("result = " + result);
}

tx.commit();

 

쿼리는 유저 이름이 null 인 경우 '이름 없는 회원' 을 반환한다.

 

 

JPQL 함수

 

 

- CONCAT(s1, s2) : s1 와 s2 를 이어주는 함수

String query = "select concat('a', 'b') from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();

 

- SUBSTRING(s, a, b) : s 의 인덱스 a 부터 길이 b 만큼 가져오는 함수

String query = "select substring(m.username, 0, 5) from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();

 

- TRIM(s) : 문자열 s 의 양쪽 공백을 제거하는 함수

String query = "select trim(m.username) from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();

 

- LOWER(s), UPPER(s) : 문자열 s 를 전부 소문자 또는 대문자로 변경하는 함수

String query = "select upper(m.username) from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();

 

- LENGTH(s) : 문자열 s 의 길이를 반환하는 함수

String query = "select length(m.username) from Member m";
List<Integer> results = em.createQuery(query, Integer.class)
                .getResultList();

 

- LOCATE(s1, s2) : s2 문자열에 s1 문자열이 속해있는지를 확인 후 (인덱스 + 1) 을 반환하는 함수

   (단, 문자열이 속하지 않을 경우 0 을 반환)

String query = "select locate('de', 'abcdefg') from Member m";
List<Integer> results = em.createQuery(query, Integer.class)
                .getResultList();

 

- ABS(n), SQRT(n), MOD(n) : 말 그대로 절댓값, 제곱근, 모듈러를 해주는 함수

 

 

※ 사용자 정의 함수 호출

 

하이버네이트는 사용전 방언에 추가해야 한다.

사용하는 DB 방언을 상속받아서 사용자 정의 함수를 등록한다.

 

우선 MyH2Dialect 클래스를 H2Dialect 데이터베이스 방언에 상속받도록 한다. 

public class MyH2Dialect extends H2Dialect {

    public MyH2Dialect() {
        registerFunction("group_concat", new StandardSQLFunction("group_concat", StandardBasicTypes.STRING));
    }
}

 

그리고 resources 패키지 아래의 META_INF 패키지 아래에 persistence.xml 에서 속성을 변경시켜준다.

<property name="hibernate.dialect" value="dialect.MyH2Dialect"/>

 

이제 여러 멤버들을 저장한 후 등록한 사용자 함수 group_concat 을 사용해보자.

Member member1 = new Member();
member1.setUsername("admin1");
em.persist(member1);

Member member2 = new Member();
member2.setUsername("admin2");
em.persist(member2);

Member member3 = new Member();
member3.setUsername("admin3");
em.persist(member3);

em.flush();
em.clear();

String query = "select function('group_concat', m.username) from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();

for (String result : results) {
    System.out.println("result = " + result);
}

tx.commit();

 

정상적으로 이어지는 것을 확인할 수 있다.

 

function() 을 이용하지 않고도 해결할 수 있다.

String query = "select group_concat(m.username) from Member m";
List<String> results = em.createQuery(query, String.class)
                .getResultList();