HHH-17639 Make recursive CTE cycle detection emulation independent of collation

beikov · beikov · commit ea7c8c6836a6 · 2024-01-15T06:37:20.000+01:00
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/MariaDBLegacySqlAstTranslator.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/MariaDBLegacySqlAstTranslator.java
@@ -395,4 +395,13 @@ public void visitCastTarget(CastTarget castTarget) {
 			super.visitCastTarget( castTarget );
 		}
 	}
+
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// MariaDB can't cope with NUL characters in the position function, so we use a like predicate instead
+		haystack.accept( this );
+		appendSql( " like concat('%',replace(replace(replace(" );
+		needle.accept( this );
+		appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );
+	}
 }
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/MySQLLegacySqlAstTranslator.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/MySQLLegacySqlAstTranslator.java
@@ -15,6 +15,8 @@
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.internal.util.collections.Stack;
 import org.hibernate.query.sqm.ComparisonOperator;
+import org.hibernate.query.sqm.function.AbstractSqmSelfRenderingFunctionDescriptor;
+import org.hibernate.query.sqm.function.SelfRenderingFunctionSqlAstExpression;
 import org.hibernate.sql.ast.Clause;
 import org.hibernate.sql.ast.spi.AbstractSqlAstTranslator;
 import org.hibernate.sql.ast.tree.MutationStatement;
@@ -414,4 +416,13 @@ public void visitCastTarget(CastTarget castTarget) {
 			super.visitCastTarget( castTarget );
 		}
 	}
+
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// MySQL can't cope with NUL characters in the position function, so we use a like predicate instead
+		haystack.accept( this );
+		appendSql( " like concat('%',replace(replace(replace(" );
+		needle.accept( this );
+		appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );
+	}
 }
diff --git a/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLServerLegacySqlAstTranslator.java b/hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLServerLegacySqlAstTranslator.java
@@ -549,4 +549,15 @@ enum OffsetFetchClauseMode {
 		TOP_ONLY,
 		EMULATED;
 	}
+
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// SQL Server ignores NUL characters in string on case-insensitive collations, so we force a binary collation.
+		// This is needed for the emulation of cycle detection in recursive queries
+		appendSql( "charindex(" );
+		needle.accept( this );
+		appendSql( " collate Latin1_General_100_BIN2," );
+		haystack.accept( this );
+		append( ")>0" );
+	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/MariaDBSqlAstTranslator.java b/hibernate-core/src/main/java/org/hibernate/dialect/MariaDBSqlAstTranslator.java
@@ -384,4 +384,13 @@ public void visitCastTarget(CastTarget castTarget) {
 		}
 	}
 
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// MariaDB can't cope with NUL characters in the position function, so we use a like predicate instead
+		haystack.accept( this );
+		appendSql( " like concat('%',replace(replace(replace(" );
+		needle.accept( this );
+		appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );
+	}
+
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/MySQLSqlAstTranslator.java b/hibernate-core/src/main/java/org/hibernate/dialect/MySQLSqlAstTranslator.java
@@ -448,4 +448,13 @@ public void visitCastTarget(CastTarget castTarget) {
 			super.visitCastTarget( castTarget );
 		}
 	}
+
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// MySQL can't cope with NUL characters in the position function, so we use a like predicate instead
+		haystack.accept( this );
+		appendSql( " like concat('%',replace(replace(replace(" );
+		needle.accept( this );
+		appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );
+	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/SQLServerSqlAstTranslator.java b/hibernate-core/src/main/java/org/hibernate/dialect/SQLServerSqlAstTranslator.java
@@ -16,6 +16,8 @@
 import org.hibernate.query.IllegalQueryOperationException;
 import org.hibernate.query.sqm.ComparisonOperator;
 import org.hibernate.query.sqm.FetchClauseType;
+import org.hibernate.query.sqm.function.AbstractSqmSelfRenderingFunctionDescriptor;
+import org.hibernate.query.sqm.function.SelfRenderingFunctionSqlAstExpression;
 import org.hibernate.sql.ast.Clause;
 import org.hibernate.sql.ast.SqlAstJoinType;
 import org.hibernate.sql.ast.spi.SqlSelection;
@@ -531,4 +533,15 @@ protected void renderMergeStatement(OptionalTableUpdate optionalTableUpdate) {
 		super.renderMergeStatement( optionalTableUpdate );
 		appendSql( ";" );
 	}
+
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// SQL Server ignores NUL characters in string on case-insensitive collations, so we force a binary collation.
+		// This is needed for the emulation of cycle detection in recursive queries
+		appendSql( "charindex(" );
+		needle.accept( this );
+		appendSql( " collate Latin1_General_100_BIN2," );
+		haystack.accept( this );
+		append( ")>0" );
+	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/dialect/TiDBSqlAstTranslator.java b/hibernate-core/src/main/java/org/hibernate/dialect/TiDBSqlAstTranslator.java
@@ -345,4 +345,13 @@ public void visitCastTarget(CastTarget castTarget) {
 			super.visitCastTarget( castTarget );
 		}
 	}
+
+	@Override
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		// TiDB can't cope with NUL characters in the position function, so we use a like predicate instead
+		haystack.accept( this );
+		appendSql( " like concat('%',replace(replace(replace(" );
+		needle.accept( this );
+		appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );
+	}
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/sql/ast/spi/AbstractSqlAstTranslator.java b/hibernate-core/src/main/java/org/hibernate/sql/ast/spi/AbstractSqlAstTranslator.java
@@ -3167,7 +3167,6 @@ private void emulateCycleClauseWithString(SelectClause selectClause) {
 					null,
 					stringType
 			);
