Hibernate 查询语言

Hibernate 查询语言 (HQL)

       Hibernate 拥有一种功能非常强大的查询语言，这种语言被有意得与 SQL 非常相似，便于开发人员掌握。但不要被 HQL 的语法表面所迷惑， HQL 完全是面向对象的，可以用来过程多态、继承、关联等关系。

10.1 大小写敏感（ Case Sensitivity ）

    HQL 中的使用的 Java 的类名和属性名是大小写敏感的，其他的关键字都是大小写不敏感的。所以“ SeLeCT ”等同与“ sELEct ”，也等同于“ SELECT ”，因为它不是 Java 类名，也不是 Java 类的属性名。但 Java 类 net.sf.hibernate.eg.FOO 不等同于 net.sf.hibernate.eg.Foo ，同样 foo.barSet 也不等同于 foo.BARSET 。

 

    在本手册中， HQL 中的关键字均采用小写，一些用户可能发现 HQL 的关键字采用大写更易读，但我们也发现，当把这些 HQL 嵌入 Java 代码中，看起来很丑陋。

 

10.2from 从句（ The from clause ）

Hibernate 中最简单的 from 查询可能是：

 

from eg.Cat

 

只是简单的返回 eg.Cat 类的所有实例。

 

在很多时候你可能需要为类设置别名（ alias ），因为你可能需要在查询的其他部分引用 Cat 。

 

from eg.Cat as cat

 

关键字 as 是可选的，我们也可以写成：

 

from eg.Cat cat

 

可以出现多个类，然后返回一个“笛卡儿积”或交叉连接：

 

from Formula as form, Parameter as param

 

HQL 中的别名用小写字母是一个好习惯，符合 Java 本地变量的命名规范。

 

10.3 关联和连接（ Associations and joins ）

       我们使用别名关联实体、甚至用 join 来关联值的集合的元素。

 

from eg.Cat as cat

 

    inner join cat.mate as mate

 

    left outer join cat.kittens as kitten

 

 

 

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

 

 

 

from Formula form full join form.parameter param

 

支持的连接类型借鉴自 ANSI SQL ：

 

·                                  inner join

 

·                                  left outer join

 

·                                  right outer join

 

·                                  full join ( 不常用 )

 

inner join, left outer join 和 right outer join 可以简写。

 

from eg.Cat as cat

 

    join cat.mate as mate

 

    left join cat.kittens as kitten

 

另外，一个“ fetch ”连接允许使用单连接来关联或值的集合，使它们可以和父对象一起来初始化。这在使用 Collection 的情况下特别有用。

 

from eg.Cat as cat

 

    inner join fetch cat.mate

 

    left join fetch cat.kittens

 

    fetch join 通常不需要设置别名，因为被关联的对象不应该被用在 where 从句中，也不能用在其他的任何从句中。

 

    被关联的对象不能直接在查询结果中返回，他们可以通过父对象来访问。

 

请注意：在目前的实现中，在查询中只能返回一个集合。另外还要注意 ,fetch 可能不用在被 scroll() 和 iterator() 调用的查询中。最后还要注意， full join fetch 和 right join fetch 是没有意义的。

 

10.4 select 从句（ The select clause ）

select 从句用来挑选在结果集中返回的对象和属性：

 

select cat.mate from eg.Cat cat

 

上面这个查询返回所有猫的配偶。

 

你也可以使用 elements 函数返回集合的元素。下面的查询将返回任何猫（ Cat ）的所有小猫（ Kitten ）。

 

select elements(cat.kittens) from eg.Cat cat

 

查询也可以返回任何值类型（包括 Component 类型的属性）的属性：

 

select cat.name from eg.DomesticCat cat

 

where cat.name like 'fri%'

 

select cust.name.firstName from Customer as cust

 

查询可以返回多个对象，也可以返回作为 Object[] 类型的数组的属性。

 

select mother, offspr, mate.name

 

from eg.DomesticCat as mother

 

    inner join mother.mate as mate

 

    left outer join mother.kittens as offspr

 

