如何获得“真实”的体验？ sql 与 hibernate 标准查询不同吗？

Question

我有一个 Hibernate 标准查询，它错误地提取了最大结果。在许多情况下，当我指定 20 个最大结果时，查询实际上只返回 1 或 5 个结果，因为限制会返回许多重复项。

Criteria c = session.createCriteria(DomainObject.class);
c.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
c.createAlias("tags.list", "tag");
c.createAlias("names", "name");
c.createAlias("site", "site");
c.createAlias("site.tags.list", "siteTag");

// loads of or/and eq/like restrictions.

c.setFirstResult(0);
c.setMaxResults(20);

return c.list();

有没有办法修复此查询，以便如果我说 20 个最大结果，它确实会返回 20 个地区结果？ hibernate 将查询限制为 20 个结果，并在之后而不是在数据库级别进行不同的过滤，这似乎非常疯狂。

帮助？

Answer 1

我认为你已经很接近了，你只需要一个不同的 ID 列表，而不是不同的对象。

尝试将此添加到您的标准中：

criteria.setProjection(Projections.distinct(Projections.property("Id")));

这样做的原因是因为
投影将执行
唯一性检查作为 sql 的一部分
查询，而不是什么
ResultTransformer 的作用是
过滤结果的清晰度
sql查询完成后
已执行。

以上是 300491

Answer 2

我从另一个论坛得到这个答案
这似乎是最好的解决方案。基本上，您首先创建一个子查询（DetachedCriteria）。这将获取所有不同的 id。
然后，将该子查询的结果应用于主查询。

由此生成的 SQL 非常干净，并且 hibernate 将结果作为对象列表返回给您。

Criteria criteria = session().createCriteria(Employee.class);
criteria.add(Property.forName("id").in(dc)); 
criteria.setMaxResults(maxLength);
criteria.setFirstResult((int)rowNum);


DetachedCriteria dc = DetachedCriteria.forClass(Employee.class);
dc.createAlias("location", "location");
dc.createAlias("location.dept", "department");
dc.add(
    Restrictions.or(
        Restrictions.eq("location.id", locationId),
        Restrictions.eq("department.name", departmentName)));
dc.setProjection(Projections.distinct(Property.forName("id")));

Answer 3

您是否尝试过在 ID 上使用投影并根据这些结果创建子查询，如 此页面？

编辑：（请注意，Oracle 11.2.0.1.0 中似乎存在 一个错误 如果您正在使用的话，这可能会阻止您获得您想要的结果。）

Answer 4

下面是我们可以通过多重投影来执行 Distinct

    package org.hibernate.criterion;

import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.type.Type;

/**
* A count for style :  count (distinct (a || b || c))
* @author Deepak Surti
*/
public class MultipleCountProjection extends AggregateProjection {

   private boolean distinct;

   protected MultipleCountProjection(String prop) {
      super("count", prop);
   }

   public String toString() {
      if(distinct) {
         return "distinct " + super.toString();
      } else {
         return super.toString();
      }
   }

   public Type[] getTypes(Criteria criteria, CriteriaQuery criteriaQuery) 
   throws HibernateException {
      return new Type[] { Hibernate.INTEGER };
   }

   public String toSqlString(Criteria criteria, int position, CriteriaQuery criteriaQuery) 
   throws HibernateException {
      StringBuffer buf = new StringBuffer();
      buf.append("count(");
      if (distinct) buf.append("distinct ");
        String[] properties = propertyName.split(";");
        for (int i = 0; i < properties.length; i++) {
           buf.append( criteriaQuery.getColumn(criteria, properties[i]) );
             if(i != properties.length - 1) 
                buf.append(" || ");
        }
        buf.append(") as y");
        buf.append(position);
        buf.append('_');
        return buf.toString();
   }

   public MultipleCountProjection setDistinct() {
      distinct = true;
      return this;
   }

}

ExtraProjections.java

package org.hibernate.criterion; 

public final class ExtraProjections
{ 
    public static MultipleCountProjection countMultipleDistinct(String propertyNames) {
        return new MultipleCountProjection(propertyNames).setDistinct();
    }
}

示例用法：

String propertyNames = "titleName;titleDescr;titleVersion"

criteria countCriteria = ....

countCriteria.setProjection(ExtraProjections.countMultipleDistinct(propertyNames);

引用自 https ://forum.hibernate.org/viewtopic.php?t=964506