14장. HQL: Hibernate Query Language

Hibernate는 (아주 의도적으로) SQL과 매우 흡사하게 보이는 극히 강력한 질의 언어를 구비하고 있다. 그러나 그 구문에 의해 우롱당하지 말라; HQL은 상속, 다형성 그리고 연관과 같은 개념들을 이해하여서, 전체적으로 객체 지향적이다.

14.1. 대소문자 구분

질의들은 Java 클래스들과 프로퍼티들의 이름들을 제외하면 대소문자를 구분하지 않는다. 따라서 SeLeCTSELECT와 같고 SELECT와도 같지만 org.hibernate.eg.FOOorg.hibernate.eg.Foo과 같지 않고 foo.barSetfoo.BARSET과 같지 않다.

이 매뉴얼은 소문자 HQL 키워드를 사용한다. 몇몇 사용자들은 보다 나은 가독성을 위해 대문자 키워드들을 가진 질의들을 찾지만, 우리는 자바 코드 속에 삽입될 때 이 컨벤션이 추하다는 점을 발견한다.

14.2. from 절

가장 간단한 가능한 Hibernate 질의는 다음 형식이다:

from eg.Cat

이것은 eg.Cat 클래스의 모든 인스턴스들을 간단하게 반환한다. 우리는 대개 클래스 이름을 수식할 필요가 없다. 왜냐하면, auto-import가 디폴트이기 때문이다. 따라서 우리는 대개 항상 단지 다음과 같이 작성한다:

from Cat

대개 당신은 한 개의 alias를 할당할 필요가 있을 것이다. 왜냐하면 당신은 질의의 다른 부분들에서 Cat을 참조하고자 원할 것이기 때문이다.

from Cat as cat

이 질의는 alias catCat 인스턴스들에 할당하여서, 우리는 나중에 질의 속에서 그 alias를 사용할 수 있을 것이다. as 키워드는 옵션이다; 우리는 또한 다음과 같이 작성할 수 있다:

from Cat cat

여러 개의 클래스들은 cartesian product(카티젼 곱) 또는 "크로스" 조인으로 귀결되어 나타날 수도 있다.

from Formula, Parameter
from Formula as form, Parameter as param

로컬 변수들에 대한 Java 네이밍 표준들과 일치되게, 첫 소문자를 사용하여 질의 alias들을 명명하는 것은 좋은 습관으로 간주된다 (예를 들면 domesticCat).

14.3. 연관들과 조인들

우리는 또한 join을 사용하여 , 연관된 엔티티들에 또는 값들을 가진 콜렉션의 요소들에도 alias들을 할당할 수도 있다.

from Cat as cat 
    inner join cat.mate as mate
    left outer join cat.kittens as kitten
from Cat as cat left join cat.mate.kittens as kittens
from Formula form full join form.parameter param

지원되는 join 타입들은 ANSI SQL로부터 빌려왔다

  • inner join

  • left outer join

  • right outer join

  • full join (대개 유용하지 않음)

inner join, left outer join, 그리고 right outer join 구조체들이 약칭될 수 있다.

from Cat as cat 
    join cat.mate as mate
    left join cat.kittens as kitten

당신은 HQL with 키워드를 사용하여 특별한 조인 조건들을 제공할 수 있다.

from Cat as cat 
    left join cat.kittens as kitten 
        with kitten.bodyWeight > 10.0

게다가, "fetch" join은 값들을 가진 콜렉션들이나 연관관계들이 한 개의 select를 사용하여, 그것들의 부모 객체들에 따라 초기화 되는 것을 허용해준다. 이것은 콜렉션의 경우에 특히 유용하다. 그것은 연관관계들과 콜렉션들에 대한 매핑 파일의 outer join과 lazy 선언들을 효율적으로 오버라이드 시킨다. 추가 정보는 19.1절. “페칭 방도들”을 보라.

from Cat as cat 
    inner join fetch cat.mate
    left join fetch cat.kittens

fetch join은 대개 alias를 할당할 필요가 없다. 왜냐하면, 연관된 객체들이 where 절(또는 어떤 다른 절) 속에 사용되지 않을 것이기 때문이다. 또한 연관된 객체들은 질의 결과들 속에 직접 반환되지 않는다. 대신 그것들은 부모 객체를 통해 접근될 수 있다. 우리가 alias를 필요로 할 수 있는 유일한 이유는 더 많은 콜렉션들을 재귀적으로 조인 페칭시키는 경우이다:

