Merge branch 'spring-projects:main' into feat/2409_intro_JSQLParses

Author: DiegoKrupitza

src/main/java/org/springframework/data/jpa/mapping/JpaPersistentPropertyImpl.java

@@ -109,7 +109,7 @@ public JpaPersistentPropertyImpl(JpaMetamodel metamodel, Property property,
 
 		this.isIdProperty = Lazy.of(() -> ID_ANNOTATIONS.stream().anyMatch(it -> isAnnotationPresent(it)) //
 				|| metamodel.isSingleIdAttribute(getOwner().getType(), getName(), getType()));
-		this.isEntity = Lazy.of(() -> metamodel.isJpaManaged(getActualType()));
+		this.isEntity = Lazy.of(() -> metamodel.isMappedType(getActualType()));
 	}
 
 	/*

src/main/java/org/springframework/data/jpa/repository/query/JpaQueryCreator.java

@@ -176,7 +176,7 @@ protected CriteriaQuery<? extends Object> complete(@Nullable Predicate predicate
 				selections.add(toExpressionRecursively(root, path, true).alias(property));
 			}
 
-			Class<?> typeToRead = returnedType.getTypeToRead();
+			Class<?> typeToRead = returnedType.getReturnedType();
 
 			query = typeToRead.isInterface()
 					? query.multiselect(selections)

src/main/java/org/springframework/data/jpa/util/JpaMetamodel.java

@@ -16,15 +16,20 @@
 package org.springframework.data.jpa.util;
 
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
+import javax.persistence.Embeddable;
 import javax.persistence.metamodel.EntityType;
 import javax.persistence.metamodel.ManagedType;
 import javax.persistence.metamodel.Metamodel;
 import javax.persistence.metamodel.SingularAttribute;
+import javax.persistence.metamodel.Type.PersistenceType;
 
+import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.data.util.Lazy;
 import org.springframework.data.util.StreamUtils;
 import org.springframework.util.Assert;
@@ -39,10 +44,13 @@
 public class JpaMetamodel {
 
 	private static final Map<Metamodel, JpaMetamodel> CACHE = new ConcurrentHashMap<>(4);
+	private static final Set<PersistenceType> ENTITY_OR_MAPPED_SUPERCLASS = EnumSet.of(PersistenceType.ENTITY,
+			PersistenceType.MAPPED_SUPERCLASS);
 
 	private final Metamodel metamodel;
 
 	private Lazy<Collection<Class<?>>> managedTypes;
+	private Lazy<Collection<Class<?>>> jpaEmbeddables;
 
 	/**
 	 * Creates a new {@link JpaMetamodel} for the given JPA {@link Metamodel}.
@@ -54,10 +62,17 @@ private JpaMetamodel(Metamodel metamodel) {
 		Assert.notNull(metamodel, "Metamodel must not be null!");
 
 		this.metamodel = metamodel;
+
 		this.managedTypes = Lazy.of(() -> metamodel.getManagedTypes().stream() //
 				.map(ManagedType::getJavaType) //
 				.filter(it -> it != null) //
 				.collect(StreamUtils.toUnmodifiableSet()));
+
+		this.jpaEmbeddables = Lazy.of(() -> metamodel.getEmbeddables().stream() //
+				.map(ManagedType::getJavaType)
+				.filter(it -> it != null)
+				.filter(it -> AnnotatedElementUtils.isAnnotated(it, Embeddable.class))
+				.collect(StreamUtils.toUnmodifiableSet()));
 	}
 
 	public static JpaMetamodel of(Metamodel metamodel) {
@@ -96,6 +111,27 @@ public boolean isSingleIdAttribute(Class<?> entity, String name, Class<?> attrib
 				.orElse(false);
 	}
 
+	/**
+	 * Returns whether the given type is considered a mapped type, i.e. an actually JPA persisted entity, mapped
+	 * superclass or native JPA embeddable.
+	 *
+	 * @param entity must not be {@literal null}.
+	 * @return
+	 */
+	public boolean isMappedType(Class<?> entity) {
+
+		Assert.notNull(entity, "Type must not be null!");
+
+		if (!isJpaManaged(entity)) {
+			return false;
+		}
+
+		ManagedType<?> managedType = metamodel.managedType(entity);
+
+		return !managedType.getPersistenceType().equals(PersistenceType.EMBEDDABLE)
+				|| jpaEmbeddables.get().contains(entity);
+	}
+
 	/**
 	 * Wipes the static cache of {@link Metamodel} to {@link JpaMetamodel}.
 	 */

src/test/java/org/springframework/data/jpa/repository/UserRepositoryTests.java

