semovy

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

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

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

我們也可以為相關聯的實體甚至是對一個集合中的全部元素指定一個別名, 這時要使用關鍵字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 可以簡寫。

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%'

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的對象，內容是別名與被選擇的值組成的名-值映射。

HQL查詢甚至可以返回作用于屬性之上的聚集函數的計算結果:

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

受支持的聚集函數如下：

你可以在選擇子句中使用數學操作符、連接以及經過驗證的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

一個如下的查詢語句:

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()方法.)

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 將涉及到完全不同的數據庫中的列。

在where子句中允許使用的表達式包括 大多數你可以在SQL使用的表達式種類:

關鍵字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
)

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

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

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

一個返回聚集值(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）.

對于支持子查詢的數據庫，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')

有兩個很好的理由使你不應當作這樣的事情：首先，它不完全適用于各個數據庫平臺；其次，查詢現在依賴于映射文件中屬性的順序。

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

HQL現在支持UPDATE與DELETE語句. 查閱 第 14.3 節 “大批量更新/刪除（Bulk update/delete）” 以獲得更多信息。

你可以統計查詢結果的數目而不必實際的返回他們：

( (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();

org.hibernate.Criteria接口表示特定持久類的一個查詢。Session是 Criteria實例的工廠。

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

一個單獨的查詢條件是org.hibernate.criterion.Criterion 接口的一個實例。org.hibernate.criterion.Restrictions類 定義了獲得某些內置Criterion類型的工廠方法。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.between("weight", minWeight, maxWeight) )
.list();

約束可以按邏輯分組。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.or(
Restrictions.eq( "age", new Integer(0) ),
Restrictions.isNull("age")
) )
.list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
.add( Restrictions.disjunction()
.add( Restrictions.isNull("age") )
.add( Restrictions.eq("age", new Integer(0) ) )
.add( Restrictions.eq("age", new Integer(1) ) )
.add( Restrictions.eq("age", new Integer(2) ) )
) )
.list();

Hibernate提供了相當多的內置criterion類型(Restrictions 子類), 但是尤其有用的是可以允許你直接使用SQL。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%", Hibernate.STRING) )
.list();

{alias}占位符應當被替換為被查詢實體的列別名。

Property實例是獲得一個條件的另外一種途徑。你可以通過調用Property.forName() 創建一個Property。

Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
.add( Restrictions.disjunction()
.add( age.isNull() )
.add( age.eq( new Integer(0) ) )
.add( age.eq( new Integer(1) ) )
.add( age.eq( new Integer(2) ) )
) )
.add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
.list();

你可以使用org.hibernate.criterion.Order來為查詢結果排序。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.addOrder( Order.asc("name") )
.addOrder( Order.desc("age") )
.setMaxResults(50)
.list();

List cats = sess.createCriteria(Cat.class)
.add( Property.forName("name").like("F%") )
.addOrder( Property.forName("name").asc() )
.addOrder( Property.forName("age").desc() )
.setMaxResults(50)
.list();

你可以使用createCriteria()非常容易的在互相關聯的實體間建立 約束。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.createCriteria("kittens")
.add( Restrictions.like("name", "F%")
.list();

注意第二個 createCriteria()返回一個新的 Criteria實例，該實例引用kittens 集合中的元素。

接下來，替換形態在某些情況下也是很有用的。

List cats = sess.createCriteria(Cat.class)
.createAlias("kittens", "kt")
.createAlias("mate", "mt")
.add( Restrictions.eqProperty("kt.name", "mt.name") )
.list();

(createAlias()并不創建一個新的 Criteria實例。)

Cat實例所保存的之前兩次查詢所返回的kittens集合是 沒有被條件預過濾的。如果你希望只獲得符合條件的kittens， 你必須使用returnMaps()。

List cats = sess.createCriteria(Cat.class)
.createCriteria("kittens", "kt")
.add( Restrictions.eq("name", "F%") )
.returnMaps()
.list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
Map map = (Map) iter.next();
Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
Cat kitten = (Cat) map.get("kt");
}