from Cat as cat 
    inner join fetch cat.mate
    left join fetch cat.kittens child
    left join fetch child.kittens

(비록 scroll()이 사용될 수 있을지라도) fetch 구조체는 iterate()를 사용하여 호출되는 질의들 내에 사용될 수 없음을 노트하라. 이들 오퍼레이션들이 결과 행들에 기초하고 있기 때문에 fetchsetMaxResults() 또는 setFirstResult()과 함께 사용되지 말아야 하며, 그것들(결과 행들)은 대개 각각의 eager 콜렉션 페칭에 대해 중복들을 포함하므로 많은 행들이 당신이 기대하는 것이 아니다. fetch는 특별한 용도의 with 조건과도 함께 사용될 수 없다.한 개의 질의 내에 하나 이상의 콜렉션을 조인 페칭시켜 카티젼 곱을 생성시키는 것이 가능한데, 이 경우에 주의하라. 다중 콜렉션 role들을 조인 페칭시키는 것은 또한 때때로 bag 매핑들에 대해 예기치 않은 결과들을 가져다주기 때문에, 당신이 이 경우에 당신의 질의들을 처방하는 방법에 대해 주의하라. 마지막으로 full join fetchright join fetch는 의미가 없다.

만일 당신이 (바이트코드 방편으로) property-레벨 lazy 페칭을 사용할 경우, Hibernate로 하여금 fetch all properties를 사용하여 (첫 번째 질의에서) lazy 프로퍼티들을 즉시 페치하도록 강제시키는 것이 가능하다.

from Document fetch all properties order by name
from Document doc fetch all properties where lower(doc.name) like '%cats%'

14.4. join 구문의 형식들

HQL은 두 가지 형식의 연관 조인을 지원한다: 암묵적 그리고 명시적.

앞의 절에서 보여진 질의들은 모두 join 키워드가 from 절 내에 명시적으로 사용되는 명시적인 형식을 사용한다. 이것은 권장되는 형식이다.

함축적인 형식은 join 키워드를 사용하지 않는다. 대신에, 연관들은 dot(.) 표기를 사용하여 "dot-참조된다(dereferenced)". 함축적인 조인들은 임의의 HQL 절들내에 나타날 수 있다. 함축적인 join은 결과되는 SQL 문장에서 inner join으로 귀결된다.

from Cat as cat where cat.mate.name like '%s%'

14.5. select 절

select 절은 질의 결과 셋 속에 반환할 객체들과 프로퍼티들이 어느 것인지를 골라 내도록 강제한다. 다음을 검토하자:

select mate 
from Cat as cat 
    inner join cat.mate as mate

질의는 다른 Cat들의 mate들을 select 할 것이다. 실제로 당신은 이 질의들을 다음과 같이 보다 축약형으로 표현할수도 있다:

select cat.mate from Cat cat

질의들은 컴포넌트 타입의 프로퍼티들을 포함하는 임의의 값 타입의 프로퍼티들을 반환할 수도 있다:

select cat.name from DomesticCat cat
where cat.name like 'fri%'
select cust.name.firstName from Customer as cust

Family 클래스가 적당한 생성자를 갖고 있음을 가정하면, 질의들은 여러 객체들 그리고/또는 프로퍼티들을 Object[] 타입의 배열로서,

select mother, offspr, mate.name 
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

또는 List로서,

select new list(mother, offspr, mate.name)
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

또는 실제 typesafe 자바 객체로서,

select new Family(mother, mate, offspr)
from DomesticCat as mother
    join mother.mate as mate
    left join mother.kittens as offspr

반환할 수도 있다.

당신은 as를 사용하여 select되는 표현식들에 alias들을 할당할 수 있다:

select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
from Cat cat

다음은 select new map과 함께 사용될 때 가장 유용하다:

select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
from Cat cat

이 질의는 select된 값들에 대한 alias로부터 한 개의 Map을 반환한다.

14.6. 집계 함수들

HQL 질의들은 프로퍼티들에 대한 집계(aggregate) 함수들의 결과들을 반환할수도 있다:

select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
from Cat cat

