hibernate hql 大全

轉自：http://www.cnblogs.com/bobomail/archive/2005/09/20/240352.html

Hibernate配備了一種很是強大的查詢語言，這種語言看上去很像SQL。可是不要被語法結構 上的類似所迷惑，HQL是很是有意識的被設計爲徹底面向對象的查詢，它能夠理解如繼承、多態 和關聯之類的概念。

 

第 15 章 HQL: Hibernate查詢語言

Hibernate配備了一種很是強大的查詢語言，這種語言看上去很像SQL。可是不要被語法結構 上的類似所迷惑，HQL是很是有意識的被設計爲徹底面向對象的查詢，它能夠理解如繼承、多態 和關聯之類的概念。

15.1. 大小寫敏感性問題

除了Java類與屬性的名稱外，查詢語句對大小寫並不敏感。 因此 SeLeCT 與 sELEct 以及 SELECT 是相同的，可是 org.hibernate.eg.FOO 並不等價於 org.hibernate.eg.Foo 而且 foo.barSet 也不等價於 foo.BARSET。

本手冊中的HQL關鍵字將使用小寫字母. 不少用戶發現使用徹底大寫的關鍵字會使查詢語句 的可讀性更強, 但咱們發現，當把查詢語句嵌入到Java語句中的時候使用大寫關鍵字比較難看。

15.2. from子句

Hibernate中最簡單的查詢語句的形式以下：

from eg.Cat

該子句簡單的返回eg.Cat類的全部實例。 一般咱們不須要使用類的全限定名, 由於 auto-import（自動引入） 是缺省的狀況。 因此咱們幾乎只使用以下的簡單寫法：

from Cat

大多數狀況下, 你須要指定一個別名, 緣由是你可能須要 在查詢語句的其它部分引用到Cat

from Cat as cat

這個語句把別名cat指定給類Cat 的實例, 這樣咱們就能夠在隨後的查詢中使用此別名了。 關鍵字as 是可選的，咱們也能夠這樣寫:

from Cat cat

子句中能夠同時出現多個類, 其查詢結果是產生一個笛卡兒積或產生跨表的鏈接。

from Formula, Parameter

from Formula as form, Parameter as param

查詢語句中別名的開頭部分小寫被認爲是實踐中的好習慣， 這樣作與Java變量的命名標準保持了一致 (好比，domesticCat)。

15.3. 關聯(Association)與鏈接(Join)

咱們也能夠爲相關聯的實體甚至是對一個集合中的所有元素指定一個別名, 這時要使用關鍵字join。

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

受支持的鏈接類型是從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

還有，一個"fetch"鏈接容許僅僅使用一個選擇語句就將相關聯的對象或一組值的集合隨着他們的父對象的初始化而被初始化，這種方法在使用到集合 的狀況下尤爲有用，對於關聯和集合來講，它有效的代替了映射文件中的外聯接 與延遲聲明（lazy declarations）. 查看 第 20.1 節 「 抓取策略(Fetching strategies) 」 以得到等多的信息。

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

一個fetch鏈接一般不須要被指定別名, 由於相關聯的對象不該當被用在 where 子句 (或其它任何子句)中。同時，相關聯的對象 並不在查詢的結果中直接返回，但能夠經過他們的父對象來訪問到他們。

注意fetch構造變量在使用了scroll() 或 iterate()函數 的查詢中是不能使用的。最後注意，使用full join fetch 與 right join fetch是沒有意義的。

若是你使用屬性級別的延遲獲取（lazy fetching）（這是經過從新編寫字節碼實現的），可使用 fetch all properties 來強制Hibernate當即取得那些本來須要延遲加載的屬性（在第一個查詢中）。

from Document fetch all properties order by name

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

15.4. select子句

select 子句選擇將哪些對象與屬性返 回到查詢結果集中. 考慮以下狀況:

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

該語句將選擇mates of other Cats。（其餘貓的配偶） 實際上, 你能夠更簡潔的用如下的查詢語句表達相同的含義:

select cat.mate from Cat cat

查詢語句能夠返回值爲任何類型的屬性，包括返回類型爲某種組件(Component)的屬性:

select cat.name from DomesticCat cat where cat.name like 'fri%'

select cust.name.firstName from Customer as cust

查詢語句能夠返回多個對象和（或）屬性，存放在 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

也可能直接返回一個實際的類型安全的Java對象,

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

假設類Family有一個合適的構造函數.

你可使用關鍵字as給「被選擇了的表達式」指派別名:

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

該查詢返回了一個Map的對象，內容是別名與被選擇的值組成的名-值映射。

