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();这段程序大概运行到 50 000 条记录左右会失败并抛出 内存溢出异常（OutOfMemoryException） 。 这是因为 Hibernate 把所有新插入的 客户（Customer）实例在 session级别的缓存区进行了缓存的缘故。

我们会在本章告诉你如何避免此类问题。首先，如果你要执行批量处理并且想要达到一个理想的性能， 那么使用JDBC的批量（batching）功能是至关重要。将JDBC的批量抓取数量（batch size）参数设置到一个合适值 （比如，10-50之间）：

hibernate.jdbc.batch_size 20你也可能想在执行批量处理时关闭二级缓存：

hibernate.cache.use_second_level_cache false14.1. 批量插入（Batch inserts）
如果要将很多对象持久化，你必须通过经常的调用 flush() 以及稍后调用 clear() 来控制第一级缓存的大小。

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批量设置相同
//flush a batch of inserts and release memory:
//将本批插入的对象立即写入数据库并释放内存
session.flush();
session.clear();
}
}
tx.commit();
session.close();14.2. 批量更新（Batch updates）
此方法同样适用于检索和更新数据。此外，在进行会返回很多行数据的查询时， 你需要使用 scroll() 方法以便充分利用服务器端游标所带来的好处。

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）
就像已经讨论的那样，自动和透明的 对象/关系 映射（object/relational mapping）关注于管理对象的状态。 这就意味着对象的状态存在于内存，因此直接更新或者删除 (使用 SQL 语句 UPDATE 和 DELETE) 数据库中的数据将不会影响内存中的对象状态和对象数据。 不过，Hibernate提供通过Hibernate查询语言（第 15 章 HQL: Hibernate查询语言）来执行大批 量SQL风格的（UPDATE）和（DELETE） 语句的方法。

UPDATE 和 DELETE语句的语法为： ( UPDATE | DELETE ) FROM? ClassName (WHERE WHERE_CONDITIONS)?。 有几点说明：

在FROM子句（from-clause）中，FROM关键字是可选的

在FROM子句（from-clause）中只能有一个类名，并且它不能有别名

不能在大批量HQL语句中使用连接（显式或者隐式的都不行）。不过在WHERE子句中可以使用子查询。

整个WHERE子句是可选的。

举个例子，使用Query.executeUpdate()方法执行一个HQL UPDATE语句：

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();执行一个HQL DELETE，同样使用 Query.executeUpdate() 方法 （此方法是为 那些熟悉JDBC PreparedStatement.executeUpdate() 的人们而设定的）

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()方法返回的整型值表明了受此操作影响的记录数量。 注意这个数值可能与数据库中被（最后一条SQL语句）影响了的“行”数有关，也可能没有。一个大批量HQL操作可能导致多条实际的SQL语句被执行， 举个例子，对joined-subclass映射方式的类进行的此类操作。这个返回值代表了实际被语句影响了的记录数量。在那个joined-subclass的例子中， 对一个子类的删除实际上可能不仅仅会删除子类映射到的表而且会影响“根”表，还有可能影响与之有继承关系的joined-subclass映射方式的子类的表。

注意，上述大批量HQL操作的少数限制会在新版本中得到改进；进一步详细信息请参考JIRA里的路线图(roadmap)。

第 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, Parameterfrom 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 kittenfrom Cat as cat left join cat.mate.kittens as kittensfrom 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 namefrom 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.weightselect 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 cat15.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.mateselect 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 = 123456from 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 > 0from Cat cat where size(cat.kittens) > 0对于索引了（有序）的集合，你可以使用minindex 与 maxindex函数来引用到最小与最大的索引序数。 同理，你可以使用minelement 与 maxelement函数来 引用到一个基本数据类型的集合中最小与最大的元素。

from Calendar cal where maxelement(cal.holidays) > current datefrom Order order where maxindex(order.items) > 100from 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 = 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在[]中的表达式甚至可以是一个算数表达式。

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.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)如果底层的数据库支持的话(例如不能在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.dueDate15.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) = 0JavaBean的属性可以被绑定到一个命名查询（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();第 16 章  条件查询(Criteria Queries)
具有一个直观的、可扩展的条件查询API是Hibernate的特色。

