Hibernate 6中自定义SQL函数与谓词的迁移与实现指南

// 部分Hibernate 5 RLikePredicate实现 (仅为示意)
package fr.cstb.doef.dao.expression;

import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.query.criteria.internal.compile.RenderingContext;
import org.hibernate.query.criteria.internal.expression.LiteralExpression;
import org.hibernate.query.criteria.internal.predicate.AbstractSimplePredicate;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.CriteriaBuilder;

public class RLikePredicate extends AbstractSimplePredicate {

    private final Expression<String> matchExpression;
    private final Expression<String> pattern;

    public RLikePredicate(CriteriaBuilder criteriaBuilder, Expression<String> matchExpression, Expression<String> pattern) {
        super((CriteriaBuilderImpl) criteriaBuilder); // 假设CriteriaBuilderImpl可用
        this.matchExpression = matchExpression;
        this.pattern = pattern;
    }

    @Override
    public String render(boolean isNegated, RenderingContext renderingContext) {
        StringBuilder buffer = new StringBuilder();
        // 根据方言判断生成不同的SQL
        if (renderingContext.getDialect() instanceof HSQLDialect) {
            final String operator = isNegated ? " IS NULL" : " IS NOT NULL";
            buffer.append("rlike (")
                  .append(((Renderable) getMatchExpression()).render(renderingContext))
                  .append(",")
                  .append(((Renderable) getPattern()).render(renderingContext)) // 简化处理
                  .append(")").append(operator);
        } else if (renderingContext.getDialect() instanceof MySQLDialect) {
            final String operator = isNegated ? " != 1" : " = 1";
            buffer.append("rlike (")
                  .append(((Renderable) getMatchExpression()).render(renderingContext))
                  .append(",")
                  .append(((Renderable) getPattern()).render(renderingContext)) // 简化处理
                  .append(")").append(operator);
        } else {
            throw new UnsupportedOperationException("Unsupported dialect.");
        }
        return buffer.toString();
    }
    // ... 其他方法
}

// HSQLDialect 示例
public class HSQLIntBooleanDialect extends HSQLDialect {
    public HSQLIntBooleanDialect() {
        super();
        // 注意：这里返回的是INTEGER，但实际需要的是布尔逻辑
        registerFunction("rlike", new SQLFunctionTemplate(StandardBasicTypes.INTEGER, "regexp_substring (?1, ?2) "));
    }
}

// MySQLDialect 示例
public class MySQL5IntBooleanDialect extends MySQL5Dialect {
    public MySQL5IntBooleanDialect() {
        super();
        // 注意：这里返回的是INTEGER，但实际需要的是布尔逻辑
        registerFunction("rlike", new SQLFunctionTemplate(StandardBasicTypes.INTEGER, "(?1 RLIKE ?2)"));
    }
}

package com.example.hibernate6;

import org.hibernate.boot.model.FunctionContributor;
import org.hibernate.boot.model.FunctionContributions;
import org.hibernate.type.StandardBasicTypes;

public class CustomFunctionContributor implements FunctionContributor {

    @Override
    public void contributeFunctions(FunctionContributions functionContributions) {
        // 注册一个名为 "rlike" 的函数
        // "?1 rlike ?2" 是一个模式字符串，表示函数接受两个参数，并以 "rlike" 操作符连接
        // 返回类型指定为 BOOLEAN
        functionContributions.getFunctionRegistry().registerPattern(
            "rlike",
            "?1 rlike ?2",
            functionContributions.getTypeConfiguration().getBasicTypeRegistry().resolve(StandardBasicTypes.BOOLEAN)
        );
    }
}

com.example.hibernate6.CustomFunctionContributor

import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;

// ... 假设你已经有了EntityManager

public class RLikeCriteriaExample {

    public static void main(String[] args) {
        EntityManager em = getEntityManager(); // 获取EntityManager实例

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

        // 使用 criteriaBuilder.function 调用自定义的 "rlike" 函数
        // 并将其结果（布尔值）传递给 criteriaBuilder.isTrue
        cq.where(cb.isTrue(
            cb.function(
                "rlike",
                Boolean.class, // 指定函数返回类型为 Boolean
                from.get("columnName"), // 第一个参数：要匹配的列
                cb.literal(".*regex.*") // 第二个参数：正则表达式字面量
            )
        ));

        TypedQuery<MyEntity> query = em.createQuery(cq);
        query.getResultList().forEach(System.out::println);

        em.close();
    }

    private static EntityManager getEntityManager() {
        // 实际应用中需要配置和获取EntityManagerFactory
        // 这里仅为示例
        return null;
    }
}

import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.function.SQLFunctionTemplate;
import org.hibernate.type.StandardBasicTypes;

public class HSQLCustomDialect extends HSQLDialect {
    public HSQLCustomDialect() {
        super();
        // HSQLDB 使用 regexp_substring，并判断 IS NOT NULL 来模拟布尔结果
        registerFunction("rlike", new SQLFunctionTemplate(StandardBasicTypes.BOOLEAN, "regexp_substring (?1, ?2) IS NOT NULL"));
    }
}

import org.hibernate.dialect.MySQL8Dialect; // 或 MySQL5Dialect
import org.hibernate.dialect.function.SQLFunctionTemplate;
import org.hibernate.type.StandardBasicTypes;

public class MySQLCustomDialect extends MySQL8Dialect {
    public MySQLCustomDialect() {
        super();
        // MySQL 的 RLIKE 操作符本身返回 0 或 1，可以直接作为布尔值处理
        registerFunction("rlike", new SQLFunctionTemplate(StandardBasicTypes.BOOLEAN, "(?1 RLIKE ?2)"));
    }
}

// 用户尝试的Hibernate 6 RLikePredicate 实现 (部分)
public class RLikePredicate extends AbstractNegatableSqmPredicate implements Serializable {
    // ... 构造函数和字段

    @Override
    public <T> T accept(SemanticQueryWalker<T> walker) {
        if (walker instanceof SqmTranslator<?>) {
            Dialect dialect = ((SqmTranslator<?>) walker).getCreationContext().getSessionFactory().getJdbcServices().getDialect();
            if (dialect instanceof HSQLDialect) {
                // HSQL 方言生成 SqmNullnessPredicate
                return walker.visitIsNullPredicate(new SqmNullnessPredicate(function, !isNegated(), nodeBuilder()));
            } else {
                // 其他方言（如 MySQL）生成 SqmComparisonPredicate
                return walker.visitComparisonPredicate(new SqmComparisonPredicate(
                    function,
                    isNegated() ? ComparisonOperator.NOT_EQUAL : ComparisonOperator.EQUAL,
                    nodeBuilder().literal(1),
                    nodeBuilder()
                ));
            }
        }
        return function.accept(walker);
    }
    // ... 其他方法
}