你可以使用setFetchMode()在運行時定義動態關聯抓取的語義。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.setFetchMode("kittens", FetchMode.EAGER)
.list();

這個查詢可以通過外連接抓取mate和kittens。 查看第 20.1 節 “ 抓取策略(Fetching strategies) ”可以獲得更多信息。

org.hibernate.criterion.Example類允許你通過一個給定實例 構建一個條件查詢。

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();

版本屬性、標識符和關聯被忽略。默認情況下值為null的屬性將被排除。

你可以自行調整Example使之更實用。

Example example = Example.create(cat)
.excludeZeroes()           //exclude zero valued properties
.excludeProperty("color")  //exclude the property named "color"
.ignoreCase()              //perform case insensitive string comparisons
.enableLike();             //use like for string comparisons
List results = session.createCriteria(Cat.class)
.add(example)
.list();

你甚至可以使用examples在關聯對象上放置條件。

List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.createCriteria("mate")
.add( Example.create( cat.getMate() ) )
.list();

org.hibernate.criterion.Projections是 Projection 的實例工廠。我們通過調用 setProjection()應用投影到一個查詢。

List results = session.createCriteria(Cat.class)
.setProjection( Projections.rowCount() )
.add( Restrictions.eq("color", Color.BLACK) )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount() )
.add( Projections.avg("weight") )
.add( Projections.max("weight") )
.add( Projections.groupProperty("color") )
)
.list();

在一個條件查詢中沒有必要顯式的使用 "group by" 。某些投影類型就是被定義為 分組投影，他們也出現在SQL的group by子句中。

你可以選擇把一個別名指派給一個投影，這樣可以使投影值被約束或排序所引用。下面是兩種不同的實現方式：

List results = session.createCriteria(Cat.class)
.setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
.addOrder( Order.asc("colr") )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.groupProperty("color").as("colr") )
.addOrder( Order.asc("colr") )
.list();

alias()和as()方法簡便的將一個投影實例包裝到另外一個 別名的Projection實例中。簡而言之，當你添加一個投影到一個投影列表中時 你可以為它指定一個別名：

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount(), "catCountByColor" )
.add( Projections.avg("weight"), "avgWeight" )
.add( Projections.max("weight"), "maxWeight" )
.add( Projections.groupProperty("color"), "color" )
)
.addOrder( Order.desc("catCountByColor") )
.addOrder( Order.desc("avgWeight") )
.list();

List results = session.createCriteria(Domestic.class, "cat")
.createAlias("kittens", "kit")
.setProjection( Projections.projectionList()
.add( Projections.property("cat.name"), "catName" )
.add( Projections.property("kit.name"), "kitName" )
)
.addOrder( Order.asc("catName") )
.addOrder( Order.asc("kitName") )
.list();

你也可以使用Property.forName()來表示投影：

List results = session.createCriteria(Cat.class)
.setProjection( Property.forName("name") )
.add( Property.forName("color").eq(Color.BLACK) )
.list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount().as("catCountByColor") )
.add( Property.forName("weight").avg().as("avgWeight") )
.add( Property.forName("weight").max().as("maxWeight") )
.add( Property.forName("color").group().as("color" )
)
.addOrder( Order.desc("catCountByColor") )
.addOrder( Order.desc("avgWeight") )
.list();