16.1. 创建一个Criteria 实例
org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();16.2. 限制结果集内容
一个单独的查询条件是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();16.3. 结果集排序
你可以使用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();16.4. 关联
你可以使用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");
}16.5. 动态关联抓取
你可以使用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) ”可以获得更多信息。

16.6. 查询示例
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();16.7. 投影(Projections)、聚合（aggregation）和分组（grouping）
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();16.8. 离线(detached)查询和子查询
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();第 17 章 Native SQL查询
你也可以使用你的数据库的Native SQL语言来查询数据。这对你在要使用数据库的某些特性的时候(比如说在查询提示或者Oracle中的 CONNECT关键字)，这是非常有用的。这就能够扫清你把原来直接使用SQL/JDBC 的程序迁移到基于 Hibernate应用的道路上的障碍。

Hibernate3允许你使用手写的sql来完成所有的create,update,delete,和load操作（包括存储过程）

17.1. 创建一个基于SQL的Query
SQL查询是通过SQLQuery接口来控制的，它是通过调用Session.createSQLQuery()方法来获得

List cats = sess.createSQLQuery("select {cat.*} from cats cat")
.addEntity("cat", Cat.class);
.setMaxResults(50);
.list();这个查询指定了:

SQL查询语句，它带一个占位符，可以让Hibernate使用字段的别名.