或者作为一个实际的 Java 对象：

 

select new Family(mother, mate, offspr)

 

from eg.DomesticCat as mother

 

    join mother.mate as mate

 

    left join mother.kittens as offspr

 

上面的这个查询语句假设 Family 类有适当的构造函数。

 

10.5 聚集函数（ Aggregate functions ）

查询可以使用属性的聚集函数：

 

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

 

select 从句的聚集函数中可以出现集合：

 

select cat, count( elements(cat.kittens) ) from eg.Cat cat group by cat

 

支持的聚集函数有：

 

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

 

·                                  count(*)

 

·                                  count(...), count(distinct ...), count(all...)

 

distinct 和 all 关键字的意义与用法和 SQL 中相同：

 

select distinct cat.name from eg.Cat cat

 

 

 

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

 

 

 

10.6 多态（ polymorphism ）

       一个查询： from eg.Cat as cat ，它返回的不只是 Cat ，也有 DomesticCat （家猫）这样的子类。 Hibernate 可以在 from 从句中指定任何 Java 类和接口，查询将返回继承自该类和实现了该接口的所有的持久类的实例。下面的查询将返回所有持久的对象：

 

from java.lang.Object o

 

        指定的接口可以被多个不同的持久类实现：

 

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

 

注意最后 2 个查询将需要超过 1 个 SQL 的 select ，这意味着不能够按照从句指定的排列次序排列整个结果集。这也意味着你不能用 Query.scroll() 来调用这些查询。

 

10.7 where 从句（ The where clause ）

       where 从句是你可以按照自己指定的条件更精确的返回实例：

 

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

 

复合表达式使 where 从句功能非常强大：

 

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

 

这个查询将被翻译成带有一个连接的 SQL 查询语句。

 

       如果你写下这句查询：

 

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

 

这个查询翻译成 SQL 语句需要 4 个表连接。

 

       “ = ”操作符不仅可以比较属性，也可以比较实例：

 

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

 

 

 

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

 

 

 

一个叫 id 的特殊的属性被用来引用一个对象的唯一标识符，你也可以用对象的属性名。

 

from eg.Cat as cat where cat.id = 123

 

 

 

from eg.Cat as cat where cat.mate.id = 69  这个查询要比上一个有效率，因为不需要表连接。

 

可以使用复合主键的属性。假设 person 有一个由 medicareNumber 和 country 构成的符合主键：

 

from bank.Person person

 

where person.id.country = 'AU'

 

    and person.id.medicareNumber = 123456

 

 

 

from bank.Account account

 

where account.owner.id.country = 'AU'

 

    and account.owner.id.medicareNumber = 123456

 

再重复一次，第二个查询效率高些。

 

 

 

同样，一个指定了属性的类在多态持久（ polymorphic persistence ）的情况下访问实体的 discriminator value 。

 

一个被嵌入到 where 从句中的 Java 类名将被翻译成它的 discriminator value 。

 

from eg.Cat cat where cat.class = eg.DomesticCat

 

你也可以指定组件（ component ）的属性和用户自己定义的合成类型（及组件的组件等等）。

 

永远也不要使用一个以组件的属性结尾的路径表达式。举个例子，假设 store.owner 是一个带有一个叫 address 组件的实体：

 

store.owner.address.city    // 正确

 

store.owner.address        // 错误 !

 

一个叫“ any ”的类型有 2 个特别的属性，一个是 id ，另一个是 class ，它允许我们用下面的办法进行连接（ join ）。 AuditLog.item 是一个用 <any> 映射的属性：

 

from eg.AuditLog log, eg.Payment payment

 

where log.item.class = 'eg.Payment' and log.item.id = payment.id

 

需要注意的是：查询中的 log.item.class 和 payment.class 将参考完全不同的数据库列。

 

10.8 表达式（ Expressions ）

       where 从句中的表达式允许你使用 SQL 中的很多东西：

 

·                                   数学运算符： +, -, *, /

 