DetachedCriteria類使你在一個session范圍之外創建一個查詢，并且可以使用任意的 Session來執行它。

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
.add( Property.forName("sex").eq('F') );
Session session = ....;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria也可以用以表示子查詢。條件實例包含子查詢可以通過 Subqueries或者Property獲得。

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
.add( Property.forName("weight).gt(avgWeight) )
.list();

DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
.add( Subqueries.geAll("weight", weights) )
.list();

甚至相互關聯的子查詢也是有可能的：

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
.setProjection( Property.forName("weight").avg() )
.add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
.add( Property.forName("weight).gt(avgWeightForSex) )
.list();

SQL查詢是通過SQLQuery接口來控制的，它是通過調用Session.createSQLQuery()方法來獲得

List cats = sess.createSQLQuery("select {cat.*} from cats cat")
.addEntity("cat", Cat.class);
.setMaxResults(50);
.list();

這個查詢指定了:

addEntity()方法將SQL表的別名和實體類聯系起來，并且確定查詢結果集的形態。

addJoin()方法可以被用于載入其他的實體和集合的關聯，TODO:examples!

原生的SQL查詢可能返回一個簡單的標量值或者一個標量和實體的結合體。

Double max = (Double) sess.createSQLQuery("select max(cat.weight) as maxWeight from cats cat")
.addScalar("maxWeight", Hibernate.DOUBLE);
.uniqueResult();

上面使用的{cat.*}標記是 "所有屬性" 的簡寫.你可以顯式地列出需要的字段,但是你必須讓Hibernate 為每一個屬性注入字段的別名.這些字段的站位符是以字段別名為前導,再加上屬性名.在下面的例子里,我們從一個其他的表(cat_log) 中獲取Cat對象,而非Cat對象原本在映射元數據中聲明的表.注意我們甚至在where子句中也可以使用屬性別名. 對于命名查詢,{}語法并不是必需的.你可以在第 17.3 節 “命名SQL查詢”得到更多的細節.

String sql = "select cat.originalId as {cat.id}, " +
"cat.mateid as {cat.mate}, cat.sex as {cat.sex}, " +
"cat.weight*10 as {cat.weight}, cat.name as {cat.name} " +
"from cat_log cat where {cat.mate} = :catId"
List loggedCats = sess.createSQLQuery(sql)
.addEntity("cat", Cat.class)
.setLong("catId", catId)
.list();

注意:如果你明確地列出了每個屬性,你必須包含這個類和它的子類的屬性! and its subclasses!

可以在映射文檔中定義查詢的名字,然后就可以象調用一個命名的HQL查詢一樣直接調用命名SQL查詢.在這種情況下,我們不 需要調用addEntity()方法.

<sql-query name="mySqlQuery">
<return alias="person" class="eg.Person"/>
SELECT person.NAME AS {person.name},
person.AGE AS {person.age},
person.SEX AS {person.sex}
FROM PERSON person WHERE person.NAME LIKE 'Hiber%'
</sql-query>

List people = sess.getNamedQuery("mySqlQuery")
.setMaxResults(50)
.list();

一個命名查詢可能會返回一個標量值.你必須使用<return-scalar>元素來指定字段的別名和 Hibernate類型

<sql-query name="mySqlQuery">
<return-scalar column="name" type="string"/>
<return-scalar column="age" type="long"/>
SELECT p.NAME AS name,
p.AGE AS age,
FROM PERSON p WHERE p.NAME LIKE 'Hiber%'
</sql-query>

<return-join>和<load-collection>元素分別用作 外連接和定義那些初始化集合的查詢

<sql-query name="mySqlQuery">
<return alias="person" class="eg.Person">
<return-property name="name" column="myName"/>
<return-property name="age" column="myAge"/>
<return-property name="sex" column="mySex"/>
</return>
SELECT person.NAME AS myName,
person.AGE AS myAge,
person.SEX AS mySex,
FROM PERSON person WHERE person.NAME LIKE :name
</sql-query>

<sql-query name="organizationCurrentEmployments">
<return alias="emp" class="Employment">
<return-property name="salary">
<return-column name="VALUE"/>
<return-column name="CURRENCY"/>
</return-property>
<return-property name="endDate" column="myEndDate"/>
</return>
SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},
STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},
REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY
FROM EMPLOYMENT
WHERE EMPLOYER = :id AND ENDDATE IS NULL
ORDER BY STARTDATE ASC
</sql-query>

CREATE OR REPLACE FUNCTION selectAllEmployments
RETURN SYS_REFCURSOR
AS
st_cursor SYS_REFCURSOR;
BEGIN
OPEN st_cursor FOR
SELECT EMPLOYEE, EMPLOYER,
STARTDATE, ENDDATE,
REGIONCODE, EID, VALUE, CURRENCY
FROM EMPLOYMENT;
RETURN  st_cursor;
END;

<sql-query name="selectAllEmployees_SP" callable="true">
<return alias="emp" class="Employment">
<return-property name="employee" column="EMPLOYEE"/>
<return-property name="employer" column="EMPLOYER"/>
<return-property name="startDate" column="STARTDATE"/>
<return-property name="endDate" column="ENDDATE"/>
<return-property name="regionCode" column="REGIONCODE"/>
<return-property name="id" column="EID"/>
<return-property name="salary">
<return-column name="VALUE"/>
<return-column name="CURRENCY"/>
</return-property>
</return>
{ ? = call selectAllEmployments() }
</sql-query>

Hibernate3能夠使用定制的SQL語句來執行create,update和delete操作。在Hibernate中，持久化的類和集合已經 包含了一套配置期產生的語句(insertsql, deletesql, updatesql等等)，這些映射標記 <sql-insert>, <sql-delete>, and <sql-update>重載了 這些語句。

<class name="Person">
<id name="id">
<generator class="increment"/>
</id>
<property name="name" not-null="true"/>
<sql-insert>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>
<sql-update>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>
<sql-delete>DELETE FROM PERSON WHERE ID=?</sql-delete>
</class>

這些SQL直接在你的數據庫里執行，所以你可以自由的使用你喜歡的任意語法。但如果你使用數據庫特定的語法， 這當然會降低你映射的可移植性。

如果設定callable，則能夠支持存儲過程了。

<class name="Person">
<id name="id">
<generator class="increment"/>
</id>
<property name="name" not-null="true"/>
<sql-insert callable="true">{call createPerson (?, ?)}</sql-insert>
<sql-delete callable="true">{? = call deletePerson (?)}</sql-delete>
<sql-update callable="true">{? = call updatePerson (?, ?)}</sql-update>
</class>

參數的位置順序是非常重要的，他們必須和Hibernate所期待的順序相同。

你能夠通過設定日志調試級別為org.hiberante.persister.entity,來查看Hibernate所期待的順序。在這個級別下， Hibernate將會打印出create,update和delete實體的靜態SQL。如果想看到預想中的順序。記得不要將定制SQL包含在映射文件里， 因為他們會重載Hibernate生成的靜態SQL。

在大多數情況下(最好這么做)，存儲過程需要返回插入/更新/刪除的行數，因為Hibernate對語句的成功執行有些運行時的檢查。 Hibernate常會把進行CUD操作的語句的第一個參數注冊為一個數值型輸出參數。

CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)
RETURN NUMBER IS
BEGIN
update PERSON
set
NAME = uname,
where
ID = uid;
return SQL%ROWCOUNT;
END updatePerson;

你可能需要聲明你自己的SQL(或HQL)來裝載實體

<sql-query name="person">
<return alias="p" class="Person" lock-mode="upgrade"/>
SELECT NAME AS {p.name}, ID AS {p.id} FROM PERSON WHERE ID=? FOR UPDATE
</sql-query>

這只是一個前面討論過的命名查詢聲明，你可以在類映射里引用這個命名查詢。

<class name="Person">
<id name="id">
<generator class="increment"/>
</id>
<property name="name" not-null="true"/>
<loader query-ref="person"/>
</class>

這也可以用于存儲過程

TODO: 未完成的例子

<sql-query name="organizationEmployments">
<load-collection alias="empcol" role="Organization.employments"/>
SELECT {empcol.*}
FROM EMPLOYMENT empcol
WHERE EMPLOYER = :id
ORDER BY STARTDATE ASC, EMPLOYEE ASC
</sql-query>
<sql-query name="organizationCurrentEmployments">
<return alias="emp" class="Employment"/>
<synchronize table="EMPLOYMENT"/>
SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},
STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},
REGIONCODE as {emp.regionCode}, ID AS {emp.id}
FROM EMPLOYMENT
WHERE EMPLOYER = :id AND ENDDATE IS NULL
ORDER BY STARTDATE ASC
</sql-query>