查询返回的实体，和它的SQL表的别名.

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();17.2. 别名和属性引用
上面使用的{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!

17.3. 命名SQL查询
可以在映射文档中定义查询的名字,然后就可以象调用一个命名的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>元素分别用作 外连接和定义那些初始化集合的查询

17.3.1. 使用return-property来明确地指定字段/别名
使用<return-property>你可以明确的告诉Hibernate使用哪些字段,这和使用{}-语法 来让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>也可用于多个字段,它解决了使用{}-语法不能细粒度控制多个字段的限制
<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>注意在这个例子中,我们使用了<return-property>结合{}的注入语法. 允许用户来选择如何引用字段以及属性.

如果你映射一个识别器(discriminator),你必须使用<return-discriminator>来指定识别器字段

17.3.2. 使用存储过程来查询
Hibernate 3引入了对存储过程查询的支持. 存储过程必须返回一个结果集,作为Hibernate能够使用的第一个外部参数. 下面是一个Oracle9和更高版本的存储过程例子.

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里要要使用这个查询,你需要通过命名查询来映射它.

<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>注意存储过程当前仅仅返回标量和实体.现在不支持<return-join>和<load-collection>

17.3.2.1. 使用存储过程的规则和限制
为了在Hibernate中使用存储过程,你必须遵循一些规则.不遵循这些规则的存储过程将不可用.如果你仍然想要使用他们, 你必须通过session.connection()来执行他们.这些规则针对于不同的数据库.因为数据库 提供商有各种不同的存储过程语法和语义.

对存储过程进行的查询无法使用setFirstResult()/setMaxResults()进行分页。

对于Oracle有如下规则:

存储过程必须返回一个结果集.它通过返回SYS_REFCURSOR实现(在Oracle9或10),在Oracle里你需要定义一个REF CURSOR 类型

推荐的格式是 { ? = call procName(<parameters>) } 或 { ? = call procName }(这更像是Oracle规则而不是Hibernate规则)

对于Sybase或者MS SQL server有如下规则:

存储过程必须返回一个结果集。.注意这些servers可能返回多个结果集以及更新的数目.Hibernate将取出第一条结果集作为它的返回值， 其他将被丢弃。

如果你能够在存储过程里设定SET NOCOUNT ON，这可能会效率更高，但这不是必需的。

17.4. 定制SQL用来create，update和delete
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;17.5. 定制装载SQL
你可能需要声明你自己的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>第 18 章 过滤数据
Hibernate3 提供了一种创新的方式来处理具有“显性(visibility)”规则的数据，那就是使用Hibernate filter。 Hibernate filter是全局有效的、具有名字、可以带参数的过滤器， 对于某个特定的Hibernate session您可以选择是否启用（或禁用）某个过滤器。

18.1. Hibernate 过滤器(filters)
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）。并且通常来说，先写参数， 然后是操作符，最后写数据库字段名。

第 19 章 XML映射
注意这是Hibernate 3.0的一个实验性的特性。这一特性仍在积极开发中。

19.1. 用XML数据进行工作
Hibernate使得你可以用XML数据来进行工作，恰如你用持久化的POJO进行工作那样。解析过的XML树 可以被认为是另外一种在对象层面上代替POJO来表示关系型数据的途径.

Hibernate支持采用dom4j作为操作XML树的API。你可以写一个查询从数据库中检索出 dom4j树，随后你对这颗树做的任何修改都将自动同步回数据库。你甚至可以用dom4j解析 一篇XML文档，然后使用Hibernate的任一基本操作将它写入数据库： persist(), saveOrUpdate(), merge(), delete(), replicate() (合并操作merge()目前还不支持)。

这一特性可以应用在很多场合，包括数据导入导出，通过JMS或SOAP表现实体数据以及 基于XSLT的报表。

一个单一的映射就可以将类的属性和XML文档的节点同时映射到数据库。如果不需要映射类， 它也可以用来只映射XML文档。

19.1.1. 指定同时映射XML和类
这是一个同时映射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映射
这是一个不映射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>这个映射使得你既可以把数据作为一棵dom4j树那样访问，又可以作为由属性键值对(java Maps) 组成的图那样访问。属性名字是纯粹逻辑上的结构，你可以在HQL查询中引用它。

19.2. XML映射元数据
许多Hibernate映射元素具有node属性。这使你可以指定用来保存 属性或实体数据的XML属性或元素。node属性必须是下列格式之一：

"element-name" - 映射为指定的XML元素

"@attribute-name" - 映射为指定的XML属性

"." - 映射为父元素

"element-name/@attribute-name" - 映射为指定元素的指定属性

对于集合和单值的关联，有一个额外的embed-xml属性可用。 这个属性的缺省值是真(embed-xml="true")。如果embed-xml="true"， 则对应于被关联实体或值类型的集合的XML树将直接嵌入拥有这些关联的实体的XML树中。 否则，如果embed-xml="false"，那么对于单值的关联，仅被引用的实体的标识符出现在 XML树中(被引用实体本身不出现)，而集合则根本不出现。

你应该小心，不要让太多关联的embed-xml属性为真(embed-xml="true")，因为XML不能很好地处理 循环引用!

<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>在这个例子中，我们决定嵌入帐目号码(account id)的集合，但不嵌入实际的帐目数据。下面的HQL查询：

from Customer c left join fetch c.accounts where c.lastName like :lastName返回的数据集将是这样：

<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>如果你把一对多映射<one-to-many>的embed-xml属性置为真(embed-xml="true")， 则数据看上去就像这样：

<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数据
让我们来读入和更新应用程序中的XML文档。通过获取一个dom4j会话可以做到这一点：

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()操作结合起来而实现的基于XML的数据导入/导出将非常有用.

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ctgyp/archive/2007/12/18/1946626.aspx

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name="t_users")
public class TUser {
 @Id
 @Column(name = "user_id")
 @GeneratedValue(generator = "sequence")
 @SequenceGenerator(name = "sequence", sequenceName = "t_table_id_seq")
 private Integer id;
 
 @Column(name = "age")
 private Integer age;
 
 @Column(name= "name")
 private String name;
 
 @OneToOne(cascade = CascadeType.ALL)
 @PrimaryKeyJoinColumn
 private TPassport passport;

 public Integer getAge() {
  return age;
 }

 public void setAge(Integer age) {
  this.age = age;
 }

 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public TPassport getPassport() {
  return passport;
 }

 public void setPassport(TPassport passport) {
  this.passport = passport;
 }
}