지원되는 집계 함수들은 다음과 같다

  • avg(...), sum(...), min(...), max(...)

  • count(*)

  • count(...), count(distinct ...), count(all...)

당신은 select 절 속에 산술 연산자들, 연결 연산자, 그리고 인지된 SQL 함수들을 사용할 수 있다:

select cat.weight + sum(kitten.weight) 
from Cat cat 
    join cat.kittens kitten
group by cat.id, cat.weight
select firstName||' '||initial||' '||upper(lastName) from Person

distinct 키워드와 all all가 사용될 수 있고 SQL의 경우와 동일한 의미를 갖는다.

select distinct cat.name from Cat cat

select count(distinct cat.name), count(cat) from Cat cat

14.7. Polymorphic(다형성) 질의들

다음과 같은 질의:

from Cat as cat

Cat의 인스턴스들 뿐만 아니라, 또한 DomesticCat과 같은 서브클래스들 또한 반환한다. Hibernate 질의들은 from 절 내에 임의의 자바 클래스나 인터페이스를 명명할 수 있다. 질의는 그 클래스를 확장하거나 그 인터페이스를 구현하는 모든 영속 클래스들의 인스턴스들을 반환할 것이다. 다음 질의는 모든 영속 객체들을 반환할 것이다:

from java.lang.Object o

인터페이스 Named는 여러 가지 영속 클래스들에 의해 구현될 수도 있다:

from Named n, Named m where n.name = m.name

이들 마지막 두 개의 질의들은 하나 이상의 SQL SELECT를 필요로 할 것임을 노트하라. 이것은 order by 절이 정확하게 전체 결과 셋을 순서지우지 않음을 의미한다.(그것은 또한 당신이 Query.scroll()을 사용하여 이들 질의들을 호출할 수 없음을 의미한다).

14.8. where 절

where 절은 반환된 인스턴스들의 목록을 제한시키는 것을 당신에게 허용해준다. 만일 alias가 존재하지 않을 경우, 당신은 이름에 의해 프로퍼티들을 참조할 수도 있다:

from Cat where name='Fritz'

만일 한 개의 alias가 존재할 경우, 하나의 수식어가 붙은 프로퍼티 이름을 사용하라:

from Cat as cat where cat.name='Fritz'

는 'Fritz'로 명명된 Cat의 인스턴스들을 반환한다.

select foo 
from Foo foo, Bar bar
where foo.startDate = bar.date

FoostartDate 프로퍼티와 동일한 date 프로퍼티를 가진 bar의 인스턴스가 존재하는 Foo의 모든 인스턴스를 반환할 것이다. 합성 경로 표현식들은 where 절을 매우 강력하게 만들어준다. 다음을 검토하자:

from Cat cat where cat.mate.name is not null

이 질의는 테이블 (inner) join을 가진 SQL 질의로 번역된다. 만일 당신이 다음과 같은 어떤 것을 작성했다면

from Foo foo  
where foo.bar.baz.customer.address.city is not null

당신은 SQL에서 네 개의 테이블 join들을 필요로 하는 하나의 질의로 끝낼 것이다.

= 연산자는 프로퍼티들 뿐만 아니라 또한 인스턴스들을 비교하는데 사용될 수 있다:

from Cat cat, Cat rival where cat.mate = rival.mate
select cat, mate 
from Cat cat, Cat mate
where cat.mate = mate

특별한 프로퍼티(소문자) id는 객체의 유일 식별자를 참조하는데 사용될 수 있다.(당신은 또한 그것의 프로퍼티 이름을 사용할 수도 있다.)

from Cat as cat where cat.id = 123

from Cat as cat where cat.mate.id = 69

두 번째 질의가 효율적이다. 테이블 join이 필요 없다!

composite identifier(합성 식별자)들의 프로퍼티들이 또한 사용될 수 있다. PersoncountrymedicareNumber로 구성된 composite identifier를 갖는다고 가정하자.

from bank.Person person
where person.id.country = 'AU' 
    and person.id.medicareNumber = 123456
from bank.Account account
where account.owner.id.country = 'AU' 
    and account.owner.id.medicareNumber = 123456

다시 한번, 두 번째 질의는 테이블 join을 필요로 하지 않는다.