Hibernate3新增了對某個類或者集合使用預先定義的過濾器條件(filter criteria)的功能。過濾器條件相當于定義一個 非常類似于類和各種集合上的“where”屬性的約束子句，但是過濾器條件可以帶參數。 應用程序可以在運行時決定是否啟用給定的過濾器，以及使用什么樣的參數值。 過濾器的用法很像數據庫視圖，只不過是在應用程序中確定使用什么樣的參數的。

要使用過濾器，必須首先在相應的映射節點中定義。而定義一個過濾器，要用到位于<hibernate-mapping/> 節點之內的<filter-def/>節點：

<filter-def name="myFilter">
<filter-param name="myFilterParam" type="string"/>
</filter-def>

定義好之后，就可以在某個類中使用這個過濾器：

<class name="myClass" ...>
...
<filter name="myFilter" condition=":myFilterParam = MY_FILTERED_COLUMN"/>
</class>

也可以在某個集合使用它：

<set ...>
<filter name="myFilter" condition=":myFilterParam = MY_FILTERED_COLUMN"/>
</set>

可以在多個類或集合中使用某個過濾器；某個類或者集合中也可以使用多個過濾器。

Session對象中會用到的方法有：enableFilter(String filterName), getEnabledFilter(String filterName), 和 disableFilter(String filterName). Session中默認是不啟用過濾器的，必須通過Session.enabledFilter()方法顯式的啟用。 該方法返回被啟用的Filter的實例。以上文定義的過濾器為例：