package com;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;

@Entity
@Table(name = "t_passports")
public class TPassport {
 @Id
 @GeneratedValue(generator = "fk")
 @GenericGenerator(strategy = "foreign", name = "fk", parameters = @Parameter(name="property", value="user"))
 private Integer id;
 
 @Column(name = "serial")
 private String serial;
 
 @Column(name="expiry")
 private Integer expiry;
 
 @OneToOne(mappedBy="passport", optional = false)
 private TUser user;

 public Integer getExpiry() {
  return expiry;
 }

 public void setExpiry(Integer expiry) {
  this.expiry = expiry;
 }

 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public String getSerial() {
  return serial;
 }

 public void setSerial(String serial) {
  this.serial = serial;
 }

 public TUser getUser() {
  return user;
 }

 public void setUser(TUser user) {
  this.user = user;
 }
}

1．     表和子类之间的对立一对一关系 Table per concrete class

源码下载 http://download.csdn.net/source/226662
2．     每个子类对应一张子表,并与主类共享主表 Table per subclass

源码下载 http://download.csdn.net/source/226728
3．     表与类的一对多关系 Table per class hierarchy
源码下载 http://download.csdn.net/source/226783

按照《深入潜出Hibernate》中介绍的，我们开始学习。

场景: 就一般的商品而言，在具备某些共性(如: 名称,厂商),也有不同的属性,如书有页数，dvd有dvd的编码格式.

<一> table per concerte class

(a) 使用xml

Titem 有两个子类: Tbook , TDvd, 那么，所谓“表与子类之间的一对一的关系”，也就是每个子类对应一张数据库表。对应Tbook , TDvd

数据库的表我们设计如下

/**

* 虚拟的表

* TItem 已经知道的继承类为 AbstractTBook AbstractTDvd

*/

public abstract class TItem implements Serializable {

    private Integer id;

    private String name;

    private String manufacturer;

    public Integer getId() {

       return id;

       }

    public void setId(Integer id) {

       this.id = id;

       }

    public String getManufacturer() {

       return manufacturer;

       }

    public void setManufacturer(String manufacturer) {

       this.manufacturer = manufacturer;

       }

    public String getName() {

       return name;

       }

    public void setName(String name) {

       this.name = name;

       }

}

public abstract class AbstractTDvd extends TItem {

    private String codetype;

    public AbstractTDvd() {     }

    public String getCodetype() {

       return this.codetype;

       }

    public void setCodetype(String codetype) {

       this.codetype = codetype;

       }

}

public abstract class AbstractTBook extends TItem {

    private Integer pagecount;

    public AbstractTBook() {}

    public Integer getPagecount() {

       return this.pagecount;

       }

    public void setPagecount(Integer pagecount) {

       this.pagecount = pagecount;

       }

}

public class TDvd extends AbstractTDvd     {

    public TDvd() {}

}

public class TBook extends AbstractTDvd     {

    public TBook() {}

}

Tbook.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<hibernate-mapping>

       <class name="com.persist.tablePerConcreteClass.TBook" table="t_book" >

           <id name="id" type="java.lang.Integer">

               <column name="id" />

               <generator class="sequence">

               <param name="sequence">t_table_id_seq</param>

               </generator>

           </id>

           <property name="name" type="java.lang.String">

               <column name="name" length="50" />

           </property>

           <property name="manufacturer" type="java.lang.String">

               <column name="manufacturer" length="50" />

           </property>

           <property name="pagecount" type="java.lang.Integer">

               <column name="pagecount" />

           </property>

       </class>

</hibernate-mapping>

Tdvd.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<hibernate-mapping>

       <class name="com.persist.tablePerConcreteClass.TDvd" table="t_dvd" >

           <id name="id" type="java.lang.Integer">

               <column name="id" />

               <generator class="sequence">

               <param name="sequence">t_table_id_seq</param>

               </generator>

           </id>

           <property name="name" type="java.lang.String">

               <column name="name" length="50" />

           </property>

           <property name="manufacturer" type="java.lang.String">

               <column name="manufacturer" length="50" />

           </property>

           <property name="codetype" type="java.lang.String">

               <column name="codetype" length="50" />

           </property>

       </class>