@@ -57,6 +57,8 @@
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.domain.Example;
 import org.springframework.data.domain.ExampleMatcher;
+import org.springframework.data.domain.ExampleMatcher.GenericPropertyMatcher;
+import org.springframework.data.domain.ExampleMatcher.StringMatcher;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.PageRequest;
@@ -2632,6 +2634,14 @@ void readsDtoProjections() {
 		assertThat(repository.findAllDtoProjectedBy()).hasSize(4);
 	}
 
+	@Test // GH-2408, GH-2363
+	void readsDerivedInterfaceProjections() {
+
+		flushTestUsers();
+
+		assertThat(repository.findAllInterfaceProjectedBy()).hasSize(4);
+	}
+
 	private Page<User> executeSpecWithSort(Sort sort) {
 
 		flushTestUsers();

src/test/java/org/springframework/data/jpa/repository/query/PartTreeJpaQueryIntegrationTests.java

@@ -222,7 +222,7 @@ void errorsDueToMissingPropertyContainNameOfMethodAndInterface() throws Exceptio
 		assertThatExceptionOfType(IllegalArgumentException.class) //
 				.isThrownBy(() -> new PartTreeJpaQuery(method, entityManager)) //
 				.withMessageContaining("findByNoSuchProperty") // the method being analyzed
-				.withMessageContaining(" noSuchProperty ") // the property we are looking for
+				.withMessageContaining("'noSuchProperty'") // the property we are looking for
 				.withMessageContaining("UserRepository"); // the repository
 	}
 

src/test/java/org/springframework/data/jpa/repository/sample/UserRepository.java

@@ -614,6 +614,9 @@ Page<User> findAllOrderedBySpecialNameMultipleParams(@Param("name") String name,
 	// #2363
 	List<NameOnlyDto> findAllDtoProjectedBy();
 
+	// GH-2408
+	List<NameOnly> findAllInterfaceProjectedBy();
+
 	interface RolesAndFirstname {
 
 		String getFirstname();

src/test/java/org/springframework/data/jpa/util/JpaMetamodelUnitTests.java

@@ -18,10 +18,17 @@
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 
+import javax.persistence.Embeddable;
+import javax.persistence.Entity;
+import javax.persistence.metamodel.EmbeddableType;
 import javax.persistence.metamodel.EntityType;
+import javax.persistence.metamodel.ManagedType;
 import javax.persistence.metamodel.Metamodel;
+import javax.persistence.metamodel.Type.PersistenceType;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -60,4 +67,54 @@ void cacheIsEffectiveUnlessCleared() {
 		JpaMetamodel.clear();
 		assertThat(model).isNotEqualTo(JpaMetamodel.of(metamodel));
 	}
+
+	@Test // #2421
+	void doesNotConsiderNonNativeEmbeddablesJpaManaged() {
+
+		JpaMetamodel model = JpaMetamodel.of(metamodel);
+
+		ManagedType<?> entity = getEntity(Wrapper.class);
+		ManagedType<?> embeddable = getEmbeddable(ExplicitEmbeddable.class);
+		ManagedType<?> inner = getEmbeddable(Inner.class);
+
+		doReturn(new HashSet<>(Arrays.asList(entity, embeddable, inner))).when(metamodel).getManagedTypes();
+		doReturn(new HashSet<>(Arrays.asList(embeddable, inner))).when(metamodel).getEmbeddables();
+
+		assertThat(model.isMappedType(Wrapper.class)).isTrue();
+		assertThat(model.isMappedType(ExplicitEmbeddable.class)).isTrue();
+		assertThat(model.isMappedType(Inner.class)).isFalse();
+	}
+
+	private EmbeddableType<?> getEmbeddable(Class<?> type) {
+
+		EmbeddableType<?> managedType = getManagedType(type, EmbeddableType.class);
+		doReturn(PersistenceType.EMBEDDABLE).when(managedType).getPersistenceType();
+
+		return managedType;
+	}
+
+	private EntityType<?> getEntity(Class<?> type) {
+
+		EntityType<?> managedType = getManagedType(type, EntityType.class);
+		doReturn(PersistenceType.ENTITY).when(managedType).getPersistenceType();
+
+		return managedType;
+	}
+
+	private <T extends ManagedType<?>> T getManagedType(Class<?> type, Class<T> baseType) {
+
+		T managedType = mock(baseType);
+		doReturn(type).when(managedType).getJavaType();
+		doReturn(managedType).when(metamodel).managedType(type);
+
+		return managedType;
+	}
+
+	@Entity
+	static class Wrapper {}
+
+	@Embeddable
+	static class ExplicitEmbeddable {}
+
+	static class Inner {}
 }