下面是对等价的JPA Criteria Query的解释，
SELECT * 来自TIMESTAMPDIFF（SECOND，setup，released）< 3600的调用;
首先，您必须创建单元表达式并从BasicFunctionExpression扩展它，其中将“SECOND”参数作为单元并仅覆盖其rendor(RenderingContext renderingContext)方法。

import java.io.Serializable;
import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.compile.RenderingContext;
import org.hibernate.query.criteria.internal.expression.function.BasicFunctionExpression;

public class UnitExpression extends BasicFunctionExpression<String> implements Serializable {

  public UnitExpression(CriteriaBuilderImpl criteriaBuilder, Class<String> javaType,
      String functionName) {
    super(criteriaBuilder, javaType, functionName);
  }

  @Override
  public String render(RenderingContext renderingContext) {
    return getFunctionName();
  }
}

字符串
然后在JPA标准查询中使用这个单位表达式。

EntityManager entityManager = emProvider.get();
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
Root<Calls> thingyRoot = query.from(Calls.class);

    Expression<String> second = new UnitExpression(null, String.class, "SECOND");
    Expression<Integer> timeInSec = cb.function(
        "TIMESTAMPDIFF",
        Integer.class,
        second ,
        root.<Timestamp>get("setup"),
        root.<Timestamp>get("release"));
    List<Predicate> conditions = new ArrayList<>();
    conditions.add(cb.lessThan(timeInSec, 3600));
    cq.where(conditions.toArray(new Predicate[]{}));
    return session.createQuery(cq);

型
它起作用了。

我遇到了同样的问题：SECOND将被撇号包围，查询将抛出异常。
我通过以下代码解决了这个问题：

CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery<MyEntity> cq = builder.createQuery( MyEntity.class );
Root<MyEntity> root = cq.from( MyEntity.class );

javax.persistence.criteria.Expression<java.sql.Time> timeDiff = builder.function(
            "TIMEDIFF",
            java.sql.Time.class,
            root.<Date>get( "endDate" ),
            root.<Date>get( "startDate" ) );
javax.persistence.criteria.Expression<Integer> timeToSec = builder.function(
            "TIME_TO_SEC",
            Integer.class,
            timeDiff );

//lessThanOrEqualTo 60 minutes
cq.where( builder.lessThanOrEqualTo( timeToSec, 3600 ) );

return em.createQuery( cq ).getResultList();

字符串
这给了我同样的结果。

CASE WHEN 1=1 THEN TIMESTAMPDIFF(SECOND,startDatetime,endDatetime) ELSE 0 END

字符串
用案例陈述来模拟它。

这里有一个比卡里德·沙阿的更一般的解决方案。
基本上，我们需要的是一个自定义的“opaque literal”Expression类，它能够将任意token表达式（如MONTH、YEAR、INTERVAL 1 DAY等）作为函数参数传递给MySQL：

import javax.persistence.criteria.CriteriaBuilder;

import org.hibernate.query.criteria.internal.CriteriaBuilderImpl;
import org.hibernate.query.criteria.internal.compile.RenderingContext;
import org.hibernate.query.criteria.internal.expression.LiteralExpression;

/**
 * Represents an opaque literal that gets pass through JPA unaltered into SQL.
 */
@SuppressWarnings("serial")
public class OpaqueLiteralExpression extends LiteralExpression<Void> {

    private final String value;

    public OpaqueLiteralExpression(CriteriaBuilderImpl builder, String value) {
        super(builder, Void.class, null);
        if (value == null)
            throw new IllegalArgumentException("null value");
        this.value = value;
    }

// ExpressionImpl

    @Override
    public String render(RenderingContext renderingContext) {
        return this.value;
    }
}

字符串
你可以这样使用它：

final Expression<LocalDate> birthDate = student.get(Student_.birthDate);
final Expression<Integer> age = builder.function("TIMESTAMPDIFF", Integer.class,
  new OpaqueLiteralExpression(builder, "YEAR"), birthDate, LocalDate.now());

型

我在这里遇到了一个类似的问题，但有一个变化- Hibernate 6已经改变了很多，以至于“OpaqueLiteralExpression”答案所建议的内部API不再适用。
我设法解决了这个问题，通过使用原始的Hibernate标准生成器

cb as HibernateCriteriaBuilder
val duration = cb.durationBetween(startTime, endTime)
val overlap = cb.greaterThanOrEqualTo(cb.durationByUnit(TemporalUnit.MINUTE, duration), 10)

字符串