</hibernate-mapping>

Hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>

<hibernate-configuration>

       <session-factory>

          <property name="dialect">

              org.hibernate.dialect.PostgreSQLDialect

          </property>

          <property name="connection.url">

              jdbc:postgresql://localhost:5432/postgres

          </property>

          <property name="connection.username">pgsql</property>

          <property name="connection.password">pgsql</property>

          <property name="connection.driver_class">

              org.postgresql.Driver

          </property>

          <property name="myeclipse.connection.profile">pgsql</property>

          <property name="show_sql">true</property>

          <mapping resource="com/persist/tablePerConcreteClass/TBook.hbm.xml" />

          <mapping resource="com/persist/tablePerConcreteClass/TDvd.hbm.xml" />

       </session-factory>

</hibernate-configuration>

测试用例

public class TBookDAO extends BaseHibernateDAO {

    public static void main(String args[]) {

       new TBookDAO().test();

       }

    public void test() {

          Session session = this.getSession();

          List list = session.createQuery(" from com.persist.tablePerConcreteClass.TItem").list();

          Iterator it = list.iterator();

       while (it.hasNext()) {

              TItem item = (TItem) it.next();

              System.out.println(item.getName());

          }

       }

}

(b) 使用hibernate注解
步骤1， 修改HibernateSessionFactory 中的Configuration为

AnnotationConfiguration configuration = new AnnotationConfiguration();

步骤2，修改hibernate.cfg.xml中的

<mapping resource="com/persist/tablePerConcreteClass/TBook.hbm.xml" />

<mapping resource="com/persist/tablePerConcreteClass/TDvd.hbm.xml" />

为

<mapping class="com.persist.tablePerConcreteClass.TBook"/>

<mapping class="com.persist.tablePerConcreteClass.TDvd"/>

步骤3，在Titem, AbstractTBook, AbstractTBook类上加注解

@MappedSuperclass

既Titem

@MappedSuperclass

public abstract class TItem implements Serializable {

    @Id

    @Column(name = "id")

    @SequenceGenerator(name = "t_table_id_seq", sequenceName = "t_table_id_seq")

    private Integer id;

    @Column(name = "name")

    private String name;

    @Column(name = "manufacturer")

    private String manufacturer;

    public Integer getId() {

       return id;

    }

    public void setId(Integer id) {

       this.id = id;

    }

    public String getManufacturer() {

       return manufacturer;

    }

    public void setManufacturer(String manufacturer) {

       this.manufacturer = manufacturer;

    }

    public String getName() {

       return name;

    }

    public void setName(String name) {

       this.name = name;

    }

}

AbstractTDvd

@MappedSuperclass

public class AbstractTDvd extends TItem {

    @Column(name = "codetype")

    private String codetype;

    public AbstractTDvd() { }

    public String getCodetype() {

       return this.codetype;

    }

    public void setCodetype(String codetype) {

       this.codetype = codetype;

    }

}

AbstractTBook

@MappedSuperclass

public class AbstractTBook extends TItem {

    @Column(name = "pagecount")

    private Integer pagecount;

    public AbstractTBook() {}

    public Integer getPagecount() {

       return this.pagecount;

    }   public void setPagecount(Integer pagecount) {

       this.pagecount = pagecount;

    }

}

步骤4，在Tbook,TDvd上加注解

@Entity

@Table(name = "t_book")

和

@Entity

@Table(name = "t_dvd")

调用的时候一样
 

<二> Table per subclass

将父类Titem单独映射到一张主表，而为Tbook, TDvd分别建立一张子表，子表和父表用外键来关联

数据库的表我们设计如下

表 T_item
id	Int	PK
Name	Varchar(50)
Manufacturer	Varchar(50)
CREATE TABLE t_item (  id int4 NOT NULL DEFAULT nextval('t_table_id_seq'::regclass),  name varchar(50),  manufacturer varchar(50),  CONSTRAINT t_item_pkey PRIMARY KEY (id) )