마찬가지로, 특별한 프로퍼티 class는 다형적인 영속성(polymorphic persistence)의 경우에 인스턴스의 판별자(discriminator) 값에 액세스한다. where 절 속에 삽입된 Java 클래스 이름은 그것의 판별자(discriminator) 값으로 변환될 것이다.

from Cat cat where cat.class = DomesticCat

당신은 또한 컴포넌트들 또는 composite 사용자 정의 타입들의 (그리고 컴포넌트들의 컴포넌트들, 기타의) 프로퍼티들을 지정할 수도 있다. (컴포넌트의 프로퍼티와은 반대로) 컴포넌트 타입의 프로퍼티로 끝나는 경로-표현식을 사용하려고 결코 시도하지 말라. 예를 들어, 만일 store.owner가 컴포넌트 address를 가진 엔티티일 경우

store.owner.address.city    // okay
store.owner.address         // error!

"임의의" 타입은 다음 방법으로 join을 표현하는 것을 우리에게 허용해주는, 특별한 프로퍼티들 idclass를 갖는다(여기서 AuditLog.item<any>로 매핑된 프로퍼티이다).

from AuditLog log, Payment payment 
where log.item.class = 'Payment' and log.item.id = payment.id

log.item.classpayment.class는 위의 질의 내에서 완전히 다른 데이터베이스 컬럼들의 값들을 참조할 것임을 노트하라.

14.9. 표현식들

where 절 속에 허용되는 표현식들은 당신이 SQL로 작성할 수 있는 대부분의 종류의 것들을 포함한다:

  • 산술 연산자들 +, -, *, /

  • 바이너리 비교 연산자들 =, >=, <=, <>, !=, like

  • 논리 연산들 and, or, not

  • 그룹핑을 나타내는 괄호들 ( ), indicating grouping

  • in, not in, between, is null, is not null, is empty, is not empty, member of and not member of

  • "간단한" 경우, case ... when ... then ... else ... end, 그리고 "검색인" 경우, case when ... then ... else ... end

  • 문자열 연결 ...||... or concat(...,...)

  • current_date(), current_time(), current_timestamp()

  • second(...), minute(...), hour(...), day(...), month(...), year(...),

  • EJB-QL 3.0에 의해 정의된 임의의 함수 또는 오퍼레이터: substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()

  • coalesce() 그리고 nullif()

  • numeric 값들이나 temporal 값들을 가독성 있는 문자열로 변환시키는 str()

  • 조인된 인덱싱된 콜렉션의 alias들에 적용되는, HQL index() 함수

  • 콜렉션 값을 가진 경로 표현식들을 취하는 HQL 함수들 : some, all, exists, any, in을 사용하여 정량화 될 수 있는 특별한 elements()indices 함수들과 함께 size(), minelement(), maxelement(), minindex(), maxindex().

  • cast(... as ...), 여기서 두번 째 아규먼트는 Hibernate 타입의 이름이고, ANSI cast()extract()가 기본 데이터베이스에 의해 지원될 경우에는 extract(... from ...)

  • 조인된 인덱싱된 콜렉션의 alias들을 적용하는 HQL index() 함수

  • 콜렉션 값 경로 표현식들을 취하는 HQL 함수들: some, all, exists, any, in을 사용하여 양이 한정될 수 있는 특별한 elements()indices 함수들과 함께 size(), minelement(), maxelement(), minindex(), maxindex() 함수들.

  • sign(), trunc(), rtrim(), sin()과 같이 임의의 데이터베이스-지원 SQL 스칼라 함수

  • JDBC-스타일 위치 파라미터들 ?

  • 명명된 파라미터들 :name, :start_date, :x1

  • SQL 리터럴들 'foo', 69, 6.66E+2, '1970-01-01 10:00:01.0'

  • Java public static final 상수들. eg.Color.TABBY

inbetween은 다음과 같이 사용될 수 있다:

from DomesticCat cat where cat.name between 'A' and 'B'
from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )

그리고 부정형들은 다음과 같이 작성될 수 있다

from DomesticCat cat where cat.name not between 'A' and 'B'
from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )

마찬가지로, is nullis not null은 null 값들을 테스트하는데 사용될 수 있다.

Boolean들은 Hibernate 구성 내에 HQL 질의 치환들을 선언함으로써 표현식들 내에 쉽게 사용될 수 있다:

<property name="hibernate.query.substitutions">true 1, false 0</property>

이것은 키워드 truefalse 키워드들을 이 HQL로부터 번역된 SQL에서 리터럴 10으로 대체될 것이다:

from Cat cat where cat.alive = true

당신은 특별한 프로퍼티 size로서 또는 특별한 size() 함수로서 콜렉션의 사이즈를 테스트할 수 있다.

from Cat cat where cat.kittens.size > 0
from Cat cat where size(cat.kittens) > 0

인덱싱된 콜렉션들에 대해, 당신은minindexmaxindex 함수들을 사용하여 최소 인덱스과 최대 인덱스를 참조할 수 있다. 유사하게 당신은 minelementmaxelement 함수를 사용하여 기본 타입을 가진 콜렉션의 최소 요소 및 최대 요소를 참조할 수 있다.

from Calendar cal where maxelement(cal.holidays) > current_date
from Order order where maxindex(order.items) > 100
from Order order where minelement(order.items) > 10000

SQL 함수들 any, some, all, exists, in은 콜렉션의 요소 또는 인덱스 세트(elements 함수와 indices 함수), 또는 서브질의의 결과를 전달했을 때 지원된다(아래를 보라).

select mother from Cat as mother, Cat as kit
where kit in elements(foo.kittens)
select p from NameList list, Person p
where p.name = some elements(list.names)
from Cat cat where exists elements(cat.kittens)
from Player p where 3 > all elements(p.scores)
from Show show where 'fizard' in indices(show.acts)

이들 구조체들-size, elements, indices, minindex, maxindex, minelement, maxelement-는 Hibernate3에서 where 절 내에서만 사용될 것임을 노트하라.

인덱싱 된 콜렉션들의 요소들(배열들, 리스트들, map들)은 인덱스에 의해 참조될 수 있다(where 절 안에서만):

from Order order where order.items[0].id = 1234
select person from Person person, Calendar calendar
where calendar.holidays['national day'] = person.birthDay
    and person.nationality.calendar = calendar
select item from Item item, Order order
where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11
select item from Item item, Order order
where order.items[ maxindex(order.items) ] = item and order.id = 11

[] 내부의 표현식은 산술 표현실일 수 있다.

select item from Item item, Order order
where order.items[ size(order.items) - 1 ] = item

HQL은 또한 one-to-many 연관 또는 값들을 가진 콜렉션의 요소들에 대해 미리 만들어진 index() 함수를 제공한다.

select item, index(item) from Order order 
    join order.items item
where index(item) < 5

기본 데이터베이스에 의해 제공되는 Scalar SQL 함수들이 사용될 수도 있다

from DomesticCat cat where upper(cat.name) like 'FRI%'

당신이 아직 이 모든 것을 납득하지 못한다면, SQL 내에서 다음 질의가 가독성이 얼마나 많고 적은지를 생각해보라:

select cust
from Product prod,
    Store store
    inner join store.customers cust
where prod.name = 'widget'
    and store.location.name in ( 'Melbourne', 'Sydney' )
    and prod = all elements(cust.currentOrder.lineItems)

힌트 : 다음과 같은 어떤 것

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order
FROM customers cust,
    stores store,
    locations loc,
    store_customers sc,
    product prod
WHERE prod.name = 'widget'
    AND store.loc_id = loc.id
    AND loc.name IN ( 'Melbourne', 'Sydney' )
    AND sc.store_id = store.id
    AND sc.cust_id = cust.id
    AND prod.id = ALL(
        SELECT item.prod_id
        FROM line_items item, orders o
        WHERE item.order_id = o.id
            AND cust.current_order = o.id
    )

14.10. order by 절

질의에 의해 반환된 리스트는 반환된 클래스 또는 컴포넌트들의 프로퍼티에 의해 순서(ordering)지워질 수 있다:

from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate

asc 옵션 또는 desc 옵션은 각각 오름차순 또는 내림차순 정렬을 나타낸다.

14.11. group by 절

aggregate 값들을 반환하는 질의는 반환된 클래스나 컴포넌트들의 프로퍼티에 의해 그룹지워질 수 있다:

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color
select foo.id, avg(name), max(name) 
from Foo foo join foo.names name
group by foo.id

또한 having 절이 허용된다.

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color 
having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