·                                  二元比较运算符： =, >=, <=, <>, !=, like

 

·                                  逻辑操作符： and, or, not

 

·                                  字符串连接符： ||

 

·                                  SQL 函数，如： upper() and lower()

 

·                                  圆括号： ( ) 

 

·                                  in, between, is null

 

·                                  JDBC 输入参数： ?

 

·                                  指定的参数： :name, :start_date, :x1

 

·                                  in 和 between ：

 

from eg.DomesticCat cat where cat.name between 'A' and 'B'

 

 

 

from eg.DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )

 

和否定形式的（ negated forms ）：

 

from eg.DomesticCat cat where cat.name not between 'A' and 'B'

 

 

 

from eg.DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )

 

·                                  is null 和 is not null

 

·                                  也可以使用特殊的属性 size 或 size() 函数来测试集合的大小：

 

from eg.Cat cat where cat.kittens.size > 0

 

 

 

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

 

·                                  对于有索引的集合，你可以使用特殊属性 minIndex 和 maxIndex 来引用最小索引和最大索引。同样，你也可以使用 minElement 和 maxElement 来引用基本类型的集合的 minimum 和 maximum 元素。

 

from Calendar cal where cal.holidays.maxElement > current date

 

也可以是函数的形式：

 

from Order order where maxindex(order.items) > 100

 

 

 

from Order order where minelement(order.items) > 10000

 

在传递索引和元素给集合时（ elements and indices 函数）和传递子查询的结果集时， SQL 函数 any, some, all, exists, in 都是被支持的：

 

select mother from eg.Cat as mother, eg.Cat as kit

 

where kit in elements(foo.kittens)

 

 

 

select p from eg.NameList list, eg.Person p

 

where p.name = some elements(list.names)

 

 

 

from eg.Cat cat where exists elements(cat.kittens)

 

 

 

from eg.Player p where 3 > all elements(p.scores)

 

 

 

from eg.Show show where 'fizard' in indices(show.acts)

 

 

 

请注意： size, elements, indices, minIndex, maxIndex, minElement, maxElement 在使用时有一些限制：

 

v      where 从句中的 in 只用于数据库的子查询。

 

v      select 从句中的 in 只用于 elements 和 indices 函数。

 

v      带有索引的元素的 collection （ arrays, lists, maps ）只能在 where 从句中通过索引引用：

 

from Order order where order.items[0].id = 1234

 

 

 

select person from Person person, Calendar calendar

 

where calendar.holidays['national day'] = person.birthDay

 

    and person.nationality.calendar = calendar

 

 

 

select item from Item item, Order order

 

where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

 

 

 

select item from Item item, Order order

 

where order.items[ maxindex(order.items) ] = item and order.id = 11

 

表达式中的 [] 的内部可以是一个算术表达式：

 

select item from Item item, Order order

 

where order.items[ size(order.items) - 1 ] = item

 

HQL 为 one-to-many 关联和值的集合提供了内置的 index() 函数：

 

select item, index(item) from Order order

 

    join order.items item

 

where index(item) < 5

 

被一些特定数据库支持的 SQL 函数可以被使用：

 

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

 

如果你还不相信上面的一切，那么想想更长的和更短的可读的查询吧：

 

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)

提示： something like

 

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 ）

 

 

10.9 order by 从句（ The order by clause ）

查询返回的列表可以使用组件或类的任意属性排序：

 

from eg.DomesticCat cat

 

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

 

关键字 asc 和 desc 是可选的，分别决定是按升序还是降序排列结果。

 

10.10 group by 从句（ The group by clause ）

       查询返回的聚集可以按照指定的类或组件的任意属性进行分组：

 

select cat.color, sum(cat.weight), count(cat)

 

from eg.Cat cat

 

group by cat.color

 

 

 

select foo.id, avg( elements(foo.names) ), max( indices(foo.names) )

 

from eg.Foo foo

 

group by foo.id

 

