GH-2273 - Allow function calls in Sort / Pageable objects in custom queries.

This closes #2273.

Author: michael-simons

src/main/java/org/springframework/data/neo4j/core/mapping/CypherGenerator.java

@@ -30,6 +30,7 @@
 import java.util.List;
 import java.util.function.Predicate;
 import java.util.function.UnaryOperator;
+import java.util.regex.Pattern;
 
 import org.apiguardian.api.API;
 import org.neo4j.cypherdsl.core.Condition;
@@ -76,6 +77,7 @@ public enum CypherGenerator {
 	private static final SymbolicName END_NODE_NAME = Cypher.name("endNode");
 
 	private static final SymbolicName RELATIONSHIP_NAME = Cypher.name("relProps");
+	private static final Pattern LOOKS_LIKE_A_FUNCTION = Pattern.compile(".+\\(.*\\)");
 
 	/**
 	 * @param nodeDescription The node description for which a match clause should be generated
@@ -466,12 +468,13 @@ public Expression[] createReturnStatementForMatch(NodeDescription<?> nodeDescrip
 		if (sort == null || sort.isUnsorted()) {
 			return null;
 		}
-
-		Statement statement = Cypher.match(Cypher.anyNode()).returning("n")
-				.orderBy(sort.stream().filter(order -> order != null).map(order -> {
-					String property = order.getProperty();
+		Statement statement = match(anyNode()).returning("n")
+				.orderBy(sort.stream().filter(order -> order != null && order.getProperty() != null).map(order -> {
+					String property = order.getProperty().trim();
 					Expression expression;
-					if (property.contains(".")) {
+					if (LOOKS_LIKE_A_FUNCTION.matcher(property).matches()) {
+						expression = Cypher.raw(property);
+					} else if (property.contains(".")) {
 						String[] path = property.split("\\.");
 						if (path.length != 2) {
 							throw new IllegalArgumentException(String.format(

src/test/java/org/springframework/data/neo4j/core/mapping/CypherGeneratorTest.java

@@ -15,10 +15,22 @@
  */
 package org.springframework.data.neo4j.core.mapping;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
 import org.junit.Assert;
 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.CsvSource;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mockito;
 import org.neo4j.cypherdsl.core.Cypher;
@@ -28,17 +40,6 @@
 import org.springframework.data.neo4j.core.schema.Id;
 import org.springframework.data.neo4j.core.schema.Node;
 
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
-import java.util.regex.Pattern;
-import java.util.stream.Stream;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.when;
-
 /**
  * @author Davide Fantuzzi
  * @author Andrea Santurbano
@@ -175,10 +176,29 @@ void shouldFailOnInvalidPathWithMultipleHops() {
 				.withMessageMatching("Cannot handle order property `.*`, it must be a simple property or one-hop path\\.");
 	}
 
+	@CsvSource(delimiterString = "|", value = {
+			"apoc.text.clean(department.name)   |false| ORDER BY apoc.text.clean(department.name) ASC",
+			"apoc.text.clean(department.name)   |true | ORDER BY apoc.text.clean(department.name) DESC",
+			"apoc.text.clean()                  |true | ORDER BY apoc.text.clean() DESC",
+			"date()                             |false| ORDER BY date() ASC",
+			"date({year:1984, month:10, day:11})|false| ORDER BY date({year:1984, month:10, day:11}) ASC",
+			"round(3.141592, 3)                 |false| ORDER BY round(3.141592, 3) ASC"
+	})
+	@ParameterizedTest // GH-2273
+	void functionCallsShouldWork(String input, boolean descending, String expected) {
+
+		Sort sort = Sort.by(input);
+		if (descending) {
+			sort = sort.descending();
+		}
+		String orderByFragment = CypherGenerator.INSTANCE.createOrderByFragment(sort);
+		assertThat(orderByFragment).isEqualTo(expected);
+	}
+
 	@Test
 	void shouldFailOnInvalidSymbolicNames() {
 
-		assertThatIllegalArgumentException().isThrownBy(() -> CypherGenerator.INSTANCE.createOrderByFragment(Sort.by("n()")))
+		assertThatIllegalArgumentException().isThrownBy(() -> CypherGenerator.INSTANCE.createOrderByFragment(Sort.by("()")))
 				.withMessage("Name must be a valid identifier.");
 	}