support conversion for ValueFunction

Author: schauder

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/QueryMapper.java

@@ -310,7 +310,7 @@ private Condition mapCondition(CriteriaDefinition criteria, MapSqlParameterSourc
 			sqlType = getTypeHint(mappedValue, actualType.getType(), settableValue);
 		} else if (criteria.getValue() instanceof ValueFunction valueFunction) {
 
-			mappedValue = valueFunction;
+			mappedValue = valueFunction.transform(v -> convertValue(comparator, v, propertyField.getTypeHint()));
 			sqlType = propertyField.getSqlType();
 
 		} else if (propertyField instanceof MetadataBackedField metadataBackedField //

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/EscapingParameterSource.java

@@ -45,8 +45,8 @@ public boolean hasValue(String paramName) {
 	public Object getValue(String paramName) throws IllegalArgumentException {
 
 		Object value = parameterSource.getValue(paramName);
-		if (value instanceof ValueFunction<?>) {
-			return ((ValueFunction<?>) value).apply(escaper);
+		if (value instanceof ValueFunction<?> valueFunction) {
+			return valueFunction.apply(escaper);
 		}
 		return value;
 	}

spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/query/QueryMapper.java

@@ -373,12 +373,10 @@ private Condition mapCondition(CriteriaDefinition criteria, MutableBindings bind
 
 			mappedValue = convertValue(comparator, parameter.getValue(), propertyField.getTypeHint());
 			typeHint = getTypeHint(mappedValue, actualType.getType(), parameter);
-		} else if (criteria.getValue() instanceof ValueFunction) {
+		} else if (criteria.getValue() instanceof ValueFunction<?> valueFunction) {
 
-			ValueFunction<Object> valueFunction = (ValueFunction<Object>) criteria.getValue();
-			Object value = valueFunction.apply(getEscaper(comparator));
+			mappedValue = valueFunction.transform(v -> convertValue(comparator, v, propertyField.getTypeHint())).apply(getEscaper(comparator));
 
-			mappedValue = convertValue(comparator, value, propertyField.getTypeHint());
 			typeHint = actualType.getType();
 		} else {
 

spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/query/UpdateMapper.java

@@ -111,18 +111,14 @@ private Assignment getAssignment(SqlIdentifier columnName, Object value, Mutable
 		Object mappedValue;
 		Class<?> typeHint;
 
-		if (value instanceof Parameter) {
-
-			Parameter parameter = (Parameter) value;
+		if (value instanceof Parameter parameter) {
 
 			mappedValue = convertValue(parameter.getValue(), propertyField.getTypeHint());
 			typeHint = getTypeHint(mappedValue, actualType.getType(), parameter);
 
-		} else if (value instanceof ValueFunction) {
-
-			ValueFunction<Object> valueFunction = (ValueFunction<Object>) value;
+		} else if (value instanceof ValueFunction<?> valueFunction) {
 
-			mappedValue = convertValue(valueFunction.apply(Escaper.DEFAULT), propertyField.getTypeHint());
+			mappedValue = valueFunction.transform(v -> convertValue(v, propertyField.getTypeHint())).apply(Escaper.DEFAULT);
 
 			if (mappedValue == null) {
 				return Assignments.value(column, SQL.nullLiteral());

spring-data-relational/src/main/java/org/springframework/data/relational/core/query/ValueFunction.java

@@ -56,4 +56,16 @@ default Supplier<T> toSupplier(Escaper escaper) {
 
 		return () -> apply(escaper);
 	}
+
+	/**
+	 * Transforms the inner value of the ValueFunction using the profided transformation.
+	 *
+	 * The default implementation just return the current {@literal ValueFunction}.
+	 * This is not a valid implementation and serves just to maintain backward compatibility.
+	 *
+	 * @param transformation to be applied to the underlying value.
+	 * @return a new {@literal ValueFunction}.
+	 * @since 3.2
+	 */
+	default ValueFunction<T> transform(Function<Object, Object> transformation) {return  this;};
 }

spring-data-relational/src/main/java/org/springframework/data/relational/repository/query/SimpleValueFunction.java renamed to spring-data-relational/src/main/java/org/springframework/data/relational/repository/query/ModifyingValueFunction.java

@@ -21,14 +21,25 @@
 
 import java.util.function.Function;
 
-record SimpleValueFunction(Object value, Function<String, String> modifier) implements ValueFunction<String> {
+/**
+ * Value function that has an underlying value and a modifier that gets applied after the escaper.
+ *
+ * @author Jens Schauder
+ * @since 3.2
+ */
+record ModifyingValueFunction(Object value, Function<String, String> modifier) implements ValueFunction<String> {
 
-	static SimpleValueFunction of(Object value, Function<String, String> modifier) {
-		return new SimpleValueFunction(value, modifier);
+	static ModifyingValueFunction of(Object value, Function<String, String> modifier) {
+		return new ModifyingValueFunction(value, modifier);
 	}
 
 	@Override
 	public String apply(Escaper escaper) {
 		return modifier.apply(escaper.escape(value.toString()));
 	}
+
+	@Override
+	public ValueFunction<String> transform(Function<Object, Object> transformation) {
+		return new ModifyingValueFunction(transformation.apply(value), modifier);
+	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/repository/query/ParameterMetadataProvider.java

@@ -138,12 +138,12 @@ protected Object prepareParameterValue(@Nullable Object value, Class<?> valueTyp
 
 		switch (partType) {
 			case STARTING_WITH:
-				return SimpleValueFunction.of(value, s -> s + "%");
+				return ModifyingValueFunction.of(value, s -> s + "%");
 			case ENDING_WITH:
-				return SimpleValueFunction.of(value, s -> "%" + s);
+				return ModifyingValueFunction.of(value, s -> "%" + s);
 			case CONTAINING:
 			case NOT_CONTAINING:
-				return SimpleValueFunction.of(value, s -> "%" + s + "%");
+				return ModifyingValueFunction.of(value, s -> "%" + s + "%");
 			default:
 				return value;
 		}