HHH-3404 Add regexp_like support for HANA, Oracle and SQL Server

beikov · beikov · commit 0f03fd6b94ec · 2025-08-21T11:34:17.000+02:00
Also cleanup the tests and make case-insensitive regexp_like work with lower function if needed
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HANALegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HANALegacyDialect.java
@@ -529,6 +529,8 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 
 //			functionFactory.xmlextract();
 		}
+
+		functionFactory.regexpLike_like_regexp();
 	}
 
 	/**
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HSQLLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/HSQLLegacyDialect.java
@@ -292,6 +292,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 				functionContributions.getTypeConfiguration(),
 				SqlAstNodeRenderingMode.NO_PLAIN_PARAMETER
 		) );
+		functionFactory.regexpLike_hsql();
 	}
 
 	/**
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/InformixDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/InformixDialect.java
@@ -16,6 +16,7 @@
 import org.hibernate.boot.model.FunctionContributions;
 import org.hibernate.boot.model.TypeContributions;
 import org.hibernate.boot.model.relational.SqlStringGenerationContext;
+import org.hibernate.community.dialect.function.InformixRegexpLikeFunction;
 import org.hibernate.community.dialect.identity.InformixIdentityColumnSupport;
 import org.hibernate.community.dialect.pagination.FirstLimitHandler;
 import org.hibernate.community.dialect.pagination.SkipFirstLimitHandler;
@@ -411,11 +412,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 		functionContributions.getFunctionRegistry().register( "trim",
 				new TrimFunction( this, typeConfiguration, SqlAstNodeRenderingMode.NO_UNTYPED ) );
 
-		//TODO: emulate support for the 'i' flag argument
-		functionRegistry.namedDescriptorBuilder( "regexp_like", "regex_match"  )
-				.setParameterTypes( STRING, STRING )
-				.setInvariantType( booleanBasicType )
-				.register();
+		functionRegistry.register( "regexp_like", new InformixRegexpLikeFunction(  typeConfiguration ) );
 	}
 
 	@Override
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/OracleLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/OracleLegacyDialect.java
@@ -375,6 +375,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 
 		functionFactory.unnest_oracle();
 		functionFactory.generateSeries_recursive( getMaximumSeriesSize(), true, false );
+		functionFactory.regexpLike_predicateFunction();
 	}
 
 	/**
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLServerLegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLServerLegacyDialect.java
@@ -521,6 +521,13 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 				functionFactory.generateSeries_recursive( getMaximumSeriesSize(), false, false );
 			}
 		}
+		if ( getVersion().isBefore( 17 ) ) {
+			// Before SQL Server 2025, this function wasn't supported
+			functionContributions.getFunctionRegistry().removeFunctionDescriptor( "regexp_like" );
+		}
+		else {
+			functionFactory.regexpLike_predicateFunction();
+		}
 	}
 
 	/**
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseASELegacyDialect.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SybaseASELegacyDialect.java
@@ -173,6 +173,8 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 		functionFactory.unnest_sybasease();
 		functionFactory.generateSeries_sybasease( getMaximumSeriesSize() );
 		functionFactory.xmltable_sybasease();
+		// Sybase ASE does not support this function
+		functionContributions.getFunctionRegistry().removeFunctionDescriptor( "regexp_like" );
 	}
 
 	/**
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/InformixRegexpLikeFunction.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/function/InformixRegexpLikeFunction.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.community.dialect.function;
+
+import org.hibernate.dialect.function.AbstractRegexpLikeFunction;
+import org.hibernate.metamodel.model.domain.ReturnableType;
+import org.hibernate.sql.ast.SqlAstTranslator;
+import org.hibernate.sql.ast.spi.SqlAppender;
+import org.hibernate.sql.ast.tree.SqlAstNode;
+import org.hibernate.sql.ast.tree.expression.Literal;
+import org.hibernate.type.spi.TypeConfiguration;
+
+import java.util.List;
+
+
+/**
+ * Informix has special integer constants as third argument.
+ */
+public class InformixRegexpLikeFunction extends AbstractRegexpLikeFunction {
+
+	public InformixRegexpLikeFunction(TypeConfiguration typeConfiguration) {
+		super( typeConfiguration );
+	}
+
+	@Override
+	public void render(
+			SqlAppender sqlAppender,
+			List<? extends SqlAstNode> arguments,
+			ReturnableType<?> returnType,
+			SqlAstTranslator<?> walker) {
+		final boolean caseSensitive;
+		if ( arguments.size() > 2 ) {
+			if ( !(arguments.get( 2 ) instanceof Literal literal)
+				|| !(literal.getLiteralValue() instanceof String flags)
+				|| !flags.equals( "i" ) ) {
+				throw new IllegalArgumentException( "Informix only supports the case insensitive flag 'i' as literal but got." );
+			}
+			caseSensitive = false;
+		}
+		else {
+			caseSensitive = true;
+		}
+
+		sqlAppender.appendSql( "regex_match(" );
+		arguments.get( 0 ).accept( walker );
+		sqlAppender.appendSql( ',' );
+		arguments.get( 1 ).accept( walker );
+		if ( !caseSensitive ) {
+			// 1 is extended POSIX regex which is the default, 3 is extended POSIX regex and case-insensitive
+			// See https://www.ibm.com/docs/en/informix-servers/14.10.0?topic=routines-regex-match-function
+			sqlAppender.appendSql( ",3" );
+		}
+		sqlAppender.appendSql( ')' );
+	}
+
+	@Override
+	public boolean isPredicate() {
+		return false;
+	}
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/HANADialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/HANADialect.java
@@ -533,6 +533,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 		functionFactory.hex( "bintohex(?1)" );
 		functionFactory.sha( "hash_sha256(to_binary(?1))" );
 		functionFactory.md5( "hash_md5(to_binary(?1))" );
+		functionFactory.regexpLike_like_regexp();
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/HSQLDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/HSQLDialect.java
@@ -239,6 +239,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 		) );
 
 		functionFactory.hex( "hex(?1)" );