15.5. 彙集函數

HQL查詢甚至能夠返回做用於屬性之上的彙集函數的計算結果:

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...)

你能夠在選擇子句中使用數學操做符、鏈接以及通過驗證的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 也可使用，它們具備與SQL相同的語義.

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

15.6. 多態查詢

一個以下的查詢語句:

from Cat as cat

不只返回Cat類的實例, 也同時返回子類 DomesticCat的實例. Hibernate 能夠在from子句中指定任何 Java 類或接口. 查詢會返回繼承了該類的全部持久化子類 的實例或返回聲明瞭該接口的全部持久化類的實例。下面的查詢語句返回全部的被持久化的對象：

from java.lang.Object o

接口Named 可能被各類各樣的持久化類聲明：

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

注意，最後的兩個查詢將須要超過一個的SQL SELECT.這代表order by子句 沒有對整個結果集進行正確的排序. (這也說明你不能對這樣的查詢使用Query.scroll()方法.)

15.7. where子句

where子句容許你將返回的實例列表的範圍縮小. 若是沒有指定別名，你可使用屬性名來直接引用屬性:

from Cat where name='Fritz'

若是指派了別名，須要使用完整的屬性名:

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

返回名爲（屬性name等於）'Fritz'的Cat類的實例。

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

將返回全部知足下面條件的Foo類的實例： 存在以下的bar的一個實例，其date屬性等於 Foo的startDate屬性。 複合路徑表達式使得where子句很是的強大，考慮以下狀況：

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

該查詢將被翻譯成爲一個含有錶鏈接（內鏈接）的SQL查詢。若是你打算寫像這樣的查詢語句

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

在SQL中，你爲達此目的將須要進行一個四表鏈接的查詢。

=運算符不只能夠被用來比較屬性的值，也能夠用來比較實例：

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

第二個查詢是有效的。此時不須要進行錶鏈接！

一樣也可使用複合標識符。好比Person類有一個複合標識符，它由country屬性 與medicareNumber屬性組成。

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

第二個查詢也不須要進行錶鏈接。

一樣的，特殊屬性class在進行多態持久化的狀況下被用來存取一個實例的鑑別值（discriminator value）。 一個嵌入到where子句中的Java類的名字將被轉換爲該類的鑑別值。

from Cat cat where cat.class = DomesticCat

你也能夠聲明一個屬性的類型是組件或者複合用戶類型（以及由組件構成的組件等等）。永遠不要嘗試使用以組件類型來結尾的路徑表達式（path-expression） （與此相反，你應當使用組件的一個屬性來結尾）。 舉例來講，若是store.owner含有一個包含了組件的實體address

store.owner.address.city    // 正確 store.owner.address         // 錯誤!

一個「任意」類型有兩個特殊的屬性id和class, 來容許咱們按照下面的方式表達一個鏈接（AuditLog.item 是一個屬性，該屬性被映射爲<any>）。

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

注意，在上面的查詢與句中，log.item.class 和 payment.class 將涉及到徹底不一樣的數據庫中的列。

15.8. 表達式

在where子句中容許使用的表達式包括 大多數你能夠在SQL使用的表達式種類:

• 數學運算符+, -, *, /

• 二進制比較運算符=, >=, <=, <>, !=, like

• 邏輯運算符and, or, not

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

• "簡單的" case, case ... when ... then ... else ... end,和 "搜索" case, 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()

• coalesce() 和 nullif()

• cast(... as ...), 其第二個參數是某Hibernate類型的名字，以及extract(... from ...)，只要ANSI cast() 和 extract() 被底層數據庫支持

• 任何數據庫支持的SQL標量函數，好比sign(), trunc(), rtrim(), sin()

• JDBC參數傳入 ?

• 命名參數:name, :start_date, :x1

• SQL 直接常量 'foo', 69, '1970-01-01 10:00:01.0'

• Java public static final 類型的常量 eg.Color.TABBY

關鍵字in與between可按以下方法使用:

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 null與is not null能夠被用來測試空值(null).

在Hibernate配置文件中聲明HQL「查詢替代（query substitutions）」以後， 布爾表達式（Booleans）能夠在其餘表達式中輕鬆的使用:

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

系統將該HQL轉換爲SQL語句時，該設置代表將用字符 1 和 0 來 取代關鍵字true 和 false:

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

對於索引了（有序）的集合，你可使用minindex 與 maxindex函數來引用到最小與最大的索引序數。 同理，你可使用minelement 與 maxelement函數來 引用到一個基本數據類型的集合中最小與最大的元素。

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