表 T_bool
id	Int	PK
Pagecount	int
CREATE TABLE t_book (  id int4 NOT NULL,  pagecount int4,  CONSTRAINT t_book_pkey PRIMARY KEY (id),  CONSTRAINT t_book_id_fkey FOREIGN KEY (id)       REFERENCES t_item (id) MATCH SIMPLE       ON UPDATE NO ACTION ON DELETE NO ACTION )

表 T_dvd
id	Int	PK
Codetype	Varchar(30)
CREATE TABLE t_dvd (  id int4 NOT NULL,  codetype varchar(30),  CONSTRAINT t_dvd_pkey PRIMARY KEY (id),  CONSTRAINT t_dvd_id_fkey FOREIGN KEY (id)       REFERENCES t_item (id) MATCH SIMPLE       ON UPDATE NO ACTION ON DELETE NO ACTION )

只有1个xml,TItem.hbm.xml
<hibernate-mapping>
     <class name="com.persist.tablePerConcreteClass.TItem" table="t_item">
         <id name="id" type="java.lang.Integer">
             <column name="id" />
             <generator class="sequence">
              <param name="sequence">t_table_id_seq</param>
             </generator>
         </id>
         <property name="name" type="java.lang.String">
             <column name="name" length="50" />
         </property>
         <property name="manufacturer" type="java.lang.String">
             <column name="manufacturer" length="50" />
         </property>
        
         <joined-subclass name="com.persist.tablePerConcreteClass.TBook" table="t_book">
          <key column="id"></key>
          <property name="pagecount" column="pagecount">
          </property>
         </joined-subclass>
         <joined-subclass name="com.persist.tablePerConcreteClass.TDvd" table="t_dvd">
          <key column="id"></key>
          <property name="codetype" column="codetype">
          </property>
         </joined-subclass>
     </class>
</hibernate-mapping>
使用注解
1.TItem不为抽象类,TItem的类注解为
@Entity
@Table(name = "t_item")
@Inheritance(strategy=InheritanceType.JOINED)
2.AbstractTBook和AbstractTDvd的类注解为
@PrimaryKeyJoinColumn(name="id")
3.TBook和TDvd的注解为
@Entity
@Table(name = "t_book")
和
@Entity
@Table(name = "t_dvd")

<三> Table per class hierarchy

CREATE TABLE t_item

(

 id int4 NOT NULL DEFAULT nextval('t_table_id_seq'::regclass),

 name varchar(50),

 manufacturer varchar(50),

 category varchar(30),

 codetype varchar(30),

 pagecount int4,

 CONSTRAINT t_item_pkey PRIMARY KEY (id)

)

只有一个xml,TItem.hbm.xml
<hibernate-mapping>
    <class name="com.persist.tablePerConcreteClass.TItem" table="t_item">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="sequence">
             <param name="sequence">t_table_id_seq</param>
            </generator>
        </id>
        <discriminator>
            <column name="category" length="10" />
        </discriminator>
        <property name="name" type="java.lang.String">
            <column name="name" length="50" />
        </property>
        <property name="manufacturer" type="java.lang.String">
            <column name="manufacturer" length="50" />
        </property>        
        <subclass name="com.persist.tablePerConcreteClass.TBook" discriminator-value="1">
         <property name="pagecount" column="pagecount">
         </property>
        </subclass>
        <subclass name="com.persist.tablePerConcreteClass.TDvd" discriminator-value="2" >
         <property name="codetype" column="codetype">
         </property>
        </subclass>
    </class>
</hibernate-mapping>
注解的修改为
1.TItem的注解修改为
@Entity
@Table(name = "t_item")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="category", discriminatorType=DiscriminatorType.STRING, length=30)
2.AbstractTBook, AbstractTDvd的注解修改为
@Inheritance
3.TBook,TDvd的注解修改为
@Entity
@DiscriminatorValue(value="2")