SQL 함수들과 집계 함수들이 기본 데이터베이스에 의해 지원될 경우(예를 들어 MySQL은 지원되지 않는다) having 절과 order by 절 속에 허용된다.

select cat
from Cat cat
    join cat.kittens kitten
group by cat
having avg(kitten.weight) > 100
order by count(kitten) asc, sum(kitten.weight) desc

group by 절도 order by 절 어느 것도 산술 표현식들을 포함할 수 없다는 점을 노트하라.

14.12. 서브질의들

subselect들을 지원하는 데이터베이스들의 경우, Hibernate는 질의들 내에 서브질의들을 지원한다. 서브질의는 괄호로 묶여져야 한다(자주 SQL 집계함수 호출에 의해). 심지어 서로 상관된 서브질의들(외부 질의 내에서 alias를 참조하는 서브질의들)이 허용된다.

from Cat as fatcat 
where fatcat.weight > ( 
    select avg(cat.weight) from DomesticCat cat 
)
from DomesticCat as cat 
where cat.name = some ( 
    select name.nickName from Name as name 
)
from Cat as cat 
where not exists ( 
    from Cat as mate where mate.mate = cat 
)
from DomesticCat as cat 
where cat.name not in ( 
    select name.nickName from Name as name 
)
select cat.id, (select max(kit.weight) from cat.kitten kit) 
from Cat as cat

select 리스트 내에 있는 하나 이상의 표현식을 가진 서브질의들의 경우에 당신은 tuple 생성자를 사용할 수 있다:

from Cat as cat 
where not ( cat.name, cat.color ) in ( 
    select cat.name, cat.color from DomesticCat cat 
)

HQL 서브질의들이 select 절 또는 where 절 내에서만 일어날 수 있음을 노트하라.

(Oracle 또는 HSQL이 아닌) 몇몇 데이터베이스들 상에서, 당신은 다른 컨텍스트들 내에서, 예를 들면 component들이나 composite 사용자 타입들을 질의할 때 tuple 생성자들을 사용할 수 있음을 노트하라:

from Person where name = ('Gavin', 'A', 'King')

이것을 더 풀어쓰면 다음과 동일하다:

from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')

당신이 이런 종류의 것을 행하는 것을 원하지 않을 수 있는 두 가지 좋은 이유들이 존재한다: 첫 번째로 데이터베이스 플랫폼들 사이에 완전하게 이식성이 없다; 두 번째로 그 질의는 이제 매핑 문서 속에 있는 프로퍼티들의 순서에 의존한다.

14.13. HQL 예제들

Hibernate 질의들은 매우 강력하고 복잡할 수 있다. 사실, 질의 언어의 힘은 Hibernate의 주요 판매 포인트들 중 하나이다. 다음은 내가 최근의 프로젝트에서 사용했던 질의들과 매우 유사한 몇몇 예제 질의들이다. 당신이 작성하게 될 대부분의 질의들은 이것들보다 훨씬 간단하다는 점을 노트하라!

다음 질의는 특정 고객에 대한 모든 지불되지 않은 주문들의 주문 id, 항목들의 개수, 그리고 주문의 전체 합계값 그리고 주어진 최소 전체 합계를 전체 합계값에 따라 결과들을 순서지워서 반환한다. 가격 결정에 있어, 그것은 현재의 카타록을 사용한다. 귀결되는 SQL 질의는 ORDER, ORDER_LINE, PRODUCT, CATALOG, PRICE 테이블들에 대한 네 개의 inner 조인들과 한 개의(상관지워지지 않은) subselect를 갖고 있다.

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog.effectiveDate < sysdate
    and catalog.effectiveDate >= all (
        select cat.effectiveDate 
        from Catalog as cat
        where cat.effectiveDate < sysdate
    )
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

괴물 같은 것! 실제로 실 생활에서, 나는 서브질의들을 매우 좋아하지 않아서, 나의 질의는 실제로 다음과 같았다:

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog = :currentCatalog
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

다음 질의는 현재 사용자에 의해 가장 최근의 상태 변경이 행해졌던 AWAITING_APPROVAL 상태에 있는 모든 지불들을 제외한, 각각의 상태에 있는 지불들의 개수를 카운트 한다. 그것은 PAYMENT, PAYMENT_STATUS, PAYMENT_STATUS_CHANGE 테이블들에 대한 두 개의 inner 조인들과 하나의 상관관계 지워진 subselect를 가진 SQL 질의로 변환된다.

