Changes for Hibernate Reactive 2.4

hibernate-core/src/main/java/org/hibernate/metamodel/internal/AbstractCompositeIdentifierMapping.java

@@ -72,6 +72,16 @@ public AbstractCompositeIdentifierMapping(
 		this.sessionFactory = creationProcess.getCreationContext().getSessionFactory();
 	}
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
+	protected AbstractCompositeIdentifierMapping(AbstractCompositeIdentifierMapping original) {
+		this.navigableRole = original.navigableRole;
+		this.entityMapping = original.entityMapping;
+		this.tableExpression = original.tableExpression;
+		this.sessionFactory = original.sessionFactory;
+	}
+
 	@Override
 	public boolean hasContainingClass() {
 		return true;

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

@@ -119,6 +119,17 @@ public NonAggregatedIdentifierMappingImpl(
 		}
 	}
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
+	protected NonAggregatedIdentifierMappingImpl(NonAggregatedIdentifierMappingImpl original) {
+		super( original );
+		entityDescriptor = original.entityDescriptor;
+		virtualIdEmbeddable = original.virtualIdEmbeddable;
+		idClassEmbeddable = original.idClassEmbeddable;
+		identifierValueMapper = original.identifierValueMapper;
+	}
+
 	@Override
 	public EmbeddableMappingType getMappedType() {
 		return virtualIdEmbeddable;

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

@@ -167,6 +167,17 @@ public SimpleForeignKeyDescriptor(
 		);
 	}
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
+	protected SimpleForeignKeyDescriptor(SimpleForeignKeyDescriptor original) {
+		keySide = original.keySide;
+		targetSide = original.targetSide;
+		refersToPrimaryKey = original.refersToPrimaryKey;
+		hasConstraint = original.hasConstraint;
+		associationKey = original.associationKey;
+	}
+
 	@Override
 	public String getKeyTable() {
 		return keySide.getModelPart().getContainingTableExpression();

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

@@ -2428,16 +2428,13 @@ public <X, Y> int breakDownJdbcValues(
 		return foreignKeyDescriptor.breakDownJdbcValues( value, offset, x, y, valueConsumer, session );
 	}
 
-	private Object extractValue(Object domainValue, SharedSessionContractImplementor session) {
+	protected Object extractValue(Object domainValue, SharedSessionContractImplementor session) {
 		if ( domainValue == null ) {
 			return null;
 		}
 
 		if ( referencedPropertyName != null ) {
-			final LazyInitializer lazyInitializer = HibernateProxy.extractLazyInitializer( domainValue );
-			if ( lazyInitializer != null ) {
-				domainValue = lazyInitializer.getImplementation();
-			}
+			domainValue = lazyInitialize( domainValue );
 			assert getAssociatedEntityMappingType()
 					.getRepresentationStrategy()
 					.getInstantiator()
@@ -2448,7 +2445,19 @@ assert getAssociatedEntityMappingType()
 		return foreignKeyDescriptor.getAssociationKeyFromSide( domainValue, sideNature.inverse(), session );
 	}
 
-	private static Object extractAttributePathValue(Object domainValue, EntityMappingType entityType, String attributePath) {
+	/**
+	 * For Hibernate Reactive, because it doesn't support lazy initialization, it will override this method and skip it
+	 * when possible.
+	 */
+	protected Object lazyInitialize(Object domainValue) {
+		final LazyInitializer lazyInitializer = HibernateProxy.extractLazyInitializer( domainValue );
+		if ( lazyInitializer != null ) {
+			return lazyInitializer.getImplementation();
+		}
+		return domainValue;
+	}
+
+	protected static Object extractAttributePathValue(Object domainValue, EntityMappingType entityType, String attributePath) {
 		if ( ! attributePath.contains( "." ) ) {
 			return entityType.findAttributeMapping( attributePath ).getValue( domainValue );
 		}

hibernate-core/src/main/java/org/hibernate/sql/results/graph/AbstractFetchParent.java

@@ -27,6 +27,16 @@ public AbstractFetchParent(NavigablePath navigablePath) {
 		this.navigablePath = navigablePath;
 	}
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
+	public AbstractFetchParent(AbstractFetchParent original) {
+		navigablePath = original.navigablePath;
+		fetches = original.fetches;
+		hasJoinFetches = original.hasJoinFetches;
+		containsCollectionFetches = original.containsCollectionFetches;
+	}
+
 	public void afterInitialize(FetchParent fetchParent, DomainResultCreationState creationState) {
 		assert fetches == ImmutableFetchList.EMPTY;
 		resetFetches( creationState.visitFetches( fetchParent ) );

hibernate-core/src/main/java/org/hibernate/sql/results/graph/InitializerData.java

@@ -6,10 +6,14 @@
  */
 package org.hibernate.sql.results.graph;
 
+import java.util.Objects;
+
 import org.hibernate.sql.results.jdbc.spi.RowProcessingState;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import static java.util.Objects.requireNonNull;
+
 public abstract class InitializerData {
 	protected final RowProcessingState rowProcessingState;
 	protected Initializer.State state = Initializer.State.UNINITIALIZED;
@@ -19,6 +23,16 @@ public InitializerData(RowProcessingState rowProcessingState) {
 		this.rowProcessingState = rowProcessingState;
 	}
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
+	public InitializerData(InitializerData original) {
+		requireNonNull( original );
+		this.rowProcessingState = original.rowProcessingState;
+		this.state = original.state;
+		this.instance = original.instance;
+	}
+
 	public RowProcessingState getRowProcessingState() {
 		return rowProcessingState;
 	}

hibernate-core/src/main/java/org/hibernate/sql/results/graph/embeddable/internal/EmbeddableFetchImpl.java

@@ -90,8 +90,8 @@ public EmbeddableFetchImpl(
 	 * For Hibernate Reactive
 	 */
 	protected EmbeddableFetchImpl(EmbeddableFetchImpl original) {
-		super( original.getNavigablePath() );
-		this.fetchContainer = original.getFetchContainer();
+		super( original );
+		fetchContainer = original.getFetchContainer();
 		fetchParent = original.fetchParent;
 		fetchTiming = original.fetchTiming;
 		tableGroup = original.tableGroup;
@@ -155,7 +155,9 @@ public EmbeddableMappingType getReferencedMappingType() {
 	public DomainResultAssembler<?> createAssembler(
 			InitializerParent<?> parent,
 			AssemblerCreationState creationState) {
-		return new EmbeddableAssembler( creationState.resolveInitializer( this, parent, this ).asEmbeddableInitializer() );
+		Initializer<?> initializer = creationState.resolveInitializer( this, parent, this );
+		EmbeddableInitializer<?> embeddableInitializer = initializer.asEmbeddableInitializer();
+		return new EmbeddableAssembler( embeddableInitializer );
 	}
 
 	@Override
@@ -180,4 +182,8 @@ public boolean appliesTo(GraphImplementor<?> graphImplementor, JpaMetamodel meta
 	public FetchParent asFetchParent() {
 		return this;
 	}
+
+	protected BasicFetch<?> getDiscriminatorFetch() {
+		return discriminatorFetch;
+	}
 }

hibernate-core/src/main/java/org/hibernate/sql/results/graph/embeddable/internal/EmbeddableForeignKeyResultImpl.java

@@ -38,6 +38,9 @@ public class EmbeddableForeignKeyResultImpl<T>
 	private final FetchParent fetchParent;
 	private final EmbeddableMappingType fetchContainer;
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
 	public EmbeddableForeignKeyResultImpl(
 			NavigablePath navigablePath,
 			EmbeddableValuedModelPart embeddableValuedModelPart,
@@ -51,6 +54,13 @@ public EmbeddableForeignKeyResultImpl(
 		resetFetches( creationState.visitFetches( this ) );
 	}
 
+	protected EmbeddableForeignKeyResultImpl(EmbeddableForeignKeyResultImpl<T> original) {
+		super( original );
+		this.resultVariable = original.resultVariable;
+		this.fetchParent = original.fetchParent;
+		this.fetchContainer = original.fetchContainer;
+	}
+
 	@Override
 	public FetchParent getRoot() {
 		return fetchParent.getRoot();

hibernate-core/src/main/java/org/hibernate/sql/results/graph/embeddable/internal/NonAggregatedIdentifierMappingInitializer.java

@@ -8,6 +8,7 @@
 
 import java.util.ArrayList;
 import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
@@ -95,6 +96,15 @@ public NonAggregatedIdentifierMappingInitializer(
 			InitializerParent<?> parent,
 			AssemblerCreationState creationState,
 			boolean isResultInitializer) {
+		this( resultDescriptor, parent, creationState, isResultInitializer, Function.identity() );
+	}
+
+	protected NonAggregatedIdentifierMappingInitializer(
+			EmbeddableResultGraphNode resultDescriptor,
+			InitializerParent<?> parent,
+			AssemblerCreationState creationState,
+			boolean isResultInitializer,
+			Function<Fetch, Fetch> fetchConverter) {
 		super( creationState );
 		this.navigablePath = resultDescriptor.getNavigablePath();
 		this.embedded = (NonAggregatedIdentifierMapping) resultDescriptor.getReferencedMappingContainer();
@@ -107,7 +117,7 @@ public NonAggregatedIdentifierMappingInitializer(
 		this.hasIdClass = embedded.hasContainingClass() && virtualIdEmbeddable != representationEmbeddable;
 
 		this.sessionFactory = creationState.getSqlAstCreationContext().getSessionFactory();
-		this.assemblers = createAssemblers( this, resultDescriptor, creationState, virtualIdEmbeddable );
+		this.assemblers = createAssemblers( this, resultDescriptor, creationState, virtualIdEmbeddable, fetchConverter );
 		final ArrayList<Initializer<?>> initializers = new ArrayList<>( assemblers.length );
 		for ( DomainResultAssembler<?> assembler : assemblers ) {
 			final Initializer<?> initializer = assembler.getInitializer();
@@ -125,12 +135,13 @@ protected static DomainResultAssembler<?>[] createAssemblers(
 			InitializerParent<?> parent,
 			EmbeddableResultGraphNode resultDescriptor,
 			AssemblerCreationState creationState,
-			EmbeddableMappingType embeddableTypeDescriptor) {
+			EmbeddableMappingType embeddableTypeDescriptor,
+			Function<Fetch, Fetch> fetchConverter) {
 		final int size = embeddableTypeDescriptor.getNumberOfFetchables();
 		final DomainResultAssembler<?>[] assemblers = new DomainResultAssembler[size];
 		for ( int i = 0; i < size; i++ ) {
 			final Fetchable stateArrayContributor = embeddableTypeDescriptor.getFetchable( i );
-			final Fetch fetch = resultDescriptor.findFetch( stateArrayContributor );
+			final Fetch fetch = fetchConverter.apply( resultDescriptor.findFetch( stateArrayContributor ) );
 
 			final DomainResultAssembler<?> stateAssembler = fetch == null
 					? new NullValueAssembler<>( stateArrayContributor.getJavaType() )
@@ -340,6 +351,13 @@ public boolean isPartOfKey() {
 		return true;
 	}
 
+	/*
+	 * Used by Hibernate Reactive
+	 */
+	protected Initializer<InitializerData>[] getInitializers() {
+		return initializers;
+	}
+
 	@Override
 	public String toString() {
 		return "NonAggregatedIdentifierMappingInitializer(" + navigablePath + ") : `" + getInitializedPart().getJavaType().getJavaTypeClass() + "`";

hibernate-core/src/main/java/org/hibernate/sql/results/graph/entity/internal/EntityDelayedFetchInitializer.java

@@ -315,4 +315,7 @@ protected DomainResultAssembler<?> getIdentifierAssembler() {
 		return identifierAssembler;
 	}
 
+	protected @Nullable BasicResultAssembler<?> getDiscriminatorAssembler() {
+		return discriminatorAssembler;
+	}
 }

hibernate-core/src/main/java/org/hibernate/sql/results/graph/entity/internal/EntityInitializerImpl.java

@@ -143,6 +143,23 @@ public static class EntityInitializerData extends InitializerData {
 		public EntityInitializerData(RowProcessingState rowProcessingState) {
 			super( rowProcessingState );
 		}
+
+		/*
+		 * Used by Hibernate Reactive
+		 */
+		public EntityInitializerData(EntityInitializerData original) {
+			super( original );
+			this.shallowCached = original.shallowCached;
+			this.lockMode = original.lockMode;
+			this.uniqueKeyAttributePath = original.uniqueKeyAttributePath;
+			this.uniqueKeyPropertyTypes = original.uniqueKeyPropertyTypes;
+			this.canUseEmbeddedIdentifierInstanceAsEntity = original.canUseEmbeddedIdentifierInstanceAsEntity;
+			this.hasCallbackActions = original.hasCallbackActions;
+			this.concreteDescriptor = original.concreteDescriptor;
+			this.entityKey = original.entityKey;
+			this.entityInstanceForNotify = original.entityInstanceForNotify;
+			this.entityHolder = original.entityHolder;
+		}
 	}
 
 	public EntityInitializerImpl(
@@ -473,7 +490,7 @@ private void notifySubInitializersToReusePreviousRowInstance(EntityInitializerDa
 		}
 	}
 
-	private void resolveKeySubInitializers(EntityInitializerData data) {
+	protected void resolveKeySubInitializers(EntityInitializerData data) {
 		final RowProcessingState rowProcessingState = data.getRowProcessingState();
 		for ( Initializer<?> initializer : subInitializers[data.concreteDescriptor.getSubclassId()] ) {
 			if ( initializer != null ) {
@@ -714,7 +731,7 @@ protected void initializeAttributeType(Type[] attributeTypes, EntityPersister en
 		}
 	}
 
-	private boolean useEmbeddedIdentifierInstanceAsEntity(EntityInitializerData data) {
+	protected boolean useEmbeddedIdentifierInstanceAsEntity(EntityInitializerData data) {
 		return data.canUseEmbeddedIdentifierInstanceAsEntity
 				&& ( data.concreteDescriptor = determineConcreteEntityDescriptor( data.getRowProcessingState(), discriminatorAssembler, entityDescriptor ) ) != null
 				&& data.concreteDescriptor.isInstance( data.getRowProcessingState().getEntityId() );
@@ -939,7 +956,7 @@ protected Object getEntityFromExecutionContext(EntityInitializerData data) {
 		return null;
 	}
 
-	private void upgradeLockMode(EntityInitializerData data) {
+	protected void upgradeLockMode(EntityInitializerData data) {
 		final RowProcessingState rowProcessingState = data.getRowProcessingState();
 		if ( data.lockMode != LockMode.NONE && rowProcessingState.upgradeLocks() ) {
 			final EntityEntry entry = data.entityHolder.getEntityEntry();
@@ -1117,7 +1134,7 @@ protected boolean consistentInstance(EntityInitializerData data) {
 		return entity == null || entity == data.entityInstanceForNotify;
 	}
 
-	private void initializeEntityInstance(EntityInitializerData data) {
+	protected void initializeEntityInstance(EntityInitializerData data) {
 		final RowProcessingState rowProcessingState = data.getRowProcessingState();
 		final Object entityIdentifier = data.entityKey.getIdentifier();
 		final SharedSessionContractImplementor session = rowProcessingState.getSession();
@@ -1379,7 +1396,7 @@ protected Object[] extractConcreteTypeStateValues(EntityInitializerData data) {
 		return values;
 	}
 
-	private void resolveState(EntityInitializerData data) {
+	protected void resolveState(EntityInitializerData data) {
 		final RowProcessingState rowProcessingState = data.getRowProcessingState();
 		for ( final DomainResultAssembler<?> assembler : assemblers[data.concreteDescriptor.getSubclassId()] ) {
 			if ( assembler != null ) {
@@ -1527,16 +1544,31 @@ public String toString() {
 	// For Hibernate Reactive
 	//#########################
 
-	protected DomainResultAssembler<?> getVersionAssembler() {
+	protected @Nullable DomainResultAssembler<?> getVersionAssembler() {
 		return versionAssembler;
 	}
 
-	protected DomainResultAssembler<Object> getRowIdAssembler() {
+	protected @Nullable DomainResultAssembler<Object> getRowIdAssembler() {
 		return rowIdAssembler;
 	}
 
-	protected DomainResultAssembler<?>[][] getAssemblers() {
+	protected @Nullable DomainResultAssembler<?>[][] getAssemblers() {
 		return assemblers;
 	}
 
+	protected @Nullable BasicResultAssembler<?> getDiscriminatorAssembler() {
+		return discriminatorAssembler;
+	}
+
+	protected boolean isKeyManyToOne() {
+		return hasKeyManyToOne;
+	}
+
+	protected Initializer<?>[][] getSubInitializers() {
+		return subInitializers;
+	}
+
+	public @Nullable DomainResultAssembler<?> getKeyAssembler() {
+		return keyAssembler;
+	}
 }

hibernate-core/src/main/java/org/hibernate/sql/results/graph/entity/internal/EntitySelectFetchInitializer.java

@@ -64,6 +64,13 @@ public EntitySelectFetchInitializerData(RowProcessingState rowProcessingState) {
 			super( rowProcessingState );
 		}
 
+		/*
+		 * Used by Hibernate Reactive
+		 */
+		public EntitySelectFetchInitializerData(EntitySelectFetchInitializerData original) {
+			super( original );
+			this.entityIdentifier = original.entityIdentifier;
+		}
 	}
 
 	public EntitySelectFetchInitializer(
@@ -312,4 +319,7 @@ public String toString() {
 		return "EntitySelectFetchInitializer(" + LoggingHelper.toLoggableString( getNavigablePath() ) + ")";
 	}
 
+	public DomainResultAssembler<?> getKeyAssembler() {
+		return keyAssembler;
+	}
 }