Add AOT fragment integration tests for UserRepositoryTests.

Add support for properties-based named queries. Align AOT implementation with reflective repository behavior.

Closes #3950

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/AotQueries.java

@@ -101,6 +101,10 @@ public Map<String, Object> serialize() {
 				serialized.put("query", sq.getQueryString());
 			}
 
+			if (result() instanceof StringAotQuery.NamedStringAotQuery nsq) {
+				serialized.put("name", nsq.getQueryName());
+			}
+
 			if (paging) {
 
 				if (count() instanceof NamedAotQuery nq) {
@@ -112,6 +116,10 @@ public Map<String, Object> serialize() {
 				if (count() instanceof StringAotQuery sq) {
 					serialized.put("count-query", sq.getQueryString());
 				}
+
+				if (count() instanceof StringAotQuery.NamedStringAotQuery nsq) {
+					serialized.put("count-name", nsq.getQueryName());
+				}
 			}
 
 			return serialized;

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/AotRepositoryFragmentSupport.java

@@ -17,19 +17,27 @@
 
 import jakarta.persistence.Tuple;
 
+import java.lang.reflect.Array;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Optional;
+import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
 
 import org.jspecify.annotations.Nullable;
 
 import org.springframework.core.CollectionFactory;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.core.convert.support.ConfigurableConversionService;
+import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.domain.Slice;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.expression.ValueEvaluationContextProvider;
 import org.springframework.data.expression.ValueExpression;
 import org.springframework.data.jpa.repository.query.DeclaredQuery;
 import org.springframework.data.jpa.repository.query.JpaParameters;
+import org.springframework.data.jpa.repository.query.JpaResultConverters;
 import org.springframework.data.jpa.repository.query.QueryEnhancer;
 import org.springframework.data.jpa.repository.query.QueryEnhancerSelector;
 import org.springframework.data.jpa.util.TupleBackedMap;
@@ -50,6 +58,19 @@
  */
 public class AotRepositoryFragmentSupport {
 
+	private static final ConversionService CONVERSION_SERVICE;
+
+	static {
+
+		ConfigurableConversionService conversionService = new DefaultConversionService();
+
+		conversionService.addConverter(JpaResultConverters.BlobToByteArrayConverter.INSTANCE);
+		conversionService.removeConvertible(Collection.class, Object.class);
+		conversionService.removeConvertible(Object.class, Optional.class);
+
+		CONVERSION_SERVICE = conversionService;
+	}
+
 	private final RepositoryMetadata repositoryMetadata;
 
 	private final ValueExpressionDelegate valueExpressions;
@@ -111,6 +132,41 @@ protected String rewriteQuery(DeclaredQuery query, Sort sort, Class<?> returnedT
 		return expression.evaluate(contextProvider.getEvaluationContext(args, expression.getExpressionDependencies()));
 	}
 
+	protected @Nullable Object mapIgnoreCase(@Nullable Object source, UnaryOperator<String> mapper) {
+
+		if (source == null) {
+			return null;
+		}
+
+		if (source.getClass().isArray()) {
+			int length = Array.getLength(source);
+			Collection<Object> result = new ArrayList<>(length);
+
+			for (int i = 0; i < length; i++) {
+				result.add(Array.get(source, i));
+			}
+			source = result;
+		}
+
+		if (source instanceof Collection<?> c) {
+
+			Collection<@Nullable Object> result = new ArrayList<>(c.size());
+
+			for (Object o : c) {
+
+				if (o instanceof String s) {
+					result.add(mapper.apply(s));
+				} else {
+					result.add(o != null ? mapper.apply(o.toString()) : null);
+				}
+			}
+
+			return result;
+		}
+
+		return source;
+	}
+
 	protected <T> @Nullable T convertOne(@Nullable Object result, boolean nativeQuery, Class<T> projection) {
 
 		if (result == null) {
@@ -121,6 +177,10 @@ protected String rewriteQuery(DeclaredQuery query, Sort sort, Class<?> returnedT
 			return projection.cast(result);
 		}
 
+		if (CONVERSION_SERVICE.canConvert(result.getClass(), projection)) {
+			return CONVERSION_SERVICE.convert(result, projection);
+		}
+
 		return projectionFactory.createProjection(projection,
 				result instanceof Tuple t ? new TupleBackedMap(nativeQuery ? TupleBackedMap.underscoreAware(t) : t) : result);
 	}