Detect Cypher capabilities correctly.

Prior to this commit, CypherRenderer with Cypher DSL dialects creating
prefixed Cypher statements, like `CYPHER 5 RETURN...`
would not correctly be reported as `elementId` capable renderers.
This led to the situation that there were a missmatch between String-based
elementIds and Cypher using the number-based `id` function.

Closes #3091

Signed-off-by: Gerrit Meier <meistermeier@gmail.com>

Author: meistermeier

src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java

@@ -468,8 +468,8 @@ private <T> T saveImpl(T instance, @Nullable Collection<PropertyFilter.Projected
 		TemplateSupport.FilteredBinderFunction<T> binderFunction = TemplateSupport.createAndApplyPropertyFilter(
 				includedProperties, entityMetaData,
 				this.neo4jMappingContext.getRequiredBinderFunctionFor((Class<T>) entityToBeSaved.getClass()));
-		var statement = this.cypherGenerator.prepareSaveOf(entityMetaData, dynamicLabels,
-				TemplateSupport.rendererRendersElementId(this.renderer));
+		var canUseElementId = TemplateSupport.rendererRendersElementId(this.renderer);
+		var statement = this.cypherGenerator.prepareSaveOf(entityMetaData, dynamicLabels, canUseElementId);
 		Optional<Entity> newOrUpdatedNode = this.neo4jClient.query(() -> this.renderer.render(statement))
 			.bind(entityToBeSaved)
 			.with(binderFunction)
@@ -486,8 +486,7 @@ private <T> T saveImpl(T instance, @Nullable Collection<PropertyFilter.Projected
 		}
 
 		Object elementId = newOrUpdatedNode.map(node -> {
-			if (!entityMetaData.isUsingDeprecatedInternalId()
-					&& TemplateSupport.rendererRendersElementId(this.renderer)) {
+			if (!entityMetaData.isUsingDeprecatedInternalId() && canUseElementId) {
 				return IdentitySupport.getElementId(node);
 			}
 			@SuppressWarnings("deprecation")
@@ -504,7 +503,8 @@ private <T> T saveImpl(T instance, @Nullable Collection<PropertyFilter.Projected
 		}
 
 		stateMachine.markEntityAsProcessed(instance, elementId);
-		processRelations(entityMetaData, propertyAccessor, isEntityNew, stateMachine, binderFunction.filter);
+		processRelations(entityMetaData, propertyAccessor, isEntityNew, stateMachine, binderFunction.filter,
+				canUseElementId);
 
 		T bean = propertyAccessor.getBean();
 		stateMachine.markAsAliased(instance, bean);
@@ -648,7 +648,8 @@ class Tuple3<T> {
 					TemplateSupport.computeIncludePropertyPredicate(
 							((includedProperties != null && !includedProperties.isEmpty()) || includeProperty != null)
 									? pps : includedPropertiesByClass.get(t.modifiedInstance.getClass()),
-							entityMetaData));
+							entityMetaData),
+					TemplateSupport.rendererRendersElementId(this.renderer));
 		}).collect(Collectors.toList());
 	}
 
@@ -856,24 +857,26 @@ private <T> ExecutableQuery<T> createExecutableQuery(Class<T> domainType, @Nulla
 	 * @param stateMachine initial state of entity processing
 	 * @param includeProperty a predicate telling to include a relationship property or
 	 * not
+	 * @param canUseElementId flag if the Cypher DSL renderer supports elementId function
 	 * @param <T> the type of the object being initially processed
 	 * @return the owner of the relations being processed
 	 */
 	private <T> T processRelations(Neo4jPersistentEntity<?> neo4jPersistentEntity,
 			PersistentPropertyAccessor<?> parentPropertyAccessor, boolean isParentObjectNew,
-			NestedRelationshipProcessingStateMachine stateMachine, PropertyFilter includeProperty) {
+			NestedRelationshipProcessingStateMachine stateMachine, PropertyFilter includeProperty,
+			boolean canUseElementId) {
 
 		PropertyFilter.RelaxedPropertyPath startingPropertyPath = PropertyFilter.RelaxedPropertyPath
 			.withRootType(neo4jPersistentEntity.getUnderlyingClass());
 		return processNestedRelations(neo4jPersistentEntity, parentPropertyAccessor, isParentObjectNew, stateMachine,
-				includeProperty, startingPropertyPath);
+				includeProperty, canUseElementId, startingPropertyPath);
 	}
 
 	@SuppressWarnings("deprecation")
 	private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity,
 			PersistentPropertyAccessor<?> propertyAccessor, boolean isParentObjectNew,
 			NestedRelationshipProcessingStateMachine stateMachine, PropertyFilter includeProperty,
