如何使用旧的休眠条件进行批处理?

我仍在使用旧org.hibernate.Criteria，并且对获取模式越来越困惑。在各种查询中，我需要以下所有变体，因此我无法通过注释来控制它。我只是将所有内容都切换到@ManyToOne(fetch=FetchType.LAZY)，否则，不会更改查询中的任何内容。

到目前为止，我能找到的要么涉及 HQL 或 JPA2，要么只提供两种选择，但我需要它用于旧标准和(至少(以下三种情况：

执行 JOIN，并从两个表中获取。这是可以的，除非数据太冗余(例如，主数据很大或在结果中重复多次(。在SQL中，我会写
SELECT * FROM item JOIN order on item.order_id = order.id
WHERE ...;
执行 JOIN，从第一个表中获取，并与另一个表分离。这通常是上一个查询的更有效的变体。在SQL中，我会写
SELECT item.* FROM item JOIN order on item.order_id = order.id
WHERE ...;

SELECT order.* FROM order WHERE ...;
执行 JOIN，但不获取连接的表。例如，这对于基于数据对另一个表进行排序是有用的。在SQL中，我会写
SELECT item.* FROM item JOIN order on item.order_id = order.id
WHERE ...
ORDER BY order.name, item.name;

看起来没有明确指定fetch=FetchType.LAZY，一切都像第一种情况一样被急切地获取，这有时太糟糕了。我想，使用Criteria#setFetchMode，我可以得到第三种情况。我还没有尝试过，因为我仍然错过了第二种情况。我知道这在某种程度上是可能的，因为有@BatchSize注释。

我上面说的对吗？
有没有办法用旧标准获得第二种情况？

更新

看起来使用createAlias()会导致急切地获取所有内容。有一些重载允许指定JoinType，但我需要指定获取类型。现在，我更加困惑了。

是的，您可以使用 FetchType.LAZY、BatchSize、不同的获取模式和投影来满足所有三种情况(请注意，我只是用Restrictions.like("name", "%s%")编造了一个"where"子句，以确保我检索到了很多行(：

执行 JOIN，并从两个表中获取。

由于项的顺序是 FetchType.LAZY，因此默认提取模式将为"SELECT"，因此只需将其设置为"JOIN"即可从联接而不是单独的查询中获取相关的实体数据：

Session session = entityManager.unwrap(org.hibernate.Session.class);
Criteria cr = session.createCriteria(Item.class);
cr.add(Restrictions.like("name", "%s%"));
cr.setFetchMode("order", FetchMode.JOIN);
List results = cr.list();
results.forEach(r -> System.out.println(((Item)r).getOrder().getName()));

生成的单个 SQL 查询：

select
this_.id as id1_0_1_,
this_.name as name2_0_1_,
this_.order_id as order_id3_0_1_,
order2_.id as id1_1_0_,
order2_.name as name2_1_0_ 
from
item_table this_ 
left outer join
order_table order2_ 
on this_.order_id=order2_.id 
where
this_.name like ?

，然后从另一个表中单独获取。

将获取模式保留为默认的"SELECT"，为订单创建一个别名以在排序中使用其列，并使用投影选择所需的列子集，包括外键：

Session session = entityManager.unwrap(org.hibernate.Session.class);
Criteria cr = session.createCriteria(Item.class);
cr.add(Restrictions.like("name", "%s%"));
cr.createAlias("order", "o");
cr.addOrder(org.hibernate.criterion.Order.asc("o.id"));
cr.setProjection(Projections.projectionList()
.add(Projections.property("id"), "id")
.add(Projections.property("name"), "name")
.add(Projections.property("order"), "order"))
.setResultTransformer(org.hibernate.transform.Transformers.aliasToBean(Item.class));
List results = cr.list();
results.forEach(r -> System.out.println(((Item)r).getOrder().getName()));

生成的第一个 SQL 查询：

select
this_.id as y0_,
this_.name as y1_,
this_.order_id as y2_ 
from
item_table this_ 
inner join
order_table o1_ 
on this_.order_id=o1_.id 
where
this_.name like ? 
order by
o1_.id asc

和后续批次(注意我在 Order 类中使用了@BatchSize(value=5)(：

select
order0_.id as id1_1_0_,
order0_.name as name2_1_0_ 
from
order_table order0_ 
where
order0_.id in (
?, ?, ?, ?, ?
)

执行 JOIN，但不获取连接的表。

与前面的情况相同，但不要执行任何操作来提示加载延迟加载的订单：

Session session = entityManager.unwrap(org.hibernate.Session.class);
Criteria cr = session.createCriteria(Item.class);
cr.add(Restrictions.like("name", "%s%"));
cr.createAlias("order", "o");
cr.addOrder(Order.asc("o.id"));
cr.setProjection(Projections.projectionList()
.add(Projections.property("id"), "id")
.add(Projections.property("name"), "name")
.add(Projections.property("order"), "order"))
.setResultTransformer(org.hibernate.transform.Transformers.aliasToBean(Item.class));
List results = cr.list();
results.forEach(r -> System.out.println(((Item)r).getName()));

生成的单个 SQL 查询：

select
this_.id as y0_,
this_.name as y1_,
this_.order_id as y2_ 
from
item_table this_ 
inner join
order_table o1_ 
on this_.order_id=o1_.id 
where
this_.name like ? 
order by
o1_.id asc

我所有案件的实体保持不变：

@Entity
@Table(name = "item_table")
public class Item {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
@ManyToOne(fetch = FetchType.LAZY)
private Order order;
// getters and setters omitted
}
@Entity
@Table(name = "order_table")
@BatchSize(size = 5)
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
// getters and setters omitted
}

更新

相关内容

最新更新

热门标签：