session.enableFilter("myFilter").setParameter("myFilterParam", "some-value");

注意，org.hibernate.Filter的方法允許鏈式方法調用。（類似上面例子中啟用Filter之后設定Filter參數這個“方法鏈”） Hibernate的其他部分也大多有這個特性。

下面是一個比較完整的例子，使用了記錄生效日期模式過濾有時效的數據：

<filter-def name="effectiveDate">
<filter-param name="asOfDate" type="date"/>
</filter-def>
<class name="Employee" ...>
...
<many-to-one name="department" column="dept_id" class="Department"/>
<property name="effectiveStartDate" type="date" column="eff_start_dt"/>
<property name="effectiveEndDate" type="date" column="eff_end_dt"/>
...
<!--
Note that this assumes non-terminal records have an eff_end_dt set to
a max db date for simplicity-sake
注意，為了簡單起見，此處假設雇用關系生效期尚未結束的記錄的eff_end_dt字段的值等于數據庫最大的日期
-->
<filter name="effectiveDate"
condition=":asOfDate BETWEEN eff_start_dt and eff_end_dt"/>
</class>
<class name="Department" ...>
...
<set name="employees" lazy="true">
<key column="dept_id"/>
<one-to-many class="Employee"/>
<filter name="effectiveDate"
condition=":asOfDate BETWEEN eff_start_dt and eff_end_dt"/>
</set>
</class>

定義好后，如果想要保證取回的都是目前處于生效期的記錄，只需在獲取雇員數據的操作之前先開啟過濾器即可：

Session session = ...;
session.enabledFilter("effectiveDate").setParameter("asOfDate", new Date());
List results = session.createQuery("from Employee as e where e.salary > :targetSalary")
.setLong("targetSalary", new Long(1000000))
.list();

在上面的HQL中，雖然我們僅僅顯式的使用了一個薪水條件，但因為啟用了過濾器，查詢將僅返回那些目前雇用 關系處于生效期的，并且薪水高于一百萬美刀的雇員的數據。

注意：如果你打算在使用外連接（或者通過HQL或load fetching）的同時使用過濾器，要注意條件表達式的方向（左還是右）。 最安全的方式是使用左外連接（left outer joining）。并且通常來說，先寫參數， 然后是操作符，最后寫數據庫字段名。