HHH-19524 @OnetoOne relationship unnecessary joins in nativeQuery

hibernate-core/src/main/java/org/hibernate/generator/values/internal/GeneratedValuesMappingProducer.java

@@ -49,6 +49,7 @@ public JdbcValuesMapping resolve(
 				null,
 				sqlSelections::add,
 				loadQueryInfluencers,
+				false,
 				sessionFactory
 		);
 

hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/ToOneAttributeMapping.java

@@ -1543,8 +1543,8 @@ public static class EntityB {
 		else {
 			side = this.sideNature;
 		}
-
-		if ( ( fetchTiming == FetchTiming.IMMEDIATE && selected ) || needsJoinFetch( side ) ) {
+		if ( fetchTiming == FetchTiming.IMMEDIATE && selected
+			|| !creationState.getSqlAstCreationState().isProcedureOrNativeQuery() && needsJoinFetch( side ) ) {
 			final TableGroup tableGroup = determineTableGroupForFetch(
 					fetchablePath,
 					fetchParent,
@@ -1675,9 +1675,12 @@ else if ( hasNotFoundAction()
 
 	private boolean needsJoinFetch(ForeignKeyDescriptor.Nature side) {
 		if ( side == ForeignKeyDescriptor.Nature.TARGET ) {
-			// The target model part doesn't correspond to the identifier of the target entity mapping
-			// so we must eagerly fetch with a join (subselect would still cause problems).
+			// With composite identifier if the target model part doesn't correspond to the identifier of the target entity mapping
+			// we must eagerly fetch with a join (subselect would still cause problems).
 			final EntityIdentifierMapping identifier = entityMappingType.getIdentifierMapping();
+			if ( identifier instanceof BasicEntityIdentifierMappingImpl ) {
+				return false;
+			}
 			final ValuedModelPart targetPart = foreignKeyDescriptor.getTargetPart();
 			if ( identifier != targetPart ) {
 				// If the identifier and the target part of the same class, we can preserve laziness as deferred loading will still work

hibernate-core/src/main/java/org/hibernate/query/results/internal/DomainResultCreationStateImpl.java

@@ -82,13 +82,15 @@ public class DomainResultCreationStateImpl
 	private boolean processingKeyFetches = false;
 	private boolean resolvingCircularFetch;
 	private ForeignKeyDescriptor.Nature currentlyResolvingForeignKeySide;
+	private boolean isProcedureOrNativeQuery;
 
 	public DomainResultCreationStateImpl(
 			String stateIdentifier,
 			JdbcValuesMetadata jdbcResultsMetadata,
 			Map<String, Map<Fetchable, LegacyFetchBuilder>> legacyFetchBuilders,
 			Consumer<SqlSelection> sqlSelectionConsumer,
 			LoadQueryInfluencers loadQueryInfluencers,
+			boolean isProcedureOrNativeQuery,
 			SessionFactoryImplementor sessionFactory) {
 		this.stateIdentifier = stateIdentifier;
 		this.jdbcResultsMetadata = jdbcResultsMetadata;
@@ -100,6 +102,8 @@ public DomainResultCreationStateImpl(
 		this.legacyFetchResolver = new LegacyFetchResolver( legacyFetchBuilders );
 
 		this.sessionFactory = sessionFactory;
+
+		this.isProcedureOrNativeQuery = isProcedureOrNativeQuery;
 	}
 
 	public SessionFactoryImplementor getSessionFactory() {
@@ -350,11 +354,8 @@ public Fetch visitIdentifierFetch(EntityResultGraphNode fetchParent) {
 		final EntityIdentifierMapping identifierMapping = parentModelPart.getEntityMappingType().getIdentifierMapping();
 		final String identifierAttributeName = attributeName( identifierMapping );
 
-		//noinspection unchecked
-		final FetchBuilder explicitFetchBuilder = (FetchBuilder) fetchBuilderResolverStack
-				.getCurrent()
-				.apply( identifierMapping );
-		LegacyFetchBuilder fetchBuilderLegacy;
+		final FetchBuilder explicitFetchBuilder = fetchBuilderResolverStack.getCurrent().apply( identifierMapping );
+		final LegacyFetchBuilder fetchBuilderLegacy;
 		if ( explicitFetchBuilder == null ) {
 			fetchBuilderLegacy = legacyFetchResolver.resolve(
 					fromClauseAccess.findTableGroup( fetchParent.getNavigablePath() )
@@ -414,9 +415,7 @@ private Consumer<Fetchable> createFetchableConsumer(FetchParent fetchParent, Imm
 			if ( !fetchable.isSelectable() ) {
 				return;
 			}
-			FetchBuilder explicitFetchBuilder = (FetchBuilder) fetchBuilderResolverStack
-					.getCurrent()
-					.apply( fetchable );
+			FetchBuilder explicitFetchBuilder = fetchBuilderResolverStack.getCurrent().apply( fetchable );
 			LegacyFetchBuilder fetchBuilderLegacy;
 			if ( explicitFetchBuilder == null ) {
 				fetchBuilderLegacy = legacyFetchResolver.resolve(
@@ -490,4 +489,8 @@ public void setCurrentlyResolvingForeignKeyPart(ForeignKeyDescriptor.Nature curr
 		this.currentlyResolvingForeignKeySide = currentlyResolvingForeignKeySide;
 	}
 
+	@Override
+	public boolean isProcedureOrNativeQuery() {
+		return isProcedureOrNativeQuery;
+	}
 }

hibernate-core/src/main/java/org/hibernate/query/results/internal/ResultSetMappingImpl.java

@@ -199,6 +199,7 @@ public JdbcValuesMapping resolve(
 				legacyFetchBuilders,
 				sqlSelections::add,
 				loadQueryInfluencers,
+				true,
 				sessionFactory
 		);
 

hibernate-core/src/main/java/org/hibernate/sql/ast/spi/SqlAstCreationState.java

@@ -57,4 +57,8 @@ default boolean supportsEntityNameUsage() {
 	@Internal
 	default void applyOrdering(TableGroup tableGroup, OrderByFragment orderByFragment) {
 	}
+
+	default boolean isProcedureOrNativeQuery(){
+		return false;
+	}
 }

hibernate-core/src/test/java/org/hibernate/orm/test/jpa/query/NativeQueryJoinTest.java

@@ -0,0 +1,166 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.orm.test.jpa.query;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.JiraKey;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+@DomainModel(
+		annotatedClasses = {
+				NativeQueryJoinTest.Order.class,
+				NativeQueryJoinTest.OrderInfo.class,
+		}
+)
+@SessionFactory
+@JiraKey("HHH-19524")
+public class NativeQueryJoinTest {
+
+	private static final long ORDER_ID = 1L;
+	private static final long ORDER_INFO_ID = 2L;
+	private static final String ORDER_INFO_DESCRIPTION = "first order";
+
+	@BeforeEach
+	public void setup(SessionFactoryScope scope) {
+		scope.inTransaction(
+				session -> {
+					OrderInfo additionalInfo = new OrderInfo(
+							new BigDecimal( ORDER_INFO_ID ),
+							ORDER_INFO_DESCRIPTION
+					);
+					Order order = new Order( ORDER_ID, 1L, additionalInfo );
+					session.persist( order );
+				}
+		);
+	}
+
+	@AfterEach
+	public void teardown(SessionFactoryScope scope) {
+		scope.getSessionFactory().getSchemaManager().truncateMappedObjects();
+	}
+
+	@Test
+	public void testFind(SessionFactoryScope scope) {
+		scope.inTransaction(
+				session -> {
+					Order order = session.find( Order.class, ORDER_ID );
+					OrderInfo additionalInfo = order.getOrderInfo();
+					assertThat( additionalInfo.getDescription() ).isEqualTo( ORDER_INFO_DESCRIPTION );
+				} );
+	}
+
+	@Test
+	public void testQuery(SessionFactoryScope scope) {
+		scope.inTransaction(
+				session -> {
+					List<Long> ids = session.createQuery("select o.orderId from Order o", Long.class ).list();
+					session.createMutationQuery( "update Order set description = :des" ).setParameter( "des", "abc" ).executeUpdate();
+				} );
+	}
+
+	@Test
+	public void testNativeQuery(SessionFactoryScope scope) {
+		scope.inTransaction(
+				session -> {
+					String query = "select o.* from ORDER_TABLE o where o.ORDER_ID = ?1";
+					List<Order> orders = session.createNativeQuery( query, Order.class )
+							.setParameter( 1, ORDER_ID )
+							.list();
+					Order order = orders.get( 0 );
+					OrderInfo additionalInfo = order.getOrderInfo();
+					assertThat( additionalInfo.getDescription() ).isEqualTo( ORDER_INFO_DESCRIPTION );
+				} );
+	}
+
+	@Table(name = "ORDER_TABLE")
+	@Entity(name = "Order")
+	public static class Order {
+
+		@Id
+		@Column(name = "ORDER_ID")
+		private Long orderId;
+
+		private long orderNumber;
+
+		private String description;
+
+		@OneToOne(mappedBy = "order", fetch = FetchType.LAZY, cascade = CascadeType.PERSIST)
+		private OrderInfo orderInfo;
+
+		public Order() {
+		}
+
+		public Long getOrderId() {
+			return orderId;
+		}
+
+		public long getOrderNumber() {
+			return orderNumber;
+		}
+
+		public OrderInfo getOrderInfo() {
+			return orderInfo;
+		}
+
+		public Order(Long orderId, long orderNumber, OrderInfo additionalInfo) {
+			this.orderId = orderId;
+			this.orderNumber = orderNumber;
+			this.orderInfo = additionalInfo;
+			additionalInfo.order = this;
+		}
+	}
+
+	@Entity(name = "OrderInfo")
+	@Table(name = "ORDER_INFO_TABLE")
+	public static class OrderInfo {
+
+		@Id
+		@Column(name = "ORDER_INFO_ID")
+		private BigDecimal orderInfoId;
+
+		private String description;
+
+		@OneToOne(fetch = FetchType.LAZY)
+		@JoinColumn(name = "ORDER_ID")
+		private Order order;
+
+		public OrderInfo() {
+		}
+
+		public OrderInfo(BigDecimal orderInfoId, String description) {
+			this.orderInfoId = orderInfoId;
+			this.description = description;
+		}
+
+		public BigDecimal getOrderInfoId() {
+			return orderInfoId;
+		}
+
+		public String getDescription() {
+			return description;
+		}
+
+		public Order getOrder() {
+			return order;
+		}
+	}
+}