-			PropertyFilter.RelaxedPropertyPath previousPath) {
+			boolean canUseElementId, PropertyFilter.RelaxedPropertyPath previousPath) {
 
 		Object fromId = propertyAccessor.getProperty(sourceEntity.getRequiredIdProperty());
 
@@ -921,7 +924,6 @@ private <T> T processNestedRelations(Neo4jPersistentEntity<?> sourceEntity,
 			// has not been processed before.
 			// This avoids the usage of cache but might have significant impact on overall
 			// performance
-			boolean canUseElementId = TemplateSupport.rendererRendersElementId(this.renderer);
 			if (!isParentObjectNew && !stateMachine.hasProcessedRelationship(fromId, relationshipDescription)) {
 
 				List<Object> knownRelationshipsIds = new ArrayList<>();
@@ -1121,7 +1123,7 @@ else if (relationshipDescription.hasRelationshipProperties() && fromId != null)
 
 				if (processState != ProcessState.PROCESSED_ALL_VALUES) {
 					processNestedRelations(targetEntity, targetPropertyAccessor, isNewEntity, stateMachine,
-							includeProperty, currentPropertyPath);
+							includeProperty, canUseElementId, currentPropertyPath);
 				}
 
 				Object potentiallyRecreatedNewRelatedObject = MappingSupport

src/main/java/org/springframework/data/neo4j/core/TemplateSupport.java

@@ -341,7 +341,7 @@ static boolean rendererCanUseElementIdIfPresent(Renderer renderer, Neo4jPersiste
 
 	static boolean rendererRendersElementId(Renderer renderer) {
 		return renderer.render(Cypher.returning(Cypher.elementId(Cypher.anyNode("n"))).build())
-			.equals("RETURN elementId(n)");
+			.endsWith("RETURN elementId(n)");
 	}
 
 	public static String convertIdOrElementIdToString(Object value) {

src/test/java/org/springframework/data/neo4j/core/TemplateSupportTests.java

@@ -17,8 +17,16 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.stream.Stream;
 
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.neo4j.cypherdsl.core.renderer.Configuration;
+import org.neo4j.cypherdsl.core.renderer.Dialect;
+import org.neo4j.cypherdsl.core.renderer.Renderer;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -99,6 +107,41 @@ void shouldNotFindCommonElementTypeWhenThereIsNone() {
 		assertThat(type).isNull();
 	}
 
+	@Nested
+	class CypherRendering {
+
+		@ParameterizedTest
+		@MethodSource("createSupportedCypherRenderers")
+		void rendersElementId(Renderer renderer, boolean supportsElementId) {
+			assertThat(TemplateSupport.rendererRendersElementId(renderer)).isEqualTo(supportsElementId);
+		}
+
+		static Stream<Arguments> createSupportedCypherRenderers() {
+			return Stream.of(Arguments
+				.arguments(Renderer.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_4).build()), false),
+					Arguments.arguments(
+							Renderer.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_5).build()), true),
+					Arguments.arguments(
+							Renderer.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_5_23).build()),
+							true),
+					Arguments.arguments(
+							Renderer.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_5_26).build()),
+							true),
+					Arguments.arguments(
+							Renderer.getRenderer(
+									Configuration.newConfig().withDialect(Dialect.NEO4J_5_DEFAULT_CYPHER).build()),
+							true),
+					Arguments.arguments(Renderer
+						.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_5_CYPHER_5).build()), true),
+					Arguments.arguments(Renderer
+						.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_5_CYPHER_25).build()), true),
+					Arguments.arguments(
+							Renderer.getRenderer(Configuration.newConfig().withDialect(Dialect.NEO4J_2025).build()),
+							true));
+		}
+
+	}
+
 	interface IA {
 
 	}