+		functionFactory.regexpLike_hsql();
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java
@@ -434,6 +434,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 				"extract",
 				new OracleExtractFunction( this, typeConfiguration )
 		);
+		functionFactory.regexpLike_predicateFunction();
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/SQLServerDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/SQLServerDialect.java
@@ -496,6 +496,13 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 		functionFactory.hex( "convert(varchar(MAX), ?1, 2)" );
 		functionFactory.sha( "hashbytes('SHA2_256', ?1)" );
 		functionFactory.md5( "hashbytes('MD5', ?1)" );
+		if ( getVersion().isBefore( 17 ) ) {
+			// Before SQL Server 2025, this function wasn't supported
+			functionContributions.getFunctionRegistry().removeFunctionDescriptor( "regexp_like" );
+		}
+		else {
+			functionFactory.regexpLike_predicateFunction();
+		}
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/SybaseASEDialect.java b/hibernate-core/src/main/java/org/hibernate/dialect/SybaseASEDialect.java
@@ -188,6 +188,8 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio
 		functionFactory.unnest_sybasease();
 		functionFactory.generateSeries_sybasease( getMaximumSeriesSize() );
 		functionFactory.xmltable_sybasease();
+		// Sybase ASE does not support this function
+		functionContributions.getFunctionRegistry().removeFunctionDescriptor( "regexp_like" );
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/AbstractRegexpLikeFunction.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/AbstractRegexpLikeFunction.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.dialect.function;
+
+import org.hibernate.query.sqm.function.AbstractSqmSelfRenderingFunctionDescriptor;
+import org.hibernate.query.sqm.produce.function.ArgumentTypesValidator;
+import org.hibernate.query.sqm.produce.function.StandardArgumentsValidators;
+import org.hibernate.query.sqm.produce.function.StandardFunctionArgumentTypeResolvers;
+import org.hibernate.query.sqm.produce.function.StandardFunctionReturnTypeResolvers;
+import org.hibernate.type.StandardBasicTypes;
+import org.hibernate.type.spi.TypeConfiguration;
+
+import static org.hibernate.query.sqm.produce.function.FunctionParameterType.STRING;
+
+/**
+ * Base implementation for the regexp_like predicate.
+ */
+public abstract class AbstractRegexpLikeFunction extends AbstractSqmSelfRenderingFunctionDescriptor {
+
+	public AbstractRegexpLikeFunction(TypeConfiguration typeConfiguration) {
+		super(
+				"regexp_like",
+				new ArgumentTypesValidator( StandardArgumentsValidators.between( 2, 3 ), STRING, STRING, STRING ),
+				StandardFunctionReturnTypeResolvers.invariant( typeConfiguration.getBasicTypeRegistry().resolve(
+						StandardBasicTypes.BOOLEAN ) ),
+				StandardFunctionArgumentTypeResolvers.invariant( typeConfiguration, STRING, STRING, STRING )
+		);
+	}
+
+	@Override
+	public String getSignature(String name) {
+		return "(STRING string, STRING pattern[, STRING flags])";
+	}
+
+	@Override
+	public boolean isPredicate() {
+		return true;
+	}
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/CommonFunctionFactory.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/CommonFunctionFactory.java
@@ -2677,10 +2677,28 @@ public void regexpLike() {
 	 * For MariaDB
 	 */
 	public void regexpLike_regexp() {
-		functionRegistry.patternDescriptorBuilder( "regexp_like", "?1 regexp ?2" )
-				.setParameterTypes( STRING, STRING )
-				.setInvariantType( booleanType )
-				.register();
+		functionRegistry.register( "regexp_like", new MariaDBRegexpLikeFunction( typeConfiguration ) );
+	}
+
+	/**
+	 * For HSQLDB
+	 */
+	public void regexpLike_hsql() {
+		functionRegistry.register( "regexp_like", new HSQLRegexpLikeFunction( typeConfiguration ) );
+	}
+
+	/**
+	 * For Oracle and SQL Server
+	 */
+	public void regexpLike_predicateFunction() {
+		functionRegistry.register( "regexp_like", new RegexpLikePredicateFunction( typeConfiguration ) );
+	}
+
+	/**
+	 * For SAP HANA
+	 */
+	public void regexpLike_like_regexp() {
+		functionRegistry.register( "regexp_like", new HANARegexpLikeFunction( typeConfiguration ) );
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/HANARegexpLikeFunction.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/HANARegexpLikeFunction.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.dialect.function;
+
+import org.hibernate.metamodel.model.domain.ReturnableType;
+import org.hibernate.sql.ast.SqlAstTranslator;
+import org.hibernate.sql.ast.spi.SqlAppender;
+import org.hibernate.sql.ast.tree.SqlAstNode;
+import org.hibernate.type.spi.TypeConfiguration;
+
+import java.util.List;
+
+
+/**
+ * HANA has a special predicate.
+ */
+public class HANARegexpLikeFunction extends AbstractRegexpLikeFunction {
+
+	public HANARegexpLikeFunction(TypeConfiguration typeConfiguration) {
+		super( typeConfiguration );
+	}
+
+	@Override
+	public void render(
+			SqlAppender sqlAppender,
+			List<? extends SqlAstNode> arguments,
+			ReturnableType<?> returnType,
+			SqlAstTranslator<?> walker) {
+		arguments.get( 0 ).accept( walker );
+		sqlAppender.appendSql( " like_regexpr " );
+		arguments.get( 1 ).accept( walker );
+		if ( arguments.size() > 2 ) {
+			sqlAppender.appendSql( " flag " );
+			arguments.get( 2 ).accept( walker );
+		}
+	}
+
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/HSQLRegexpLikeFunction.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/HSQLRegexpLikeFunction.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.dialect.function;
+
+import org.hibernate.metamodel.model.domain.ReturnableType;
+import org.hibernate.sql.ast.SqlAstTranslator;
+import org.hibernate.sql.ast.spi.SqlAppender;
+import org.hibernate.sql.ast.tree.SqlAstNode;
+import org.hibernate.sql.ast.tree.expression.Literal;
+import org.hibernate.type.spi.TypeConfiguration;
+
+import java.util.List;
+
+
+/**
+ * HSQLDB doesn't support the third argument.
+ */
+public class HSQLRegexpLikeFunction extends AbstractRegexpLikeFunction {
+
+	public HSQLRegexpLikeFunction(TypeConfiguration typeConfiguration) {
+		super( typeConfiguration );
+	}
+
+	@Override
+	public void render(
+			SqlAppender sqlAppender,
+			List<? extends SqlAstNode> arguments,
+			ReturnableType<?> returnType,
+			SqlAstTranslator<?> walker) {
+		final boolean caseSensitive;
+		if ( arguments.size() > 2 ) {
+			if ( !(arguments.get( 2 ) instanceof Literal literal)
+				|| !(literal.getLiteralValue() instanceof String flags)
+				|| !flags.equals( "i" ) ) {
+				throw new IllegalArgumentException( "HSQLDB only supports the case insensitive flag 'i' as literal but got." );
+			}
+			caseSensitive = false;
+		}
+		else {
+			caseSensitive = true;
+		}
+
+		sqlAppender.appendSql( "regexp_like(" );
+		if ( !caseSensitive ) {
+			sqlAppender.appendSql( "lower(" );
+		}
+		arguments.get( 0 ).accept( walker );
+		if ( !caseSensitive ) {
+			sqlAppender.appendSql( ')' );
+		}
+		sqlAppender.appendSql( ',' );
+		if ( !caseSensitive ) {
+			sqlAppender.appendSql( "lower(" );
+		}
+		arguments.get( 1 ).accept( walker );
+		if ( !caseSensitive ) {
+			sqlAppender.appendSql( ')' );
+		}
+		sqlAppender.appendSql( ')' );
+	}
+
+	@Override
+	public boolean isPredicate() {
+		return false;
+	}
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/MariaDBRegexpLikeFunction.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/MariaDBRegexpLikeFunction.java
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/function/RegexpLikePredicateFunction.java b/hibernate-core/src/main/java/org/hibernate/dialect/function/RegexpLikePredicateFunction.java
diff --git a/hibernate-core/src/main/java/org/hibernate/query/sqm/function/SqmFunctionRegistry.java b/hibernate-core/src/main/java/org/hibernate/query/sqm/function/SqmFunctionRegistry.java
diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/RegexTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/query/hql/RegexTest.java
diff --git a/hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java b/hibernate-testing/src/main/java/org/hibernate/testing/orm/junit/DialectFeatureChecks.java

Original file line number	Diff line number	Diff line change
`@@ -529,6 +529,8 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`529`	`529`
`530`	`530`	`// functionFactory.xmlextract();`
`531`	`531`	`}`
	`532`	`+`
	`533`	`+ functionFactory.regexpLike_like_regexp();`
`532`	`534`	`}`
`533`	`535`
`534`	`536`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -292,6 +292,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`292`	`292`	`functionContributions.getTypeConfiguration(),`
`293`	`293`	`SqlAstNodeRenderingMode.NO_PLAIN_PARAMETER`
`294`	`294`	`) );`
	`295`	`+ functionFactory.regexpLike_hsql();`
`295`	`296`	`}`
`296`	`297`
`297`	`298`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -375,6 +375,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`375`	`375`
`376`	`376`	`functionFactory.unnest_oracle();`
`377`	`377`	`functionFactory.generateSeries_recursive( getMaximumSeriesSize(), true, false );`
	`378`	`+ functionFactory.regexpLike_predicateFunction();`
`378`	`379`	`}`
`379`	`380`
`380`	`381`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -521,6 +521,13 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`521`	`521`	`functionFactory.generateSeries_recursive( getMaximumSeriesSize(), false, false );`
`522`	`522`	`}`
`523`	`523`	`}`
	`524`	`+ if ( getVersion().isBefore( 17 ) ) {`
	`525`	`+ // Before SQL Server 2025, this function wasn't supported`
	`526`	`+ functionContributions.getFunctionRegistry().removeFunctionDescriptor( "regexp_like" );`
	`527`	`+ }`
	`528`	`+ else {`
	`529`	`+ functionFactory.regexpLike_predicateFunction();`
	`530`	`+ }`
`524`	`531`	`}`
`525`	`532`
`526`	`533`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -173,6 +173,8 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`173`	`173`	`functionFactory.unnest_sybasease();`
`174`	`174`	`functionFactory.generateSeries_sybasease( getMaximumSeriesSize() );`
`175`	`175`	`functionFactory.xmltable_sybasease();`
	`176`	`+ // Sybase ASE does not support this function`
	`177`	`+ functionContributions.getFunctionRegistry().removeFunctionDescriptor( "regexp_like" );`
`176`	`178`	`}`
`177`	`179`
`178`	`180`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -533,6 +533,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`533`	`533`	`functionFactory.hex( "bintohex(?1)" );`
`534`	`534`	`functionFactory.sha( "hash_sha256(to_binary(?1))" );`
`535`	`535`	`functionFactory.md5( "hash_md5(to_binary(?1))" );`
	`536`	`+ functionFactory.regexpLike_like_regexp();`
`536`	`537`	`}`
`537`	`538`
`538`	`539`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -239,6 +239,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`239`	`239`	`) );`
`240`	`240`
`241`	`241`	`functionFactory.hex( "hex(?1)" );`
	`242`	`+ functionFactory.regexpLike_hsql();`
`242`	`243`	`}`
`243`	`244`
`244`	`245`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -434,6 +434,7 @@ public void initializeFunctionRegistry(FunctionContributions functionContributio`
`434`	`434`	`"extract",`
`435`	`435`	`new OracleExtractFunction( this, typeConfiguration )`
`436`	`436`	`);`
	`437`	`+ functionFactory.regexpLike_predicateFunction();`
`437`	`438`	`}`
`438`	`439`
`439`	`440`	`/**`