关联(join)
JPQL
仍然支持和
SQL
中类似的关联语法:
left outjoin/left join
innerjoin
left joinfetch/inner join fetch
left outjoin/left join等,都是允许符合条件的右边表达式中的Entiies为空(
需要显式使用
left join/left outer join
的情况会比较少。
)
例:
//
获取
26
岁人的订单
,
不管
Order
中是否有
OrderItem
select o from Order oleft join o.orderItems whereo.ower.age=26 order by o.orderid
innerjoin 要求右边的表达式必须返回Entities。
例:
//
获取
26
岁人的订单
,Order
中必须要有
OrderItem
select o from Order oinner join o.orderItems whereo.ower.age=26 order by o.orderid
!!重要知识点:在默认的查询中,Entity中的集合属性默认不会被关联,集合属性默认是延迟加载(lazy-load )。那么,left fetch/left out fetch/inner joinfetch提供了一种灵活的查询加载方式来提高查询的性能。
例:
private StringQueryInnerJoinLazyLoad(){
//
默认不关联集合属性变量
(orderItems)
对应的表
Query query =em.createQuery("select o from Order o
inner join
o.orderItems whereo.ower.age=26 order by o.orderid");
List result =query.getResultList();
if(result!=null &&result.size()>0){
//
这时获得Order实体中orderItems(集合属性变量)为空
Order order = (Order)result.get(0);
//
当需要时,EJB3Runtime才会执行一条SQL语句来加载属于当前Order的
//OrderItems
Set<OrderItem>list =
order.getOrderItems
();
Iterator<OrderItem>iterator = list.iterator();
if(iterator.hasNext()){
OrderItem orderItem=iterator.next();
System.out.println("
订购产品名:
"+orderItem.getProductname());
}
}
上面代码在执行
"select o from Order o inner joino.orderItems where o.ower.age=26 order byo.orderid"
时编译成的
SQL
如下(
他不包含集合属性变量
(orderItems)
对应表的字段
)
:
select order0_.orderid asorderid6_, order0_.amount as amount6_, order0_.person_idas
person4_6_,order0_.createdate as createdate6_ from Orders order0_ inner joinOrderItems
orderitems1_ onorder0_.orderid=orderitems1_.order_id, Person person2_where
order0_.person_id=person2_.personid andperson2_.age=26 order by order0_.orderid
上面代码当执行到
Set<OrderItem>list = order.getOrderItems();
时才会执行一条
SQL语句来加载
属于当前
Order
的
OrderItems
,编译成的
SQL
如下
:
select orderitems0_.order_idas order4_1_, orderitems0_.id as id1_, orderitems0_.id asid7_0_,
orderitems0_.order_id asorder4_7_0_, orderitems0_.productname asproductn2_7_0_,
orderitems0_.price asprice7_0_ from OrderItems orderitems0_ whereorderitems0_.order_id=?
order by orderitems0_.idASC
这样的查询性能上有不足的地方
。为了查询
N
个
Order
,我们需要一条
SQL
语句获得所有的
Order
的原始对象属性,但需要另外
N
条语句获得每个
Order
的
orderItems
集合属性。为了避免
N+1的性能问题,我们可以利用joinfetch一次过用一条SQL语句把Order的所有信息查询出来
例子
//
获取
26
岁人的订单
,Order
中必须要有
OrderItem
Query query =em.createQuery("select o from Order o
inner join fetch
o.orderItemswhere
o.ower.age=26order by o.orderid");
上面这句HPQL
编译成以下的
SQL
:
select order0_.orderid asorderid18_0_, orderitems1_.id as id19_1_, order0_.amountas
amount18_0_,order0_.person_idas person4_18_0_, order0_.createdate ascreatedate18_0_,
orderitems1_.order_id
as order4_19_1_, orderitems1_.productname asproductn2_19_1_,
orderitems1_.price
as price19_1_, orderitems1_.order_id as order4_0__,orderitems1_.id asid0__
from Orders order0_ innerjoin OrderItems orderitems1_ on
order0_.orderid=orderitems1_.order_id, Personperson2_ where
order0_.person_id=person2_.personid andperson2_.age=26 order by order0_.orderid,
orderitems1_.idASC
上面由于使用了
fetch,
这个查询只会产生一条
SQL
语句,比原来需要
N+1
条
SQL
语句在性能上有了极大的提升
排除相同的记录DISTINCT
使用关联查询,我们很经常得到重复的对象,如下面语句:
"
select o from Order oinner join fetch o.orderItems order by o.orderid
"
当有
N
个
orderItem
时就会产生
N
个
Order,
而有些
Order
对象往往是相同的,这时我们需要使用
DISTINCT
关键字来排除掉相同的对象
。
例:
select
DISTINCT
o from Ordero inner join fetch o.orderItems order by o.orderid
比较Entity
在查询中使用参数查询时,参数类型除了
String,
原始数据类型
( int, double
等
)
和它们的对象类型
( Integer, Double
等
),
也可以是
Entity
的实例
。
例:
//
查询某人的所有订单
Query query =em.createQuery("select o from Order o where
o.ower=?1
order byo.orderid");
Person person =new Person();
person.setPersonid(newInteger(1));
//
设置查询中的参数
query.setParameter(1,person);
批量更新(Batch Update)
HPQL
支持批量更新
例:
//
把所有订单的金额加
10
Query query =em.createQuery("
update Order as o seto.amount=o.amount+10
");
//update
的记录数
int result =query.
executeUpdate
();
批量删除(Batch Remove)
例:
//
把金额小于100的订单删除,先删除订单子项,再删除订单
Query query=
em
.createQuery(
"delete from OrderItemitem where item.order in(from Order as o whereo.amount<100)"
);
query.
executeUpdate();
query =
em
.createQuery(
"delete from Order as owhere o.amount<100"
);
query.executeUpdate();
//delete
的记录数
使用操作符NOT
//
查询除了指定人之外的所有订单
Query query =em.createQuery("select o from Order o where
not(o.ower=?1)
order byo.orderid");
Person person =new Person();
person.setPersonid(newInteger(2));
//
设置查询中的参数
query.setParameter(1,person);
使用操作符BETWEEN
select o from Order as owhere o.amount between 300 and1000
使用操作符IN
//
查找年龄为
26,21
的
Person
select p from Person as pwhere p.age in(26,21)
使用操作符LIKE
//
查找以字符串
"li"
开头的
Person
select p from Person as pwhere p.name like'li%'
使用操作符IS NULL
//
查询含有购买者的所有
Order
select o from Order as owhere o.ower is [not]null
使用操作符IS EMPTY
ISEMPTY
是针对集合属性
(Collection)
的操作符
。可以和
NOT
一起使用
。
注:低版权的
Mysql
不支持
ISEMPTY
//
查询含有订单项的所有
Order
select o from Order as owhere o.orderItems is [not]empty
使用操作符EXISTS
[NOT]EXISTS
需要和子查询配合使用
。注:低版权的
Mysql
不支持
EXISTS
//
如果存在订单号为
1
的订单,就获取所有
OrderItem
select oi from OrderItem asoi where exists(select o from Order o where o.orderid=1)
//
如果不存在订单号为
10
的订单,就获取
id
为
1
的
OrderItem
select oi from OrderItem asoi where oi.id=1 and notexists (select o from Order o whereo.orderid=10)
字符串函数
JPQL
定义了内置函数方便使用。这些函数的使用方法和
SQL
中相应的函数方法类似。包括:
1. CONCAT
字符串拼接
2. SUBSTRING
字符串截取
3. TRIM
去掉空格
4. LOWER
转换成小写
5. UPPER
装换成大写
6. LENGTH
字符串长度
7. LOCATE
字符串定位
例:
//
查询所有人员,并在姓名后面加上字符串
"_foshan"
select p.personid,concat(p.name, '_foshan') fromPerson as p
//
查询所有人员
,
只取姓名的前三个字符
select p.personid,substring(p.name,1,3) from Personas p
计算函数
HPQL
定义的计算函数包括:
ABS
绝对值
SQRT
平方根
MOD
取余数
SIZE
取集合的数量
例:
//
查询所有
Order
的订单号及其订单项的数量
select o.orderid,size(o.orderItems) from Order as ogroup by o.orderid
//
查询所有
Order
的订单号及其总金额
/10
的余数
select o.orderid,mod(o.amount, 10) from Order aso
子查询
子查询可以用于WHERE和HAVING条件语句中
例:
//
查询年龄为
26
岁的购买者的所有
Order
select o fromOrder as o where o.ower in(select p from Person as p where p.age=26)
结果集分页
有些时候当执行一个查询会返回成千上万条记录,事实上我们只需要显示一部分数据。这时我们需要对结果集进行分页,
QueryAPI
有两个接口方法可以解决这个问题:
setMaxResults() 和setFirstResult()
。
setMaxResults
方法设置获取多少条记录
setFirstResult
方法设置从结果集中的那个索引开始获取
(假如返回的记录有
3
条,容器会自动为记录编上索引,索引从
0
开始,依次为
0
,
1
,
2
)
例:
public
ListgetPersonList(
int
max,
int
whichpage) {
try
{
int
index = (whichpage-1) *max;
Query query =
em
.createQuery(
"from Person p order bypersonid asc"
);
List list =query.
setMaxResults(max)
.
setFirstResult(index)
.
getResultList();
em
.clear();
//
分离内存中受EntityManager管理的实体bean,让VM进行垃圾回收
return
list;
}
catch
(Exception e){
e.printStackTrace();
returnnull
;
}
}