我在服务器日志中收到警告“使用集合提取指定的 firstResult/maxResults；在内存中应用！” . 但是一切正常。但我不想要这个警告。
public employee find(int id) {
return (employee) getEntityManager().createQuery(QUERY).setParameter("id", id).getSingleResult();
}
QUERY = "from employee as emp left join fetch emp.salary left join fetch emp.department where emp.id = :id"
尽管您得到了有效的结果，但 SQL 查询会获取所有数据，但效率并没有达到应有的水平。
所以，你有两个选择。
解决此问题的最简单方法是执行两个查询：
. 第一个查询将获取与提供的过滤条件匹配的根实体标识符。. 第二个查询将使用先前提取的根实体标识符来获取父实体和子实体。
这种方法很容易实现，如下所示：
List<Long> postIds = entityManager
.createQuery(
"select p.id " +
"from Post p " +
"where p.title like :titlePattern " +
"order by p.createdOn", Long.class)
.setParameter(
"titlePattern",
"High-Performance Java Persistence %"
)
.setMaxResults(5)
.getResultList();
List<Post> posts = entityManager
.createQuery(
"select distinct p " +
"from Post p " +
"left join fetch p.comments " +
"where p.id in (:postIds) " +
"order by p.createdOn", Post.class)
.setParameter("postIds", postIds)
.setHint(
"hibernate.query.passDistinctThrough",
false
)
.getResultList();
第二种方法是对匹配我们过滤条件的父子实体的结果集使用 SDENSE_RANK，并仅限制前 N 个帖子条目的输出。
SQL 查询如下所示：
@NamedNativeQuery(
name = "PostWithCommentByRank",
query =
"SELECT * " +
"FROM ( " +
" SELECT *, dense_rank() OVER (ORDER BY \"p.created_on\", \"p.id\") rank " +
" FROM ( " +
" SELECT p.id AS \"p.id\", " +
" p.created_on AS \"p.created_on\", " +
" p.title AS \"p.title\", " +
" pc.id as \"pc.id\", " +
" pc.created_on AS \"pc.created_on\", " +
" pc.review AS \"pc.review\", " +
" pc.post_id AS \"pc.post_id\" " +
" FROM post p " +
" LEFT JOIN post_comment pc ON p.id = pc.post_id " +
" WHERE p.title LIKE :titlePattern " +
" ORDER BY p.created_on " +
" ) p_pc " +
") p_pc_r " +
"WHERE p_pc_r.rank <= :rank ",
resultSetMapping = "PostWithCommentByRankMapping"
)
@SqlResultSetMapping(
name = "PostWithCommentByRankMapping",
entities = {
@EntityResult(
entityClass = Post.class,
fields = {
@FieldResult(name = "id", column = "p.id"),
@FieldResult(name = "createdOn", column = "p.created_on"),
@FieldResult(name = "title", column = "p.title"),
}
),
@EntityResult(
entityClass = PostComment.class,
fields = {
@FieldResult(name = "id", column = "pc.id"),
@FieldResult(name = "createdOn", column = "pc.created_on"),
@FieldResult(name = "review", column = "pc.review"),
@FieldResult(name = "post", column = "pc.post_id"),
}
)
}
)
获取与提供的标题匹配的@NamedNativeQuery所有 Post 实体及其关联的PostComment子实体。DENSE_RANKWindow Function 用于为每个 Post 和 join 记录分配排名，以便PostComment我们稍后可以过滤我们有兴趣获取的 Post 记录的数量。
SqlResultSetMapping提供了 SQL 级别的列别名和需要填充的 JPA 实体属性之间的映射。
现在，我们可以PostWithCommentByRank @NamedNativeQuery这样执行：
List<Post> posts = entityManager
.createNamedQuery("PostWithCommentByRank")
.setParameter(
"titlePattern",
"High-Performance Java Persistence %"
)
.setParameter(
"rank",
5
)
.unwrap(NativeQuery.class)
.setResultTransformer(
new DistinctPostResultTransformer(entityManager)
)
.getResultList();
现在，默认情况下，像这样的原生 SQL 查询PostWithCommentByRank会在同一 JDBC 行中获取 Post 和 the PostComment，所以我们最终会得到一个Object[]包含两个实体的。
但是，我们希望将表格Object[]数组转换为父子实体树，因此，我们需要使用 Hibernate ResultTransformer。
DistinctPostResultTransformer外观如下：
public class DistinctPostResultTransformer
extends BasicTransformerAdapter {
private final EntityManager entityManager;
public DistinctPostResultTransformer(
EntityManager entityManager) {
this.entityManager = entityManager;
}
@Override
public List transformList(
List list) {
Map<Serializable, Identifiable> identifiableMap =
new LinkedHashMap<>(list.size());
for (Object entityArray : list) {
if (Object[].class.isAssignableFrom(entityArray.getClass())) {
Post post = null;
PostComment comment = null;
Object[] tuples = (Object[]) entityArray;
for (Object tuple : tuples) {
if(tuple instanceof Identifiable) {
entityManager.detach(tuple);
if (tuple instanceof Post) {
post = (Post) tuple;
}
else if (tuple instanceof PostComment) {
comment = (PostComment) tuple;
}
else {
throw new UnsupportedOperationException(
"Tuple " + tuple.getClass() + " is not supported!"
);
}
}
}
if (post != null) {
if (!identifiableMap.containsKey(post.getId())) {
identifiableMap.put(post.getId(), post);
post.setComments(new ArrayList<>());
}
if (comment != null) {
post.addComment(comment);
}
}
}
}
return new ArrayList<>(identifiableMap.values());
}
}
必须分离正在获取的DistinctPostResultTransformer实体，因为我们正在覆盖子集合，并且我们不希望它作为实体状态转换传播：
post.setComments(new ArrayList<>());
出现此警告的原因是，当使用 fetch join 时，结果集中的顺序仅由所选实体的 ID 定义（而不是由 join fetched 定义）。
如果内存中的这种排序导致问题，请不要将 firsResult/maxResults 与 JOIN FETCH 一起使用。
为避免此警告，您必须将调用更改getSingleResult为
getResultList().get(0)
此警告告诉您 Hibernate 正在内存中执行 java 分页。这可能会导致高 JVM 内存消耗。由于开发人员可能会错过这个警告，我通过添加一个允许抛出异常而不是记录警告的标志来为 Hibernate 做出贡献（https://hibernate.atlassian.net/browse/HHH-9965）。
该标志是hibernate.query.fail_on_pagination_over_collection_fetch。
我建议大家启用它。
该标志在org.hibernate.cfg.AvailableSettings中定义：
/**
* Raises an exception when in-memory pagination over collection fetch is about to be performed.
* Disabled by default. Set to true to enable.
*
* @since 5.2.13
*/
String FAIL_ON_PAGINATION_OVER_COLLECTION_FETCH = "hibernate.query.fail_on_pagination_over_collection_fetch";
问题是你会得到笛卡尔积做 JOIN。偏移量将减少您的记录集，而无需查看您是否仍在同一根身份类上
我猜 emp 有很多部门，这是一对多的关系。Hibernate 将使用获取的部门记录为该查询获取许多行。因此，在真正将结果提取到内存之前，无法确定结果集的顺序。所以分页将在内存中完成。
如果你不想用emp去获取部门，但仍然想根据部门做一些查询，你可以达到没有警告的结果（不做内存排序）。为此，您必须删除“获取”子句。如下所示：
QUERY = "从员工作为 emp left join emp.salary sal left join emp.department dep where emp.id = :id and dep.name = 'testing' and sal.salary > 5000 "
正如其他人指出的那样，您通常应该避免同时使用“JOIN FETCH”和 firstResult/maxResults。
如果您的查询需要它，您可以使用它.stream()来消除警告并避免潜在的 OOM 异常。
try (Stream<ENTITY> stream = em.createQuery(QUERY).stream()) {
ENTITY first = stream.findFirst().orElse(null); // equivalents .getSingleResult()
}
//Stream返回的是一个需要手动关闭的IO流。