在傳遞一個集合的索引集或者是元素集(elements與indices 函數) 或者傳遞一個子查詢的結果的時候，可使用SQL函數any, some, all, exists, in

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)

注意，在Hibernate3種，這些結構變量- size, elements, indices, minindex, maxindex, minelement, maxelement - 只能在where子句中使用。

一個被索引過的（有序的）集合的元素(arrays, lists, maps)能夠在其餘索引中被引用（只能在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

對於一個一對多的關聯（one-to-many association）或是值的集合中的元素， HQL也提供內建的index()函數，

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

若是底層數據庫支持標量的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     )

15.9. order by子句

查詢返回的列表(list)能夠按照一個返回的類或組件（components)中的任何屬性（property）進行排序：

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

可選的asc或desc關鍵字指明瞭按照升序或降序進行排序.

15.10. group by子句

一個返回彙集值(aggregate values)的查詢能夠按照一個返回的類或組件（components)中的任何屬性（property）進行分組：

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)

若是底層的數據庫支持的話(例如不能在MySQL中使用)，SQL的通常函數與彙集函數也能夠出現 在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子句中都不能包含算術表達式（arithmetic expressions）.

15.11. 子查詢

對於支持子查詢的數據庫，Hibernate支持在查詢中使用子查詢。一個子查詢必須被圓括號包圍起來（常常是SQL彙集函數的圓括號）。 甚至相互關聯的子查詢（引用到外部查詢中的別名的子查詢）也是容許的。

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列表中包含一個表達式以上的子查詢，你可使用一個元組構造符（tuple constructors）：

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

注意在某些數據庫中（不包括Oracle與HSQL），你也能夠在其餘語境中使用元組構造符， 好比查詢用戶類型的組件與組合：

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

該查詢等價於更復雜的：

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

有兩個很好的理由使你不該看成這樣的事情：首先，它不徹底適用於各個數據庫平臺；其次，查詢如今依賴於映射文件中屬性的順序。

15.12. HQL示例

Hibernate查詢能夠很是的強大與複雜。實際上，Hibernate的一個主要賣點就是查詢語句的威力。這裏有一些例子，它們與我在最近的 一個項目中使用的查詢很是類似。注意你能用到的大多數查詢比這些要簡單的多！

下面的查詢對於某個特定的客戶的全部未支付的帳單，在給定給最小總價值的狀況下，返回訂單的id，條目的數量和總價值， 返回值按照總價值的結果進行排序。爲了決訂價格，查詢使用了當前目錄。做爲轉換結果的SQL查詢，使用了ORDER, ORDER_LINE, PRODUCT, CATALOG 和PRICE 庫表。

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狀態的支付，由於在該狀態下 當前的用戶做出了狀態的最新改變。該查詢被轉換成含有兩個內鏈接以及一個相關聯的子選擇的SQL查詢，該查詢使用了表 PAYMENT, PAYMENT_STATUS 以及PAYMENT_STATUS_CHANGE。

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實例集映射爲一個列表（list）而不是一個集合（set）, 書寫查詢語句將更加簡單.

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進行的三個內鏈接， 一個外鏈接和一個子選擇的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

對於一些數據庫，咱們須要棄用（相關的）子選擇。

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

15.13. 批量的UPDATE & DELETE語句

HQL如今支持UPDATE與DELETE語句. 查閱 第 14.3 節 「大批量更新/刪除（Bulk update/delete）」 以得到更多信息。

15.14. 小技巧 & 小竅門

你能夠統計查詢結果的數目而沒必要實際的返回他們：

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

若想根據一個集合的大小來進行排序，可使用以下的語句：

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)

若是你的數據庫支持子選擇，你能夠在你的查詢的where子句中爲選擇的大小（selection size）指定一個條件:

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

若是你的數據庫不支持子選擇語句，使用下面的查詢：

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

由於內鏈接（inner join）的緣由，這個解決方案不能返回含有零個信息的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的屬性能夠被綁定到一個命名查詢（named query）的參數上：

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

經過將接口Query與一個過濾器（filter）一塊兒使用，集合（Collections）是能夠分頁的：

Query q = s.createFilter( collection, "" ); // 一個簡單的過濾器 q.setMaxResults(PAGE_SIZE); q.setFirstResult(PAGE_SIZE * pageNumber); List page = q.list();

經過使用查詢過濾器（query filter）能夠將集合（Collection）的原素分組或排序:

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

不用經過初始化，你就能夠知道一個集合（Collection）的大小：

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