轉(zhuǎn)自http://blog.csdn.net/ctgyp/archive/2007/12/18/1946626.aspx
第 14 章 批量處理（Batch processing）
使用Hibernate將 100 000 條記錄插入到數(shù)據(jù)庫(kù)的一個(gè)很自然的做法可能是這樣的
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
for ( int i=0; i<100000; i++ ) {
Customer customer = new Customer(.....);
session.save(customer);
}
tx.commit();
session.close();這段程序大概運(yùn)行到 50 000 條記錄左右會(huì)失敗并拋出 內(nèi)存溢出異常（OutOfMemoryException） 。 這是因?yàn)?Hibernate 把所有新插入的 客戶（Customer）實(shí)例在 session級(jí)別的緩存區(qū)進(jìn)行了緩存的緣故。
我們會(huì)在本章告訴你如何避免此類問(wèn)題。首先，如果你要執(zhí)行批量處理并且想要達(dá)到一個(gè)理想的性能， 那么使用JDBC的批量（batching）功能是至關(guān)重要。將JDBC的批量抓取數(shù)量（batch size）參數(shù)設(shè)置到一個(gè)合適值 （比如，10-50之間）：
hibernate.jdbc.batch_size 20你也可能想在執(zhí)行批量處理時(shí)關(guān)閉二級(jí)緩存：
hibernate.cache.use_second_level_cache false14.1. 批量插入（Batch inserts）
如果要將很多對(duì)象持久化，你必須通過(guò)經(jīng)常的調(diào)用 flush() 以及稍后調(diào)用 clear() 來(lái)控制第一級(jí)緩存的大小。
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
for ( int i=0; i<100000; i++ ) {
Customer customer = new Customer(.....);
session.save(customer);
if ( i % 20 == 0 ) { //20, same as the JDBC batch size //20,與JDBC批量設(shè)置相同
//flush a batch of inserts and release memory:
//將本批插入的對(duì)象立即寫入數(shù)據(jù)庫(kù)并釋放內(nèi)存
session.flush();
session.clear();
}
}
tx.commit();
session.close();14.2. 批量更新（Batch updates）
此方法同樣適用于檢索和更新數(shù)據(jù)。此外，在進(jìn)行會(huì)返回很多行數(shù)據(jù)的查詢時(shí)， 你需要使用 scroll() 方法以便充分利用服務(wù)器端游標(biāo)所帶來(lái)的好處。
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
ScrollableResults customers = session.getNamedQuery("GetCustomers")
.setCacheMode(CacheMode.IGNORE)
.scroll(ScrollMode.FORWARD_ONLY);
int count=0;
while ( customers.next() ) {
Customer customer = (Customer) customers.get(0);
customer.updateStuff(...);
if ( ++count % 20 == 0 ) {
//flush a batch of updates and release memory:
session.flush();
session.clear();
}
}
tx.commit();
session.close();14.3. 大批量更新/刪除（Bulk update/delete）
就像已經(jīng)討論的那樣，自動(dòng)和透明的 對(duì)象/關(guān)系 映射（object/relational mapping）關(guān)注于管理對(duì)象的狀態(tài)。 這就意味著對(duì)象的狀態(tài)存在于內(nèi)存，因此直接更新或者刪除 (使用 SQL 語(yǔ)句 UPDATE 和 DELETE) 數(shù)據(jù)庫(kù)中的數(shù)據(jù)將不會(huì)影響內(nèi)存中的對(duì)象狀態(tài)和對(duì)象數(shù)據(jù)。 不過(guò)，Hibernate提供通過(guò)Hibernate查詢語(yǔ)言（第 15 章 HQL: Hibernate查詢語(yǔ)言）來(lái)執(zhí)行大批 量SQL風(fēng)格的（UPDATE）和（DELETE） 語(yǔ)句的方法。
UPDATE 和 DELETE語(yǔ)句的語(yǔ)法為： ( UPDATE | DELETE ) FROM? ClassName (WHERE WHERE_CONDITIONS)?。 有幾點(diǎn)說(shuō)明：
在FROM子句（from-clause）中，F(xiàn)ROM關(guān)鍵字是可選的
在FROM子句（from-clause）中只能有一個(gè)類名，并且它不能有別名
不能在大批量HQL語(yǔ)句中使用連接（顯式或者隱式的都不行）。不過(guò)在WHERE子句中可以使用子查詢。
整個(gè)WHERE子句是可選的。
舉個(gè)例子，使用Query.executeUpdate()方法執(zhí)行一個(gè)HQL UPDATE語(yǔ)句：
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlUpdate = "update Customer set name = :newName where name = :oldName";
int updatedEntities = s.createQuery( hqlUpdate )
.setString( "newName", newName )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();執(zhí)行一個(gè)HQL DELETE，同樣使用 Query.executeUpdate() 方法 （此方法是為 那些熟悉JDBC PreparedStatement.executeUpdate() 的人們而設(shè)定的）
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlDelete = "delete Customer where name = :oldName";
int deletedEntities = s.createQuery( hqlDelete )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();由Query.executeUpdate()方法返回的整型值表明了受此操作影響的記錄數(shù)量。 注意這個(gè)數(shù)值可能與數(shù)據(jù)庫(kù)中被（最后一條SQL語(yǔ)句）影響了的“行”數(shù)有關(guān)，也可能沒(méi)有。一個(gè)大批量HQL操作可能導(dǎo)致多條實(shí)際的SQL語(yǔ)句被執(zhí)行， 舉個(gè)例子，對(duì)joined-subclass映射方式的類進(jìn)行的此類操作。這個(gè)返回值代表了實(shí)際被語(yǔ)句影響了的記錄數(shù)量。在那個(gè)joined-subclass的例子中， 對(duì)一個(gè)子類的刪除實(shí)際上可能不僅僅會(huì)刪除子類映射到的表而且會(huì)影響“根”表，還有可能影響與之有繼承關(guān)系的joined-subclass映射方式的子類的表。
注意，上述大批量HQL操作的少數(shù)限制會(huì)在新版本中得到改進(jìn)；進(jìn)一步詳細(xì)信息請(qǐng)參考JIRA里的路線圖(roadmap)。
第 15 章 HQL: Hibernate查詢語(yǔ)言
Hibernate配備了一種非常強(qiáng)大的查詢語(yǔ)言，這種語(yǔ)言看上去很像SQL。但是不要被語(yǔ)法結(jié)構(gòu) 上的相似所迷惑，HQL是非常有意識(shí)的被設(shè)計(jì)為完全面向?qū)ο蟮牟樵儯梢岳斫馊缋^承、多態(tài) 和關(guān)聯(lián)之類的概念。
15.1. 大小寫敏感性問(wèn)題
除了Java類與屬性的名稱外，查詢語(yǔ)句對(duì)大小寫并不敏感。 所以 SeLeCT 與 sELEct 以及 SELECT 是相同的，但是 org.hibernate.eg.FOO 并不等價(jià)于 org.hibernate.eg.Foo 并且 foo.barSet 也不等價(jià)于 foo.BARSET。
本手冊(cè)中的HQL關(guān)鍵字將使用小寫字母. 很多用戶發(fā)現(xiàn)使用完全大寫的關(guān)鍵字會(huì)使查詢語(yǔ)句 的可讀性更強(qiáng), 但我們發(fā)現(xiàn)，當(dāng)把查詢語(yǔ)句嵌入到Java語(yǔ)句中的時(shí)候使用大寫關(guān)鍵字比較難看。
15.2. from子句
Hibernate中最簡(jiǎn)單的查詢語(yǔ)句的形式如下：
from eg.Cat該子句簡(jiǎn)單的返回eg.Cat類的所有實(shí)例。 通常我們不需要使用類的全限定名, 因?yàn)?auto-import（自動(dòng)引入） 是缺省的情況。 所以我們幾乎只使用如下的簡(jiǎn)單寫法：
from Cat大多數(shù)情況下, 你需要指定一個(gè)別名, 原因是你可能需要 在查詢語(yǔ)句的其它部分引用到Cat
from Cat as cat這個(gè)語(yǔ)句把別名cat指定給類Cat 的實(shí)例, 這樣我們就可以在隨后的查詢中使用此別名了。 關(guān)鍵字as 是可選的，我們也可以這樣寫:
from Cat cat子句中可以同時(shí)出現(xiàn)多個(gè)類, 其查詢結(jié)果是產(chǎn)生一個(gè)笛卡兒積或產(chǎn)生跨表的連接。
from Formula, Parameterfrom Formula as form, Parameter as param查詢語(yǔ)句中別名的開(kāi)頭部分小寫被認(rèn)為是實(shí)踐中的好習(xí)慣， 這樣做與Java變量的命名標(biāo)準(zhǔn)保持了一致 (比如，domesticCat)。
15.3. 關(guān)聯(lián)(Association)與連接(Join)
我們也可以為相關(guān)聯(lián)的實(shí)體甚至是對(duì)一個(gè)集合中的全部元素指定一個(gè)別名, 這時(shí)要使用關(guān)鍵字join。
from Cat as cat
inner join cat.mate as mate
left outer join cat.kittens as kittenfrom Cat as cat left join cat.mate.kittens as kittensfrom Formula form full join form.parameter param受支持的連接類型是從ANSI SQL中借鑒來(lái)的。
inner join（內(nèi)連接）
left outer join（左外連接）
right outer join（右外連接）
full join (全連接，并不常用)
語(yǔ)句inner join, left outer join 以及 right outer join 可以簡(jiǎn)寫。
from Cat as cat
join cat.mate as mate
left join cat.kittens as kitten還有，一個(gè)"fetch"連接允許僅僅使用一個(gè)選擇語(yǔ)句就將相關(guān)聯(lián)的對(duì)象或一組值的集合隨著他們的父對(duì)象的初始化而被初始化，這種方法在使用到集合的情況下尤其有用，對(duì)于關(guān)聯(lián)和集合來(lái)說(shuō)，它有效的代替了映射文件中的外聯(lián)接 與延遲聲明（lazy declarations）. 查看 第 20.1 節(jié) “ 抓取策略(Fetching strategies) ” 以獲得等多的信息。
from Cat as cat
inner join fetch cat.mate
left join fetch cat.kittens一個(gè)fetch連接通常不需要被指定別名, 因?yàn)橄嚓P(guān)聯(lián)的對(duì)象不應(yīng)當(dāng)被用在 where 子句 (或其它任何子句)中。同時(shí)，相關(guān)聯(lián)的對(duì)象 并不在查詢的結(jié)果中直接返回，但可以通過(guò)他們的父對(duì)象來(lái)訪問(wèn)到他們。
注意fetch構(gòu)造變量在使用了scroll() 或 iterate()函數(shù) 的查詢中是不能使用的。最后注意，使用full join fetch 與 right join fetch是沒(méi)有意義的。
如果你使用屬性級(jí)別的延遲獲取（lazy fetching）（這是通過(guò)重新編寫字節(jié)碼實(shí)現(xiàn)的），可以使用 fetch all properties 來(lái)強(qiáng)制Hibernate立即取得那些原本需要延遲加載的屬性（在第一個(gè)查詢中）。
from Document fetch all properties order by namefrom Document doc fetch all properties where lower(doc.name) like '%cats%'15.4. select子句
select 子句選擇將哪些對(duì)象與屬性返 回到查詢結(jié)果集中. 考慮如下情況:
select mate
from Cat as cat
inner join cat.mate as mate該語(yǔ)句將選擇mates of other Cats。（其他貓的配偶） 實(shí)際上, 你可以更簡(jiǎn)潔的用以下的查詢語(yǔ)句表達(dá)相同的含義:
select cat.mate from Cat cat查詢語(yǔ)句可以返回值為任何類型的屬性，包括返回類型為某種組件(Component)的屬性:
select cat.name from DomesticCat cat
where cat.name like 'fri%'select cust.name.firstName from Customer as cust查詢語(yǔ)句可以返回多個(gè)對(duì)象和（或）屬性，存放在 Object[]隊(duì)列中,
select mother, offspr, mate.name
from DomesticCat as mother
inner join mother.mate as mate
left outer join mother.kittens as offspr或存放在一個(gè)List對(duì)象中,
select new list(mother, offspr, mate.name)
from DomesticCat as mother
inner join mother.mate as mate
left outer join mother.kittens as offspr也可能直接返回一個(gè)實(shí)際的類型安全的Java對(duì)象,
select new Family(mother, mate, offspr)
from DomesticCat as mother
join mother.mate as mate
left join mother.kittens as offspr假設(shè)類Family有一個(gè)合適的構(gòu)造函數(shù).
你可以使用關(guān)鍵字as給“被選擇了的表達(dá)式”指派別名:
select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
from Cat cat這種做法在與子句select new map一起使用時(shí)最有用:
select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
from Cat cat該查詢返回了一個(gè)Map的對(duì)象，內(nèi)容是別名與被選擇的值組成的名-值映射。
15.5. 聚集函數(shù)
HQL查詢甚至可以返回作用于屬性之上的聚集函數(shù)的計(jì)算結(jié)果:
select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
from Cat cat受支持的聚集函數(shù)如下：
avg(...), sum(...), min(...), max(...)
count(*)
count(...), count(distinct ...), count(all...)
你可以在選擇子句中使用數(shù)學(xué)操作符、連接以及經(jīng)過(guò)驗(yàn)證的SQL函數(shù)：
select cat.weight + sum(kitten.weight)
from Cat cat
join cat.kittens kitten
group by cat.id, cat.weightselect firstName||' '||initial||' '||upper(lastName) from Person關(guān)鍵字distinct與all 也可以使用，它們具有與SQL相同的語(yǔ)義.
select distinct cat.name from Cat cat
select count(distinct cat.name), count(cat) from Cat cat15.6. 多態(tài)查詢
一個(gè)如下的查詢語(yǔ)句:
from Cat as cat不僅返回Cat類的實(shí)例, 也同時(shí)返回子類 DomesticCat的實(shí)例. Hibernate 可以在from子句中指定任何 Java 類或接口. 查詢會(huì)返回繼承了該類的所有持久化子類 的實(shí)例或返回聲明了該接口的所有持久化類的實(shí)例。下面的查詢語(yǔ)句返回所有的被持久化的對(duì)象：
from java.lang.Object o接口Named 可能被各種各樣的持久化類聲明：
from Named n, Named m where n.name = m.name注意，最后的兩個(gè)查詢將需要超過(guò)一個(gè)的SQL SELECT.這表明order by子句 沒(méi)有對(duì)整個(gè)結(jié)果集進(jìn)行正確的排序. (這也說(shuō)明你不能對(duì)這樣的查詢使用Query.scroll()方法.)
15.7. where子句
where子句允許你將返回的實(shí)例列表的范圍縮小. 如果沒(méi)有指定別名，你可以使用屬性名來(lái)直接引用屬性:
from Cat where name='Fritz'如果指派了別名，需要使用完整的屬性名:
from Cat as cat where cat.name='Fritz'返回名為（屬性name等于）'Fritz'的Cat類的實(shí)例。
select foo
from Foo foo, Bar bar
where foo.startDate = bar.date將返回所有滿足下面條件的Foo類的實(shí)例： 存在如下的bar的一個(gè)實(shí)例，其date屬性等于 Foo的startDate屬性。 復(fù)合路徑表達(dá)式使得where子句非常的強(qiáng)大，考慮如下情況：
from Cat cat where cat.mate.name is not null該查詢將被翻譯成為一個(gè)含有表連接（內(nèi)連接）的SQL查詢。如果你打算寫像這樣的查詢語(yǔ)句
from Foo foo
where foo.bar.baz.customer.address.city is not null在SQL中，你為達(dá)此目的將需要進(jìn)行一個(gè)四表連接的查詢。
=運(yùn)算符不僅可以被用來(lái)比較屬性的值，也可以用來(lái)比較實(shí)例：
from Cat cat, Cat rival where cat.mate = rival.mateselect cat, mate
from Cat cat, Cat mate
where cat.mate = mate特殊屬性（小寫）id可以用來(lái)表示一個(gè)對(duì)象的唯一的標(biāo)識(shí)符。（你也可以使用該對(duì)象的屬性名。）
from Cat as cat where cat.id = 123
from Cat as cat where cat.mate.id = 69第二個(gè)查詢是有效的。此時(shí)不需要進(jìn)行表連接！
同樣也可以使用復(fù)合標(biāo)識(shí)符。比如Person類有一個(gè)復(fù)合標(biāo)識(shí)符，它由country屬性 與medicareNumber屬性組成。
from bank.Person person
where person.id.country = 'AU'
and person.id.medicareNumber = 123456from bank.Account account
where account.owner.id.country = 'AU'
and account.owner.id.medicareNumber = 123456第二個(gè)查詢也不需要進(jìn)行表連接。
同樣的，特殊屬性class在進(jìn)行多態(tài)持久化的情況下被用來(lái)存取一個(gè)實(shí)例的鑒別值（discriminator value）。 一個(gè)嵌入到where子句中的Java類的名字將被轉(zhuǎn)換為該類的鑒別值。
from Cat cat where cat.class = DomesticCat你也可以聲明一個(gè)屬性的類型是組件或者復(fù)合用戶類型（以及由組件構(gòu)成的組件等等）。永遠(yuǎn)不要嘗試使用以組件類型來(lái)結(jié)尾的路徑表達(dá)式（path-expression） （與此相反，你應(yīng)當(dāng)使用組件的一個(gè)屬性來(lái)結(jié)尾）。 舉例來(lái)說(shuō)，如果store.owner含有一個(gè)包含了組件的實(shí)體address
store.owner.address.city // 正確
store.owner.address // 錯(cuò)誤!一個(gè)“任意”類型有兩個(gè)特殊的屬性id和class, 來(lái)允許我們按照下面的方式表達(dá)一個(gè)連接（AuditLog.item 是一個(gè)屬性，該屬性被映射為<any>）。
from AuditLog log, Payment payment
where log.item.class = 'Payment' and log.item.id = payment.id注意，在上面的查詢與句中，log.item.class 和 payment.class 將涉及到完全不同的數(shù)據(jù)庫(kù)中的列。
15.8. 表達(dá)式
在where子句中允許使用的表達(dá)式包括 大多數(shù)你可以在SQL使用的表達(dá)式種類:
數(shù)學(xué)運(yùn)算符+, -, *, /
二進(jìn)制比較運(yùn)算符=, >=, <=, <>, !=, like
邏輯運(yùn)算符and, or, not
in, not in, between, is null, is not null, is empty, is not empty, member of and not member of
"簡(jiǎn)單的" 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定義的任何函數(shù)或操作：substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length()
coalesce() 和 nullif()
cast(... as ...), 其第二個(gè)參數(shù)是某Hibernate類型的名字，以及extract(... from ...)，只要ANSI cast() 和 extract() 被底層數(shù)據(jù)庫(kù)支持
任何數(shù)據(jù)庫(kù)支持的SQL標(biāo)量函數(shù)，比如sign(), trunc(), rtrim(), sin()
JDBC參數(shù)傳入 ?
命名參數(shù):name, :start_date, :x1
SQL 直接常量 'foo', 69, '1970-01-01 10:00:01.0'
Java public static final 類型的常量 eg.Color.TABBY
關(guān)鍵字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可以被用來(lái)測(cè)試空值(null).
在Hibernate配置文件中聲明HQL“查詢替代（query substitutions）”之后， 布爾表達(dá)式（Booleans）可以在其他表達(dá)式中輕松的使用:
<property name="hibernate.query.substitutions">true 1, false 0</property>系統(tǒng)將該HQL轉(zhuǎn)換為SQL語(yǔ)句時(shí)，該設(shè)置表明將用字符 1 和 0 來(lái) 取代關(guān)鍵字true 和 false:
from Cat cat where cat.alive = true你可以用特殊屬性size, 或是特殊函數(shù)size()測(cè)試一個(gè)集合的大小。
from Cat cat where cat.kittens.size > 0from Cat cat where size(cat.kittens) > 0對(duì)于索引了（有序）的集合，你可以使用minindex 與 maxindex函數(shù)來(lái)引用到最小與最大的索引序數(shù)。 同理，你可以使用minelement 與 maxelement函數(shù)來(lái) 引用到一個(gè)基本數(shù)據(jù)類型的集合中最小與最大的元素。
from Calendar cal where maxelement(cal.holidays) > current datefrom Order order where maxindex(order.items) > 100from Order order where minelement(order.items) > 10000在傳遞一個(gè)集合的索引集或者是元素集(elements與indices 函數(shù)) 或者傳遞一個(gè)子查詢的結(jié)果的時(shí)候，可以使用SQL函數(shù)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種，這些結(jié)構(gòu)變量- size, elements, indices, minindex, maxindex, minelement, maxelement - 只能在where子句中使用。
一個(gè)被索引過(guò)的（有序的）集合的元素(arrays, lists, maps)可以在其他索引中被引用（只能在where子句中）：
from Order order where order.items[0].id = 1234select person from Person person, Calendar calendar
where calendar.holidays['national day'] = person.birthDay
and person.nationality.calendar = calendarselect item from Item item, Order order
where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11select item from Item item, Order order
where order.items[ maxindex(order.items) ] = item and order.id = 11在[]中的表達(dá)式甚至可以是一個(gè)算數(shù)表達(dá)式。
select item from Item item, Order order
where order.items[ size(order.items) - 1 ] = item對(duì)于一個(gè)一對(duì)多的關(guān)聯(lián)（one-to-many association）或是值的集合中的元素， HQL也提供內(nèi)建的index()函數(shù)，
select item, index(item) from Order order
join order.items item
where index(item) < 5如果底層數(shù)據(jù)庫(kù)支持標(biāo)量的SQL函數(shù)，它們也可以被使用
from DomesticCat cat where upper(cat.name) like 'FRI%'如果你還不能對(duì)所有的這些深信不疑，想想下面的查詢。如果使用SQL，語(yǔ)句長(zhǎng)度會(huì)增長(zhǎng)多少，可讀性會(huì)下降多少：
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)提示: 會(huì)像如下的語(yǔ)句
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)可以按照一個(gè)返回的類或組件（components)中的任何屬性（property）進(jìn)行排序：
from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate可選的asc或desc關(guān)鍵字指明了按照升序或降序進(jìn)行排序.
15.10. group by子句
一個(gè)返回聚集值(aggregate values)的查詢可以按照一個(gè)返回的類或組件（components)中的任何屬性（property）進(jìn)行分組：
select cat.color, sum(cat.weight), count(cat)
from Cat cat
group by cat.colorselect foo.id, avg(name), max(name)
from Foo foo join foo.names name
group by foo.idhaving子句在這里也允許使用.
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)如果底層的數(shù)據(jù)庫(kù)支持的話(例如不能在MySQL中使用)，SQL的一般函數(shù)與聚集函數(shù)也可以出現(xiàn) 在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子句中都不能包含算術(shù)表達(dá)式（arithmetic expressions）.
15.11. 子查詢
對(duì)于支持子查詢的數(shù)據(jù)庫(kù)，Hibernate支持在查詢中使用子查詢。一個(gè)子查詢必須被圓括號(hào)包圍起來(lái)（經(jīng)常是SQL聚集函數(shù)的圓括號(hào)）。 甚至相互關(guān)聯(lián)的子查詢（引用到外部查詢中的別名的子查詢）也是允許的。
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列表中包含一個(gè)表達(dá)式以上的子查詢，你可以使用一個(gè)元組構(gòu)造符（tuple constructors）：
from Cat as cat
where not ( cat.name, cat.color ) in (
select cat.name, cat.color from DomesticCat cat
)注意在某些數(shù)據(jù)庫(kù)中（不包括Oracle與HSQL），你也可以在其他語(yǔ)境中使用元組構(gòu)造符， 比如查詢用戶類型的組件與組合：
from Person where name = ('Gavin', 'A', 'King')該查詢等價(jià)于更復(fù)雜的：
from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')有兩個(gè)很好的理由使你不應(yīng)當(dāng)作這樣的事情：首先，它不完全適用于各個(gè)數(shù)據(jù)庫(kù)平臺(tái)；其次，查詢現(xiàn)在依賴于映射文件中屬性的順序。
15.12. HQL示例
Hibernate查詢可以非常的強(qiáng)大與復(fù)雜。實(shí)際上，Hibernate的一個(gè)主要賣點(diǎn)就是查詢語(yǔ)句的威力。這里有一些例子，它們與我在最近的 一個(gè)項(xiàng)目中使用的查詢非常相似。注意你能用到的大多數(shù)查詢比這些要簡(jiǎn)單的多！
下面的查詢對(duì)于某個(gè)特定的客戶的所有未支付的賬單，在給定給最小總價(jià)值的情況下，返回訂單的id，條目的數(shù)量和總價(jià)值， 返回值按照總價(jià)值的結(jié)果進(jìn)行排序。為了決定價(jià)格，查詢使用了當(dāng)前目錄。作為轉(zhuǎn)換結(jié)果的SQL查詢，使用了ORDER, ORDER_LINE, PRODUCT, CATALOG 和PRICE 庫(kù)表。
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這簡(jiǎn)直是一個(gè)怪物！實(shí)際上，在現(xiàn)實(shí)生活中，我并不熱衷于子查詢，所以我的查詢語(yǔ)句看起來(lái)更像這個(gè)：
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下面一個(gè)查詢計(jì)算每一種狀態(tài)下的支付的數(shù)目，除去所有處于AWAITING_APPROVAL狀態(tài)的支付，因?yàn)樵谠摖顟B(tài)下 當(dāng)前的用戶作出了狀態(tài)的最新改變。該查詢被轉(zhuǎn)換成含有兩個(gè)內(nèi)連接以及一個(gè)相關(guān)聯(lián)的子選擇的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實(shí)例集映射為一個(gè)列表（list）而不是一個(gè)集合（set）, 書寫查詢語(yǔ)句將更加簡(jiǎn)單.
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下面一個(gè)查詢使用了MS SQL Server的 isNull()函數(shù)用以返回當(dāng)前用戶所屬組織的組織帳號(hào)及組織未支付的賬。 它被轉(zhuǎn)換成一個(gè)對(duì)表ACCOUNT, PAYMENT, PAYMENT_STATUS, ACCOUNT_TYPE, ORGANIZATION 以及 ORG_USER進(jìn)行的三個(gè)內(nèi)連接， 一個(gè)外連接和一個(gè)子選擇的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對(duì)于一些數(shù)據(jù)庫(kù)，我們需要棄用（相關(guān)的）子選擇。
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.dueDate15.13. 批量的UPDATE & DELETE語(yǔ)句
HQL現(xiàn)在支持UPDATE與DELETE語(yǔ)句. 查閱 第 14.3 節(jié) “大批量更新/刪除（Bulk update/delete）” 以獲得更多信息。
15.14. 小技巧 & 小竅門
你可以統(tǒng)計(jì)查詢結(jié)果的數(shù)目而不必實(shí)際的返回他們：
( (Integer) session.iterate("select count(*) from ....").next() ).intValue()若想根據(jù)一個(gè)集合的大小來(lái)進(jìn)行排序，可以使用如下的語(yǔ)句：
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)如果你的數(shù)據(jù)庫(kù)支持子選擇，你可以在你的查詢的where子句中為選擇的大小（selection size）指定一個(gè)條件:
from User usr where size(usr.messages) >= 1如果你的數(shù)據(jù)庫(kù)不支持子選擇語(yǔ)句，使用下面的查詢：
select usr.id, usr.name
from User usr.name
join usr.messages msg
group by usr.id, usr.name
having count(msg) >= 1因?yàn)閮?nèi)連接（inner join）的原因，這個(gè)解決方案不能返回含有零個(gè)信息的User 類的實(shí)例, 所以這種情況下使用下面的格式將是有幫助的:
select usr.id, usr.name
from User as usr
left join usr.messages as msg
group by usr.id, usr.name
having count(msg) = 0JavaBean的屬性可以被綁定到一個(gè)命名查詢（named query）的參數(shù)上：
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();通過(guò)將接口Query與一個(gè)過(guò)濾器（filter）一起使用，集合（Collections）是可以分頁(yè)的：
Query q = s.createFilter( collection, "" ); // 一個(gè)簡(jiǎn)單的過(guò)濾器
q.setMaxResults(PAGE_SIZE);
q.setFirstResult(PAGE_SIZE * pageNumber);
List page = q.list();通過(guò)使用查詢過(guò)濾器（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" );不用通過(guò)初始化，你就可以知道一個(gè)集合（Collection）的大小：
( (Integer) session.iterate("select count(*) from ....").next() ).intValue();第 16 章 條件查詢(Criteria Queries)
具有一個(gè)直觀的、可擴(kuò)展的條件查詢API是Hibernate的特色。
16.1. 創(chuàng)建一個(gè)Criteria 實(shí)例
org.hibernate.Criteria接口表示特定持久類的一個(gè)查詢。Session是 Criteria實(shí)例的工廠。
Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();16.2. 限制結(jié)果集內(nèi)容
一個(gè)單獨(dú)的查詢條件是org.hibernate.criterion.Criterion 接口的一個(gè)實(shí)例。org.hibernate.criterion.Restrictions類 定義了獲得某些內(nèi)置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提供了相當(dāng)多的內(nèi)置criterion類型(Restrictions 子類), 但是尤其有用的是可以允許你直接使用SQL。
List cats = sess.createCriteria(Cat.class)
.add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%", Hibernate.STRING) )
.list();{alias}占位符應(yīng)當(dāng)被替換為被查詢實(shí)體的列別名。
Property實(shí)例是獲得一個(gè)條件的另外一種途徑。你可以通過(guò)調(diào)用Property.forName() 創(chuàng)建一個(gè)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();16.3. 結(jié)果集排序
你可以使用org.hibernate.criterion.Order來(lái)為查詢結(jié)果排序。
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();16.4. 關(guān)聯(lián)
你可以使用createCriteria()非常容易的在互相關(guān)聯(lián)的實(shí)體間建立 約束。
List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.createCriteria("kittens")
.add( Restrictions.like("name", "F%")
.list();注意第二個(gè) createCriteria()返回一個(gè)新的 Criteria實(shí)例，該實(shí)例引用kittens 集合中的元素。
接下來(lái)，替換形態(tài)在某些情況下也是很有用的。
List cats = sess.createCriteria(Cat.class)
.createAlias("kittens", "kt")
.createAlias("mate", "mt")
.add( Restrictions.eqProperty("kt.name", "mt.name") )
.list();(createAlias()并不創(chuàng)建一個(gè)新的 Criteria實(shí)例。)
Cat實(shí)例所保存的之前兩次查詢所返回的kittens集合是 沒(méi)有被條件預(yù)過(guò)濾的。如果你希望只獲得符合條件的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");
}16.5. 動(dòng)態(tài)關(guān)聯(lián)抓取
你可以使用setFetchMode()在運(yùn)行時(shí)定義動(dòng)態(tài)關(guān)聯(lián)抓取的語(yǔ)義。
List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.setFetchMode("kittens", FetchMode.EAGER)
.list();這個(gè)查詢可以通過(guò)外連接抓取mate和kittens。 查看第 20.1 節(jié) “ 抓取策略(Fetching strategies) ”可以獲得更多信息。
16.6. 查詢示例
org.hibernate.criterion.Example類允許你通過(guò)一個(gè)給定實(shí)例 構(gòu)建一個(gè)條件查詢。
Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.list();版本屬性、標(biāo)識(shí)符和關(guān)聯(lián)被忽略。默認(rèn)情況下值為null的屬性將被排除。
你可以自行調(diào)整Example使之更實(shí)用。
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在關(guān)聯(lián)對(duì)象上放置條件。
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.createCriteria("mate")
.add( Example.create( cat.getMate() ) )
.list();16.7. 投影(Projections)、聚合（aggregation）和分組（grouping）
org.hibernate.criterion.Projections是 Projection 的實(shí)例工廠。我們通過(guò)調(diào)用 setProjection()應(yīng)用投影到一個(gè)查詢。
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();在一個(gè)條件查詢中沒(méi)有必要顯式的使用 "group by" 。某些投影類型就是被定義為 分組投影，他們也出現(xiàn)在SQL的group by子句中。
你可以選擇把一個(gè)別名指派給一個(gè)投影，這樣可以使投影值被約束或排序所引用。下面是兩種不同的實(shí)現(xiàn)方式：
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()方法簡(jiǎn)便的將一個(gè)投影實(shí)例包裝到另外一個(gè) 別名的Projection實(shí)例中。簡(jiǎn)而言之，當(dāng)你添加一個(gè)投影到一個(gè)投影列表中時(shí) 你可以為它指定一個(gè)別名：
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()來(lái)表示投影：
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();16.8. 離線(detached)查詢和子查詢
DetachedCriteria類使你在一個(gè)session范圍之外創(chuàng)建一個(gè)查詢，并且可以使用任意的 Session來(lái)執(zhí)行它。
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也可以用以表示子查詢。條件實(shí)例包含子查詢可以通過(guò) 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();甚至相互關(guān)聯(lián)的子查詢也是有可能的：
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();第 17 章 Native SQL查詢
你也可以使用你的數(shù)據(jù)庫(kù)的Native SQL語(yǔ)言來(lái)查詢數(shù)據(jù)。這對(duì)你在要使用數(shù)據(jù)庫(kù)的某些特性的時(shí)候(比如說(shuō)在查詢提示或者Oracle中的 CONNECT關(guān)鍵字)，這是非常有用的。這就能夠掃清你把原來(lái)直接使用SQL/JDBC 的程序遷移到基于 Hibernate應(yīng)用的道路上的障礙。
Hibernate3允許你使用手寫的sql來(lái)完成所有的create,update,delete,和load操作（包括存儲(chǔ)過(guò)程）
17.1. 創(chuàng)建一個(gè)基于SQL的Query
SQL查詢是通過(guò)SQLQuery接口來(lái)控制的，它是通過(guò)調(diào)用Session.createSQLQuery()方法來(lái)獲得
List cats = sess.createSQLQuery("select {cat.*} from cats cat")
.addEntity("cat", Cat.class);
.setMaxResults(50);
.list();這個(gè)查詢指定了:
SQL查詢語(yǔ)句，它帶一個(gè)占位符，可以讓Hibernate使用字段的別名.
查詢返回的實(shí)體，和它的SQL表的別名.
addEntity()方法將SQL表的別名和實(shí)體類聯(lián)系起來(lái)，并且確定查詢結(jié)果集的形態(tài)。
addJoin()方法可以被用于載入其他的實(shí)體和集合的關(guān)聯(lián)，TODO:examples!
原生的SQL查詢可能返回一個(gè)簡(jiǎn)單的標(biāo)量值或者一個(gè)標(biāo)量和實(shí)體的結(jié)合體。
Double max = (Double) sess.createSQLQuery("select max(cat.weight) as maxWeight from cats cat")
.addScalar("maxWeight", Hibernate.DOUBLE);
.uniqueResult();17.2. 別名和屬性引用
上面使用的{cat.*}標(biāo)記是 "所有屬性" 的簡(jiǎn)寫.你可以顯式地列出需要的字段,但是你必須讓Hibernate 為每一個(gè)屬性注入字段的別名.這些字段的站位符是以字段別名為前導(dǎo),再加上屬性名.在下面的例子里,我們從一個(gè)其他的表(cat_log) 中獲取Cat對(duì)象,而非Cat對(duì)象原本在映射元數(shù)據(jù)中聲明的表.注意我們甚至在where子句中也可以使用屬性別名. 對(duì)于命名查詢,{}語(yǔ)法并不是必需的.你可以在第 17.3 節(jié) “命名SQL查詢”得到更多的細(xì)節(jié).
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();注意:如果你明確地列出了每個(gè)屬性,你必須包含這個(gè)類和它的子類的屬性! and its subclasses!
17.3. 命名SQL查詢
可以在映射文檔中定義查詢的名字,然后就可以象調(diào)用一個(gè)命名的HQL查詢一樣直接調(diào)用命名SQL查詢.在這種情況下,我們不 需要調(diào)用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();一個(gè)命名查詢可能會(huì)返回一個(gè)標(biāo)量值.你必須使用<return-scalar>元素來(lái)指定字段的別名和 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>元素分別用作 外連接和定義那些初始化集合的查詢
17.3.1. 使用return-property來(lái)明確地指定字段/別名
使用<return-property>你可以明確的告訴Hibernate使用哪些字段,這和使用{}-語(yǔ)法 來(lái)讓Hibernate注入它自己的別名是相反的.
<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>
<return-property>也可用于多個(gè)字段,它解決了使用{}-語(yǔ)法不能細(xì)粒度控制多個(gè)字段的限制
<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>注意在這個(gè)例子中,我們使用了<return-property>結(jié)合{}的注入語(yǔ)法. 允許用戶來(lái)選擇如何引用字段以及屬性.
如果你映射一個(gè)識(shí)別器(discriminator),你必須使用<return-discriminator>來(lái)指定識(shí)別器字段
17.3.2. 使用存儲(chǔ)過(guò)程來(lái)查詢
Hibernate 3引入了對(duì)存儲(chǔ)過(guò)程查詢的支持. 存儲(chǔ)過(guò)程必須返回一個(gè)結(jié)果集,作為Hibernate能夠使用的第一個(gè)外部參數(shù). 下面是一個(gè)Oracle9和更高版本的存儲(chǔ)過(guò)程例子.
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;在Hibernate里要要使用這個(gè)查詢,你需要通過(guò)命名查詢來(lái)映射它.
<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>注意存儲(chǔ)過(guò)程當(dāng)前僅僅返回標(biāo)量和實(shí)體.現(xiàn)在不支持<return-join>和<load-collection>
17.3.2.1. 使用存儲(chǔ)過(guò)程的規(guī)則和限制
為了在Hibernate中使用存儲(chǔ)過(guò)程,你必須遵循一些規(guī)則.不遵循這些規(guī)則的存儲(chǔ)過(guò)程將不可用.如果你仍然想要使用他們, 你必須通過(guò)session.connection()來(lái)執(zhí)行他們.這些規(guī)則針對(duì)于不同的數(shù)據(jù)庫(kù).因?yàn)閿?shù)據(jù)庫(kù) 提供商有各種不同的存儲(chǔ)過(guò)程語(yǔ)法和語(yǔ)義.
對(duì)存儲(chǔ)過(guò)程進(jìn)行的查詢無(wú)法使用setFirstResult()/setMaxResults()進(jìn)行分頁(yè)。
對(duì)于Oracle有如下規(guī)則:
存儲(chǔ)過(guò)程必須返回一個(gè)結(jié)果集.它通過(guò)返回SYS_REFCURSOR實(shí)現(xiàn)(在Oracle9或10),在Oracle里你需要定義一個(gè)REF CURSOR 類型
推薦的格式是 { ? = call procName(<parameters>) } 或 { ? = call procName }(這更像是Oracle規(guī)則而不是Hibernate規(guī)則)
對(duì)于Sybase或者M(jìn)S SQL server有如下規(guī)則:
存儲(chǔ)過(guò)程必須返回一個(gè)結(jié)果集。.注意這些servers可能返回多個(gè)結(jié)果集以及更新的數(shù)目.Hibernate將取出第一條結(jié)果集作為它的返回值， 其他將被丟棄。
如果你能夠在存儲(chǔ)過(guò)程里設(shè)定SET NOCOUNT ON，這可能會(huì)效率更高，但這不是必需的。
17.4. 定制SQL用來(lái)create，update和delete
Hibernate3能夠使用定制的SQL語(yǔ)句來(lái)執(zhí)行create,update和delete操作。在Hibernate中，持久化的類和集合已經(jīng) 包含了一套配置期產(chǎn)生的語(yǔ)句(insertsql, deletesql, updatesql等等)，這些映射標(biāo)記 <sql-insert>, <sql-delete>, and <sql-update>重載了 這些語(yǔ)句。
<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直接在你的數(shù)據(jù)庫(kù)里執(zhí)行，所以你可以自由的使用你喜歡的任意語(yǔ)法。但如果你使用數(shù)據(jù)庫(kù)特定的語(yǔ)法， 這當(dāng)然會(huì)降低你映射的可移植性。
如果設(shè)定callable，則能夠支持存儲(chǔ)過(guò)程了。
<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>參數(shù)的位置順序是非常重要的，他們必須和Hibernate所期待的順序相同。
你能夠通過(guò)設(shè)定日志調(diào)試級(jí)別為org.hiberante.persister.entity,來(lái)查看Hibernate所期待的順序。在這個(gè)級(jí)別下， Hibernate將會(huì)打印出create,update和delete實(shí)體的靜態(tài)SQL。如果想看到預(yù)想中的順序。記得不要將定制SQL包含在映射文件里， 因?yàn)樗麄儠?huì)重載Hibernate生成的靜態(tài)SQL。
在大多數(shù)情況下(最好這么做)，存儲(chǔ)過(guò)程需要返回插入/更新/刪除的行數(shù)，因?yàn)镠ibernate對(duì)語(yǔ)句的成功執(zhí)行有些運(yùn)行時(shí)的檢查。 Hibernate常會(huì)把進(jìn)行CUD操作的語(yǔ)句的第一個(gè)參數(shù)注冊(cè)為一個(gè)數(shù)值型輸出參數(shù)。
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;17.5. 定制裝載SQL
你可能需要聲明你自己的SQL(或HQL)來(lái)裝載實(shí)體
<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>這只是一個(gè)前面討論過(guò)的命名查詢聲明，你可以在類映射里引用這個(gè)命名查詢。
<class name="Person">
<id name="id">
<generator class="increment"/>
</id>
<property name="name" not-null="true"/>
<loader query-ref="person"/>
</class>這也可以用于存儲(chǔ)過(guò)程
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>第 18 章 過(guò)濾數(shù)據(jù)
Hibernate3 提供了一種創(chuàng)新的方式來(lái)處理具有“顯性(visibility)”規(guī)則的數(shù)據(jù)，那就是使用Hibernate filter。 Hibernate filter是全局有效的、具有名字、可以帶參數(shù)的過(guò)濾器， 對(duì)于某個(gè)特定的Hibernate session您可以選擇是否啟用（或禁用）某個(gè)過(guò)濾器。
18.1. Hibernate 過(guò)濾器(filters)
Hibernate3新增了對(duì)某個(gè)類或者集合使用預(yù)先定義的過(guò)濾器條件(filter criteria)的功能。過(guò)濾器條件相當(dāng)于定義一個(gè) 非常類似于類和各種集合上的“where”屬性的約束子句，但是過(guò)濾器條件可以帶參數(shù)。 應(yīng)用程序可以在運(yùn)行時(shí)決定是否啟用給定的過(guò)濾器，以及使用什么樣的參數(shù)值。 過(guò)濾器的用法很像數(shù)據(jù)庫(kù)視圖，只不過(guò)是在應(yīng)用程序中確定使用什么樣的參數(shù)的。
要使用過(guò)濾器，必須首先在相應(yīng)的映射節(jié)點(diǎn)中定義。而定義一個(gè)過(guò)濾器，要用到位于<hibernate-mapping/> 節(jié)點(diǎn)之內(nèi)的<filter-def/>節(jié)點(diǎn)：
<filter-def name="myFilter">
<filter-param name="myFilterParam" type="string"/>
</filter-def>定義好之后，就可以在某個(gè)類中使用這個(gè)過(guò)濾器：
<class name="myClass" ...>
...
<filter name="myFilter" condition=":myFilterParam = MY_FILTERED_COLUMN"/>
</class>也可以在某個(gè)集合使用它：
<set ...>
<filter name="myFilter" condition=":myFilterParam = MY_FILTERED_COLUMN"/>
</set>可以在多個(gè)類或集合中使用某個(gè)過(guò)濾器；某個(gè)類或者集合中也可以使用多個(gè)過(guò)濾器。
Session對(duì)象中會(huì)用到的方法有：enableFilter(String filterName), getEnabledFilter(String filterName), 和 disableFilter(String filterName). Session中默認(rèn)是不啟用過(guò)濾器的，必須通過(guò)Session.enabledFilter()方法顯式的啟用。 該方法返回被啟用的Filter的實(shí)例。以上文定義的過(guò)濾器為例：
session.enableFilter("myFilter").setParameter("myFilterParam", "some-value");注意，org.hibernate.Filter的方法允許鏈?zhǔn)椒椒ㄕ{(diào)用。（類似上面例子中啟用Filter之后設(shè)定Filter參數(shù)這個(gè)“方法鏈”） Hibernate的其他部分也大多有這個(gè)特性。
下面是一個(gè)比較完整的例子，使用了記錄生效日期模式過(guò)濾有時(shí)效的數(shù)據(jù)：
<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
注意，為了簡(jiǎn)單起見(jiàn)，此處假設(shè)雇用關(guān)系生效期尚未結(jié)束的記錄的eff_end_dt字段的值等于數(shù)據(jù)庫(kù)最大的日期
-->
<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>定義好后，如果想要保證取回的都是目前處于生效期的記錄，只需在獲取雇員數(shù)據(jù)的操作之前先開(kāi)啟過(guò)濾器即可：
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中，雖然我們僅僅顯式的使用了一個(gè)薪水條件，但因?yàn)閱⒂昧诉^(guò)濾器，查詢將僅返回那些目前雇用 關(guān)系處于生效期的，并且薪水高于一百萬(wàn)美刀的雇員的數(shù)據(jù)。
注意：如果你打算在使用外連接（或者通過(guò)HQL或load fetching）的同時(shí)使用過(guò)濾器，要注意條件表達(dá)式的方向（左還是右）。 最安全的方式是使用左外連接（left outer joining）。并且通常來(lái)說(shuō)，先寫參數(shù)， 然后是操作符，最后寫數(shù)據(jù)庫(kù)字段名。
第 19 章 XML映射
注意這是Hibernate 3.0的一個(gè)實(shí)驗(yàn)性的特性。這一特性仍在積極開(kāi)發(fā)中。
19.1. 用XML數(shù)據(jù)進(jìn)行工作
Hibernate使得你可以用XML數(shù)據(jù)來(lái)進(jìn)行工作，恰如你用持久化的POJO進(jìn)行工作那樣。解析過(guò)的XML樹(shù) 可以被認(rèn)為是另外一種在對(duì)象層面上代替POJO來(lái)表示關(guān)系型數(shù)據(jù)的途徑.
Hibernate支持采用dom4j作為操作XML樹(shù)的API。你可以寫一個(gè)查詢從數(shù)據(jù)庫(kù)中檢索出 dom4j樹(shù)，隨后你對(duì)這顆樹(shù)做的任何修改都將自動(dòng)同步回?cái)?shù)據(jù)庫(kù)。你甚至可以用dom4j解析 一篇XML文檔，然后使用Hibernate的任一基本操作將它寫入數(shù)據(jù)庫(kù)： persist(), saveOrUpdate(), merge(), delete(), replicate() (合并操作merge()目前還不支持)。
這一特性可以應(yīng)用在很多場(chǎng)合，包括數(shù)據(jù)導(dǎo)入導(dǎo)出，通過(guò)JMS或SOAP表現(xiàn)實(shí)體數(shù)據(jù)以及 基于XSLT的報(bào)表。
一個(gè)單一的映射就可以將類的屬性和XML文檔的節(jié)點(diǎn)同時(shí)映射到數(shù)據(jù)庫(kù)。如果不需要映射類， 它也可以用來(lái)只映射XML文檔。
19.1.1. 指定同時(shí)映射XML和類
這是一個(gè)同時(shí)映射POJO和XML的例子：
<class name="Account"
table="ACCOUNTS"
node="account">
<id name="accountId"
column="ACCOUNT_ID"
node="@id"/>
<many-to-one name="customer"
column="CUSTOMER_ID"
node="customer/@id"
embed-xml="false"/>
<property name="balance"
column="BALANCE"
node="balance"/>
...
</class>19.1.2. 只定義XML映射
這是一個(gè)不映射POJO的例子：
<class entity-name="Account"
table="ACCOUNTS"
node="account">
<id name="id"
column="ACCOUNT_ID"
node="@id"
type="string"/>
<many-to-one name="customerId"
column="CUSTOMER_ID"
node="customer/@id"
embed-xml="false"
entity-name="Customer"/>
<property name="balance"
column="BALANCE"
node="balance"
type="big_decimal"/>
...
</class>這個(gè)映射使得你既可以把數(shù)據(jù)作為一棵dom4j樹(shù)那樣訪問(wèn)，又可以作為由屬性鍵值對(duì)(java Maps) 組成的圖那樣訪問(wèn)。屬性名字是純粹邏輯上的結(jié)構(gòu)，你可以在HQL查詢中引用它。
19.2. XML映射元數(shù)據(jù)
許多Hibernate映射元素具有node屬性。這使你可以指定用來(lái)保存 屬性或?qū)嶓w數(shù)據(jù)的XML屬性或元素。node屬性必須是下列格式之一：
"element-name" - 映射為指定的XML元素
"@attribute-name" - 映射為指定的XML屬性
"." - 映射為父元素
"element-name/@attribute-name" - 映射為指定元素的指定屬性
對(duì)于集合和單值的關(guān)聯(lián)，有一個(gè)額外的embed-xml屬性可用。 這個(gè)屬性的缺省值是真(embed-xml="true")。如果embed-xml="true"， 則對(duì)應(yīng)于被關(guān)聯(lián)實(shí)體或值類型的集合的XML樹(shù)將直接嵌入擁有這些關(guān)聯(lián)的實(shí)體的XML樹(shù)中。 否則，如果embed-xml="false"，那么對(duì)于單值的關(guān)聯(lián)，僅被引用的實(shí)體的標(biāo)識(shí)符出現(xiàn)在 XML樹(shù)中(被引用實(shí)體本身不出現(xiàn))，而集合則根本不出現(xiàn)。
你應(yīng)該小心，不要讓太多關(guān)聯(lián)的embed-xml屬性為真(embed-xml="true")，因?yàn)閄ML不能很好地處理 循環(huán)引用!
<class name="Customer"
table="CUSTOMER"
node="customer">
<id name="id"
column="CUST_ID"
node="@id"/>
<map name="accounts"
node="."
embed-xml="true">
<key column="CUSTOMER_ID"
not-null="true"/>
<map-key column="SHORT_DESC"
node="@short-desc"
type="string"/>
<one-to-many entity-name="Account"
embed-xml="false"
node="account"/>
</map>
<component name="name"
node="name">
<property name="firstName"
node="first-name"/>
<property name="initial"
node="initial"/>
<property name="lastName"
node="last-name"/>
</component>
...
</class>在這個(gè)例子中，我們決定嵌入帳目號(hào)碼(account id)的集合，但不嵌入實(shí)際的帳目數(shù)據(jù)。下面的HQL查詢：
from Customer c left join fetch c.accounts where c.lastName like :lastName返回的數(shù)據(jù)集將是這樣：
<customer id="123456789">
<account id="987632567" short-desc="Savings"/>
<account id="985612323" short-desc="Credit Card"/>
<name>
<first-name>Gavin</first-name>
<initial>A</initial>
<last-name>King</last-name>
</name>
...
</customer>如果你把一對(duì)多映射<one-to-many>的embed-xml屬性置為真(embed-xml="true")， 則數(shù)據(jù)看上去就像這樣：
<customer id="123456789">
<account id="987632567" short-desc="Savings">
<customer id="123456789"/>
<balance>100.29</balance>
</account>
<account id="985612323" short-desc="Credit Card">
<customer id="123456789"/>
<balance>-2370.34</balance>
</account>
<name>
<first-name>Gavin</first-name>
<initial>A</initial>
<last-name>King</last-name>
</name>
...
</customer>19.3. 操作XML數(shù)據(jù)
讓我們來(lái)讀入和更新應(yīng)用程序中的XML文檔。通過(guò)獲取一個(gè)dom4j會(huì)話可以做到這一點(diǎn)：
Document doc = ....;
Session session = factory.openSession();
Session dom4jSession = session.getSession(EntityMode.DOM4J);
Transaction tx = session.beginTransaction();
List results = dom4jSession
.createQuery("from Customer c left join fetch c.accounts where c.lastName like :lastName")
.list();
for ( int i=0; i<results.size(); i++ ) {
//add the customer data to the XML document
Element customer = (Element) results.get(i);
doc.add(customer);
}
tx.commit();
session.close();Session session = factory.openSession();
Session dom4jSession = session.getSession(EntityMode.DOM4J);
Transaction tx = session.beginTransaction();
Element cust = (Element) dom4jSession.get("Customer", customerId);
for ( int i=0; i<results.size(); i++ ) {
Element customer = (Element) results.get(i);
//change the customer name in the XML and database
Element name = customer.element("name");
name.element("first-name").setText(firstName);
name.element("initial").setText(initial);
name.element("last-name").setText(lastName);
}
tx.commit();
session.close();將這一特色與Hibernate的replicate()操作結(jié)合起來(lái)而實(shí)現(xiàn)的基于XML的數(shù)據(jù)導(dǎo)入/導(dǎo)出將非常有用.
本文來(lái)自CSDN博客，轉(zhuǎn)載請(qǐng)標(biāo)明出處：http://blog.csdn.net/ctgyp/archive/2007/12/18/1946626.aspx
</script>