-			arguments.add( new QueryLiteral<>( "%", stringType ) );
 			for ( CteColumn cycleColumn : currentCteStatement.getCycleColumns() ) {
 				final int selectionIndex = currentCteStatement.getCteTable()
 						.getCteColumns()
@@ -3190,14 +3189,20 @@ private void emulateCycleClauseWithString(SelectClause selectClause) {
 				arguments.add( nullSeparator );
 			}
 			arguments.add( nullSeparator );
-			arguments.add( new QueryLiteral<>( "%", stringType ) );
 
 			if ( !supportsRecursiveCycleClause() ) {
 				// Cycle mark
 				appendSql( "case when " );
-				visitColumnReference( cyclePathColumnReference );
-				appendSql( " like " );
-				concat.render( this, arguments, stringType, this );
+				renderStringContainsExactlyPredicate(
+						cyclePathColumnReference,
+						new SelfRenderingFunctionSqlAstExpression(
+								"concat",
+								concat,
+								arguments,
+								stringType,
+								stringType
+						)
+				);
 				appendSql( " then " );
 				currentCteStatement.getCycleValue().accept( this );
 				appendSql( " else " );
@@ -3206,9 +3211,8 @@ private void emulateCycleClauseWithString(SelectClause selectClause) {
 				appendSql( COMMA_SEPARATOR );
 			}
 
-			// Remove the wildcard literals
-			arguments.remove( arguments.size() - 1 );
-			arguments.set( 0, cyclePathColumnReference );
+			// Add the previous path
+			arguments.add( 0, cyclePathColumnReference );
 			// Cycle path
 			concat.render( this, arguments, stringType, this );
 		}
@@ -3257,6 +3261,18 @@ private void emulateCycleClauseWithString(SelectClause selectClause) {
 		}
 	}
 
+	protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {
+		final AbstractSqmSelfRenderingFunctionDescriptor position = findSelfRenderingFunction( "position", 2 );
+		new SelfRenderingFunctionSqlAstExpression(
+				"position",
+				position,
+				List.of( needle, haystack ),
+				getStringType(),
+				getStringType()
+		).accept( this );
+		append( ">0" );
+	}
+
 	/**
 	 * Wraps the given expression so that it produces a string, which should have the same ordering as the original value.
 	 * Here are the mappings for various data types:

Original file line number	Diff line number	Diff line change
`@@ -395,4 +395,13 @@ public void visitCastTarget(CastTarget castTarget) {`
`395`	`395`	`super.visitCastTarget( castTarget );`
`396`	`396`	`}`
`397`	`397`	`}`
	`398`	`+`
	`399`	`+ @Override`
	`400`	`+ protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {`
	`401`	`+ // MariaDB can't cope with NUL characters in the position function, so we use a like predicate instead`
	`402`	`+ haystack.accept( this );`
	`403`	`+ appendSql( " like concat('%',replace(replace(replace(" );`
	`404`	`+ needle.accept( this );`
	`405`	`+ appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );`
	`406`	`+ }`
`398`	`407`	`}`
Original file line number	Diff line number	Diff line change
`@@ -384,4 +384,13 @@ public void visitCastTarget(CastTarget castTarget) {`
`384`	`384`	`}`
`385`	`385`	`}`
`386`	`386`
	`387`	`+ @Override`
	`388`	`+ protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {`
	`389`	`+ // MariaDB can't cope with NUL characters in the position function, so we use a like predicate instead`
	`390`	`+ haystack.accept( this );`
	`391`	`+ appendSql( " like concat('%',replace(replace(replace(" );`
	`392`	`+ needle.accept( this );`
	`393`	`+ appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );`
	`394`	`+ }`
	`395`	`+`
`387`	`396`	`}`
Original file line number	Diff line number	Diff line change
`@@ -448,4 +448,13 @@ public void visitCastTarget(CastTarget castTarget) {`
`448`	`448`	`super.visitCastTarget( castTarget );`
`449`	`449`	`}`
`450`	`450`	`}`
	`451`	`+`
	`452`	`+ @Override`
	`453`	`+ protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {`
	`454`	`+ // MySQL can't cope with NUL characters in the position function, so we use a like predicate instead`
	`455`	`+ haystack.accept( this );`
	`456`	`+ appendSql( " like concat('%',replace(replace(replace(" );`
	`457`	`+ needle.accept( this );`
	`458`	`+ appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );`
	`459`	`+ }`
`451`	`460`	`}`
Original file line number	Diff line number	Diff line change
`@@ -345,4 +345,13 @@ public void visitCastTarget(CastTarget castTarget) {`
`345`	`345`	`super.visitCastTarget( castTarget );`
`346`	`346`	`}`
`347`	`347`	`}`
	`348`	`+`
	`349`	`+ @Override`
	`350`	`+ protected void renderStringContainsExactlyPredicate(Expression haystack, Expression needle) {`
	`351`	`+ // TiDB can't cope with NUL characters in the position function, so we use a like predicate instead`
	`352`	`+ haystack.accept( this );`
	`353`	`+ appendSql( " like concat('%',replace(replace(replace(" );`
	`354`	`+ needle.accept( this );`
	`355`	`+ appendSql( ",'~','~~'),'?','~?'),'%','~%'),'%') escape '~'" );`
	`356`	`+ }`
`348`	`357`	`}`