select count(payment), status.name 
from Payment as payment 
    join payment.currentStatus as status
    join payment.statusChanges as statusChange
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or (
        statusChange.timeStamp = ( 
            select max(change.timeStamp) 
            from PaymentStatusChange change 
            where change.payment = payment
        )
        and statusChange.user <> :currentUser
    )
group by status.name, status.sortOrder
order by status.sortOrder

만일 내가 statusChanges 콜렉션을 set가 아닌 list로 매핑했다면, 그 질의는 작성하기가 훨씬 더 간단했을 것이다.

select count(payment), status.name 
from Payment as payment
    join payment.currentStatus as status
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser
group by status.name, status.sortOrder
order by status.sortOrder

다음 질의는 현재의 사용자가 속해 있는 조직의 모든 계정들과 지불되지 않은 지불들을 반환하는데 MS SQL Server isNull() 함수를 사용한다. 그것은 ACCOUNT, PAYMENT, PAYMENT_STATUS, ACCOUNT_TYPE, ORGANIZATION, ORG_USER 테이블들에 대한 세 개의 inner 조인들, 하나의 outer 조인, 그리고 하나의 subselect를 가진 한 개의 SQL 질의로 번역된다.

select account, payment
from Account as account
    left outer join account.payments as payment
where :currentUser in elements(account.holder.users)
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

몇몇 데이터베이스들의 경우, 우리는 (상관관계 지워진) subselect를 없앨 필요가 있을 것이다.

select account, payment
from Account as account
    join account.holder.users as user
    left outer join account.payments as payment
where :currentUser = user
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

14.14. 대량 update와 delete

HQL은 이제 update, delete 그리고 insert ... select ... 문장들을 지원한다. 상세한 것은 13.4절. “DML-스타일 연산들”를 보라.

14.15. 팁들 & 트릭들

당신은 실제로 질의 결과들을 반환하지 않고서 그것들(질의 결과들)의 개수를 카운트할 수 있다:

( (Integer) session.iterate("select count(*) from ....").next() ).intValue()

콜렉션의 크기에 따라 결과를 순서(ordering)지우려면, 다음 질의를 사용하라:

select usr.id, usr.name
from User as usr 
    left join usr.messages as msg
group by usr.id, usr.name
order by count(msg)

만일 당신의 데이터베이스가 subselect들을 지원할 경우, 당신은 당신의 질의의 where 절 내에 selection 사이즈에 대한 조건을 위치지울 수 있다:

from User usr where size(usr.messages) >= 1

만일 당신의 데이터베이스가 subselect를 지원하지 않을 경우, 다음 질의를 사용하라:

select usr.id, usr.name
from User usr.name
    join usr.messages msg
group by usr.id, usr.name
having count(msg) >= 1

이 해결책이 inner 조인 때문에 0개의 메시지를 가진 User를 반환할 수 없으므로, 다음 형식이 또한 유용하다:

select usr.id, usr.name
from User as usr
    left join usr.messages as msg
group by usr.id, usr.name
having count(msg) = 0

하나의 JavaBean의 프로퍼티들은 명명된 질의 파라미터들에 바인드될 수 있다:

Query q = s.createQuery("from foo Foo as foo where foo.name=:name and foo.size=:size");
q.setProperties(fooBean); // fooBean has getName() and getSize()
List foos = q.list();

콜렉션들은 필터를 가진 Query 인터페이스를 사용하여 쪼매김하는 것이 가능하다:

Query q = s.createFilter( collection, "" ); // the trivial filter
q.setMaxResults(PAGE_SIZE);
q.setFirstResult(PAGE_SIZE * pageNumber);
List page = q.list();

콜렉션 요소들은 질의 필터를 사용하여 순서(ordering)지워지거나 그룹지워질 수 도 있다:

Collection orderedCollection = s.filter( collection, "order by this.amount" );
Collection counts = s.filter( collection, "select this.type, count(this) group by this.type" );

당신은 콜렉션을 초기화 하지 않고서 그것(콜렉션)의 크기를 찾을 수 있다:

( (Integer) session.iterate("select count(*) from ....").next() ).intValue();