注意：你可以在 select 从句中使用 elements 和 indices 结构，即使数据库中没有子查询。

 

    Having 从句也允许使用：

 

select cat.color, sum(cat.weight), count(cat)

 

from eg.Cat cat

 

group by cat.color

 

having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

 

如果你的数据库支持，则你可以在 having 和 order by 从句中使用 SQL 函数（ ie ： MySQL 中不支持）：

 

select cat from eg.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 clause nor the order by 都不支持算术表达式。

 

 

 

10.11 子查询（ Subqueries ）

       Hibernate 支持子查询，子查询必须用圆括号包围。子查询通常被 SQL 聚集函数调用。子查询中引用一个外部查询的别名也是被允许的。

 

from eg.Cat as fatcat

 

where fatcat.weight > (

 

    select avg(cat.weight) from eg.DomesticCat cat

 

)

 

 

 

from eg.DomesticCat as cat

 

where cat.name = some (

 

    select name.nickName from eg.Name as name

 

)

 

 

 

from eg.Cat as cat

 

where not exists (

 

    from eg.Cat as mate where mate.mate = cat

 

)

 

 

 

from eg.DomesticCat as cat

 

where cat.name not in (

 

    select name.nickName from eg.Name as name

 

       )

 

10.12 例子（ Examples ）

       Hibernate 的查询功能相当强大，而且复杂。事实上，功能强大的查询语言是 Hibernate 的主要的卖点（ selling points 。原来这是一个外来词呀，今天才知道。 ^_^ ）。

 

       下面是一些简单的查询例子，这是从我最近的项目中挑出来的，在大多数情况下，你写的查询要比这些更简单。

 

       下面这个查询使用到的表： order, order_line, product, catalog 和 price 。有 4 个内连接和一个没有关系（ uncorrelated ）的子查询。

 

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

简直是怪物！（ What a monster! ）。现实生活中（ in real life ），我们对子查询并不是很关心，我们大多数的查询更像下面这样：

 

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

下面这个 查询翻译成 SQL 将需要 2 个内连接和一个相关联的子查询。它用到的表： 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

       如果我映射 tatusChanges 为一个 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 的 isnull （）函数，用到 3 个内连接和 1 个外联接，用大的表： account, payment, payment_status, account_type, organization 和 org_user 。

 

select account, payment

from Account as account

    left outer join account.payments as payment

where :currentUser in elements(account.holder.users)

    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)

order by account.type.sortOrder, account.accountNumber, payment.dueDate

       对于其他的数据库，我们需要使用关联的子查询：

 

select account, payment

from Account as account

    join account.holder.users as user

    left outer join account.payments as payment

where :currentUser = user

    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)

order by account.type.sortOrder, account.accountNumber, payment.dueDate

10.13 提示和窍门

       你可以不用真正的返回查询结果，而知道查询结果的数量：

 

( (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 从句中指定一个查询返回结果尺寸的条件：

 

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

 

上面这个办法因为使用了内连接不能返回拥有 0 个消息的用户的信息，下面这个查询是有用的：

 

select usr.id, usr.name

 

from User as usr

 

    left join usr.messages as msg

 

group by usr.id, usr.name

 

having count(msg) = 0

 

JavaBean 的属性可以作为查询的指定参数被绑定：

 

Query q = s.createQuery("from foo in class Foo where foo.name=:name and foo.size=:size");

 

q.setProperties(fooBean); // fooBean has getName() and getSize()

 

List foos = q.list();

 

集合可以通过使用带有过滤器的 Query 接口实现分页（ pageable ）功能：

 

Query q = s.createFilter( collection, "" ); // the trivial filter

 

q.setMaxResults(PAGE_SIZE);

 

q.setFirstResult(PAGE_SIZE * pageNumber);

 

List page = q.list();

 

使用查询过滤器，可以实现集合元素的排序和分组：

 

Collection orderedCollection = s.filter( collection, "order by this.amount" );

 

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

 

你可以不用对集合进行初始化，就可以得到它的大小：

 

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