Add support for Value Expressions, Stream, Named and Modifying Queries.

See #3830

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/provider/HibernateUtils.java

@@ -15,8 +15,11 @@
  */
 package org.springframework.data.jpa.provider;
 
+import org.hibernate.query.NativeQuery;
 import org.hibernate.query.Query;
 import org.hibernate.query.spi.SqmQuery;
+import org.hibernate.query.sql.spi.NamedNativeQueryMemento;
+import org.hibernate.query.sqm.spi.NamedSqmQueryMemento;
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -44,7 +47,6 @@ private HibernateUtils() {}
 	public @Nullable static String getHibernateQuery(Object query) {
 
 		try {
-
 			// Try the new Hibernate implementation first
 			if (query instanceof SqmQuery sqmQuery) {
 
@@ -57,6 +59,22 @@ private HibernateUtils() {}
 				return sqmQuery.getSqmStatement().toHqlString();
 			}
 
+			// Try the new Hibernate implementation first
+			if (query instanceof NamedSqmQueryMemento<?> sqmQuery) {
+
+				String hql = sqmQuery.getHqlString();
+
+				if (!hql.equals("<criteria>")) {
+					return hql;
+				}
+
+				return sqmQuery.getSqmStatement().toHqlString();
+			}
+
+			if (query instanceof NamedNativeQueryMemento<?> nativeQuery) {
+				return nativeQuery.getSqlString();
+			}
+
 			// Couple of cases in which this still breaks, see HHH-15389
 		} catch (RuntimeException o_O) {}
 
@@ -67,4 +85,28 @@ private HibernateUtils() {}
 			throw new IllegalArgumentException("Don't know how to extract the query string from " + query);
 		}
 	}
+
+	public static boolean isNativeQuery(Object query) {
+
+		// Try the new Hibernate implementation first
+		if (query instanceof SqmQuery) {
+			return false;
+		}
+
+		if (query instanceof NativeQuery<?>) {
+			return true;
+		}
+
+		// Try the new Hibernate implementation first
+		if (query instanceof NamedSqmQueryMemento<?>) {
+
+			return false;
+		}
+
+		if (query instanceof NamedNativeQueryMemento<?>) {
+			return true;
+		}
+
+		return false;
+	}
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/provider/JpaClassUtils.java

@@ -18,9 +18,9 @@
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.metamodel.Metamodel;
 
-import org.springframework.util.Assert;
-
 import org.jspecify.annotations.Nullable;
+
+import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
@@ -59,7 +59,7 @@ public static boolean isMetamodelOfType(Metamodel metamodel, String type) {
 		return isOfType(metamodel, type, metamodel.getClass().getClassLoader());
 	}
 
-	private static boolean isOfType(Object source, String typeName, @Nullable ClassLoader classLoader) {
+	public static boolean isOfType(Object source, String typeName, @Nullable ClassLoader classLoader) {
 
 		Assert.notNull(source, "Source instance must not be null");
 		Assert.hasText(typeName, "Target type name must not be null or empty");

spring-data-jpa/src/main/java/org/springframework/data/jpa/provider/PersistenceProvider.java

@@ -19,6 +19,7 @@
 import static org.springframework.data.jpa.provider.PersistenceProvider.Constants.*;
 
 import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.Query;
 import jakarta.persistence.metamodel.IdentifiableType;
 import jakarta.persistence.metamodel.Metamodel;
@@ -65,14 +66,20 @@ public enum PersistenceProvider implements QueryExtractor, ProxyIdAccessor, Quer
 	 * @see <a href="https://github.com/spring-projects/spring-data-jpa/issues/846">DATAJPA-444</a>
 	 */
 	HIBERNATE(//
+			Collections.singletonList(HIBERNATE_ENTITY_MANAGER_FACTORY_INTERFACE), //
 			Collections.singletonList(HIBERNATE_ENTITY_MANAGER_INTERFACE), //
 			Collections.singletonList(HIBERNATE_JPA_METAMODEL_TYPE)) {
 
 		@Override
-		public @Nullable String extractQueryString(Query query) {
+		public @Nullable String extractQueryString(Object query) {
 			return HibernateUtils.getHibernateQuery(query);
 		}
 
+		@Override
+		public boolean isNativeQuery(Object query) {
+			return HibernateUtils.isNativeQuery(query);
+		}
+
 		/**
 		 * Return custom placeholder ({@code *}) as Hibernate does create invalid queries for count queries for objects with
 		 * compound keys.
@@ -115,14 +122,20 @@ public String getCommentHintKey() {
 	/**
 	 * EclipseLink persistence provider.
 	 */
-	ECLIPSELINK(Collections.singleton(ECLIPSELINK_ENTITY_MANAGER_INTERFACE),
+	ECLIPSELINK(List.of(ECLIPSELINK_ENTITY_MANAGER_FACTORY_INTERFACE1, ECLIPSELINK_ENTITY_MANAGER_FACTORY_INTERFACE2),
+			Collections.singleton(ECLIPSELINK_ENTITY_MANAGER_INTERFACE),
 			Collections.singleton(ECLIPSELINK_JPA_METAMODEL_TYPE)) {
 
 		@Override
-		public String extractQueryString(Query query) {
+		public String extractQueryString(Object query) {
 			return ((JpaQuery<?>) query).getDatabaseQuery().getJPQLString();
 		}
 
+		@Override
+		public boolean isNativeQuery(Object query) {
+			return false;
+		}
+
 		@Override
 		public boolean shouldUseAccessorFor(Object entity) {
 			return false;
@@ -152,13 +165,19 @@ public String getCommentHintValue(String comment) {
 	/**
 	 * Unknown special provider. Use standard JPA.
 	 */
-	GENERIC_JPA(Collections.singleton(GENERIC_JPA_ENTITY_MANAGER_INTERFACE), Collections.emptySet()) {
+	GENERIC_JPA(Collections.singleton(GENERIC_JPA_ENTITY_MANAGER_INTERFACE),
+			Collections.singleton(GENERIC_JPA_ENTITY_MANAGER_INTERFACE), Collections.emptySet()) {
 
 		@Override
-		public @Nullable String extractQueryString(Query query) {
+		public @Nullable String extractQueryString(Object query) {
 			return null;
 		}
 
+		@Override
+		public boolean isNativeQuery(Object query) {
+			return false;
+		}
+
 		@Override
 		public boolean canExtractQuery() {
 			return false;
@@ -196,6 +215,7 @@ public boolean shouldUseAccessorFor(Object entity) {
 	private static final Collection<PersistenceProvider> ALL = List.of(HIBERNATE, ECLIPSELINK, GENERIC_JPA);
 
 	private static final ConcurrentReferenceHashMap<Class<?>, PersistenceProvider> CACHE = new ConcurrentReferenceHashMap<>();
+	private final Iterable<String> entityManagerFactoryClassNames;
 	private final Iterable<String> entityManagerClassNames;
 	private final Iterable<String> metamodelClassNames;
 
@@ -204,24 +224,38 @@ public boolean shouldUseAccessorFor(Object entity) {
 	/**
 	 * Creates a new {@link PersistenceProvider}.
 	 *
+	 * @param entityManagerFactoryClassNames the names of the provider specific
+	 *          {@link jakarta.persistence.EntityManagerFactory} implementations. Must not be {@literal null} or empty.
 	 * @param entityManagerClassNames the names of the provider specific {@link EntityManager} implementations. Must not
 	 *          be {@literal null} or empty.
 	 * @param metamodelClassNames must not be {@literal null}.
 	 */
-	PersistenceProvider(Iterable<String> entityManagerClassNames, Iterable<String> metamodelClassNames) {
+	PersistenceProvider(Iterable<String> entityManagerFactoryClassNames, Iterable<String> entityManagerClassNames,
+			Iterable<String> metamodelClassNames) {
 
+		this.entityManagerFactoryClassNames = entityManagerFactoryClassNames;
 		this.entityManagerClassNames = entityManagerClassNames;
 		this.metamodelClassNames = metamodelClassNames;
 
 		boolean present = false;
-		for (String entityManagerClassName : entityManagerClassNames) {
+		for (String emfClassName : entityManagerFactoryClassNames) {
 
-			if (ClassUtils.isPresent(entityManagerClassName, PersistenceProvider.class.getClassLoader())) {
+			if (ClassUtils.isPresent(emfClassName, PersistenceProvider.class.getClassLoader())) {
 				present = true;
 				break;
 			}
 		}
 
+		if (!present) {
+			for (String entityManagerClassName : entityManagerClassNames) {
+
+				if (ClassUtils.isPresent(entityManagerClassName, PersistenceProvider.class.getClassLoader())) {
+					present = true;
+					break;
+				}
+			}
+		}
+
 		this.present = present;
 	}
 
@@ -266,6 +300,36 @@ public static PersistenceProvider fromEntityManager(EntityManager em) {
 		return cacheAndReturn(entityManagerType, GENERIC_JPA);
 	}
 
+	/**
+	 * Determines the {@link PersistenceProvider} from the given {@link EntityManager}. If no special one can be
+	 * determined {@link #GENERIC_JPA} will be returned.
+	 *
+	 * @param emf must not be {@literal null}.
+	 * @return will never be {@literal null}.
+	 */
+	public static PersistenceProvider fromEntityManagerFactory(EntityManagerFactory emf) {
+
+		Assert.notNull(emf, "EntityManager must not be null");
+
+		Class<?> entityManagerType = emf.getPersistenceUnitUtil().getClass();
+		PersistenceProvider cachedProvider = CACHE.get(entityManagerType);
+
+		if (cachedProvider != null) {
+			return cachedProvider;
+		}
+
+		for (PersistenceProvider provider : ALL) {
+			for (String emfClassName : provider.entityManagerFactoryClassNames) {
+				if (isOfType(emf.getPersistenceUnitUtil(), emfClassName,
+						emf.getPersistenceUnitUtil().getClass().getClassLoader())) {
+					return cacheAndReturn(entityManagerType, provider);
+				}
+			}
+		}
+
+		return cacheAndReturn(entityManagerType, GENERIC_JPA);
+	}
+
 	/**
 	 * Determines the {@link PersistenceProvider} from the given {@link Metamodel}. If no special one can be determined
 	 * {@link #GENERIC_JPA} will be returned.
@@ -350,9 +414,15 @@ public boolean isPresent() {
 	 */
 	interface Constants {
 
+		String GENERIC_JPA_ENTITY_MANAGER_FACTORY_INTERFACE = "jakarta.persistence.EntityManagerFactory";
 		String GENERIC_JPA_ENTITY_MANAGER_INTERFACE = "jakarta.persistence.EntityManager";
+
+		String ECLIPSELINK_ENTITY_MANAGER_FACTORY_INTERFACE1 = "org.eclipse.persistence.internal.jpa.EntityManagerFactoryDelegate";
+		String ECLIPSELINK_ENTITY_MANAGER_FACTORY_INTERFACE2 = "org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl";
 		String ECLIPSELINK_ENTITY_MANAGER_INTERFACE = "org.eclipse.persistence.jpa.JpaEntityManager";
+
 		// needed as Spring only exposes that interface via the EM proxy
+		String HIBERNATE_ENTITY_MANAGER_FACTORY_INTERFACE = "org.hibernate.jpa.internal.PersistenceUnitUtilImpl";
 		String HIBERNATE_ENTITY_MANAGER_INTERFACE = "org.hibernate.engine.spi.SessionImplementor";
 
 		String HIBERNATE_JPA_METAMODEL_TYPE = "org.hibernate.metamodel.model.domain.JpaMetamodel";

spring-data-jpa/src/main/java/org/springframework/data/jpa/provider/QueryExtractor.java

@@ -16,6 +16,7 @@
 package org.springframework.data.jpa.provider;
 
 import jakarta.persistence.Query;
+import jakarta.persistence.TypedQueryReference;
 
 import org.jspecify.annotations.Nullable;
 
@@ -28,19 +29,31 @@
 public interface QueryExtractor {
 
 	/**
-	 * Reverse engineers the query string from the {@link Query} object. This requires provider specific API as JPA does
-	 * not provide access to the underlying query string as soon as one has created a {@link Query} instance of it.
+	 * Reverse engineers the query string from the {@link Query} or a {@link TypedQueryReference} object. This requires
+	 * provider specific API as JPA does not provide access to the underlying query string as soon as one has created a
+	 * {@link Query} instance of it.
 	 *
 	 * @param query
 	 * @return the query string representing the query or {@literal null} if resolving is not possible.
 	 */
 	@Nullable
-	String extractQueryString(Query query);
+	String extractQueryString(Object query);
+
+	/**
+	 * Reverse engineers the query native flag from a {@link Query} or native query as JPA does not provide access to the
+	 * underlying query string once a (named) query is constructed.
+	 *
+	 * @param query
+	 * @return {@literal true} if the query is a native one.
+	 * @since 4.0
+	 */
+	boolean isNativeQuery(Object query);
 
 	/**
 	 * Returns whether the extractor is able to extract the original query string from a given {@link Query}.
 	 *
 	 * @return
 	 */
 	boolean canExtractQuery();
+
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/generated/AotMetaModel.java renamed to spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/generated/AotMetamodel.java

@@ -36,30 +36,31 @@
 
 /**
  * @author Christoph Strobl
+ * @since 4.0
  */
-class AotMetaModel implements Metamodel {
+class AotMetamodel implements Metamodel {
 
 	private final String persistenceUnit;
 	private final Set<Class<?>> managedTypes;
 	private final Lazy<EntityManagerFactory> entityManagerFactory = Lazy.of(this::init);
 	private final Lazy<Metamodel> metamodel = Lazy.of(() -> entityManagerFactory.get().getMetamodel());
 	private final Lazy<EntityManager> entityManager = Lazy.of(() -> entityManagerFactory.get().createEntityManager());
 
-	public AotMetaModel(Set<Class<?>> managedTypes) {
+	public AotMetamodel(Set<Class<?>> managedTypes) {
 		this("dynamic-tests", managedTypes);
 	}
 
-	private AotMetaModel(String persistenceUnit, Set<Class<?>> managedTypes) {
+	private AotMetamodel(String persistenceUnit, Set<Class<?>> managedTypes) {
 		this.persistenceUnit = persistenceUnit;
 		this.managedTypes = managedTypes;
 	}
 
-	public static AotMetaModel hibernateModel(Class<?>... types) {
-		return new AotMetaModel(Set.of(types));
+	public static AotMetamodel hibernateModel(Class<?>... types) {
+		return new AotMetamodel(Set.of(types));
 	}
 
-	public static AotMetaModel hibernateModel(String persistenceUnit, Class<?>... types) {
-		return new AotMetaModel(persistenceUnit, Set.of(types));
+	public static AotMetamodel hibernateModel(String persistenceUnit, Class<?>... types) {
+		return new AotMetamodel(persistenceUnit, Set.of(types));
 	}
 
 	public <X> EntityType<X> entity(Class<X> cls) {
@@ -95,6 +96,11 @@ public EntityManager entityManager() {
 		return entityManager.get();
 	}
 
+	// TODO: Capture an existing factory bean (e.g. EntityManagerFactoryInfo) to extract PersistenceInfo
+	public EntityManagerFactory getEntityManagerFactory() {
+		return entityManagerFactory.get();
+	}
+
 	EntityManagerFactory init() {
 
 		MutablePersistenceUnitInfo persistenceUnitInfo = new MutablePersistenceUnitInfo() {
@@ -121,4 +127,5 @@ public List<String> getManagedClassNames() {
 			}
 		}, Map.of("hibernate.dialect", "org.hibernate.dialect.H2Dialect")).build();
 	}
+
 }