@@ -100,109 +100,124 @@ public CompletionStage<Void> reactiveResolveInstance(EntityDelayedFetchInitializ
100100 final RowProcessingState rowProcessingState = data .getRowProcessingState ();
101101 data .setEntityIdentifier ( getIdentifierAssembler ().assemble ( rowProcessingState ) );
102102
103- CompletionStage <Void > stage = voidFuture ();
104103 if ( data .getEntityIdentifier () == null ) {
105104 data .setInstance ( null );
106105 data .setState ( State .MISSING );
106+ return voidFuture ();
107107 }
108- else {
109- final SharedSessionContractImplementor session = rowProcessingState .getSession ();
110-
111- final EntityPersister entityPersister = referencedModelPart .getEntityMappingType ().getEntityPersister ();
112- final EntityPersister concreteDescriptor ;
113- if ( getDiscriminatorAssembler () != null ) {
114- concreteDescriptor = determineConcreteEntityDescriptor ( rowProcessingState , getDiscriminatorAssembler (), entityPersister );
115- if ( concreteDescriptor == null ) {
116- // If we find no discriminator it means there's no entity in the target table
117- if ( !referencedModelPart .isOptional () ) {
118- throw new FetchNotFoundException ( entityPersister .getEntityName (), data .getEntityIdentifier () );
119- }
120- data .setInstance ( null );
121- data .setState ( State .MISSING );
122- return voidFuture ();
123- }
124- }
125- else {
126- concreteDescriptor = entityPersister ;
127- }
128108
129- final PersistenceContext persistenceContext = session .getPersistenceContextInternal ();
130- if ( isSelectByUniqueKey () ) {
131- final String uniqueKeyPropertyName = referencedModelPart .getReferencedPropertyName ();
132- final Type uniqueKeyPropertyType = uniqueKeyPropertyName == null
133- ? concreteDescriptor .getIdentifierType ()
134- : session .getFactory ().getRuntimeMetamodels ().getReferencedPropertyType ( concreteDescriptor .getEntityName (), uniqueKeyPropertyName );
135- final EntityUniqueKey euk = new EntityUniqueKey (
136- concreteDescriptor .getEntityName (),
137- uniqueKeyPropertyName ,
138- data .getEntityIdentifier (),
139- uniqueKeyPropertyType ,
140- session .getFactory ()
141- );
142- data .setInstance ( persistenceContext .getEntity ( euk ) );
143- if ( data .getInstance () == null ) {
144- // For unique-key mappings, we always use bytecode-laziness if possible,
145- // because we can't generate a proxy based on the unique key yet
146- if ( referencedModelPart .isLazy () ) {
147- data .setInstance ( LazyPropertyInitializer .UNFETCHED_PROPERTY );
148- }
149- else {
150- stage = stage
151- .thenCompose ( v -> ( (ReactiveEntityPersister ) concreteDescriptor )
152- .reactiveLoadByUniqueKey (
153- uniqueKeyPropertyName ,
154- data .getEntityIdentifier (),
155- session
156- ) )
157- .thenAccept ( data ::setInstance )
158- .thenAccept ( v -> {
159- // If the entity was not in the Persistence Context, but was found now,
160- // add it to the Persistence Context
161- if ( data .getInstance () != null ) {
162- persistenceContext .addEntity ( euk , data .getInstance () );
163- }
164- } );
165- }
109+ final EntityPersister entityPersister = referencedModelPart .getEntityMappingType ().getEntityPersister ();
110+ final EntityPersister concreteDescriptor ;
111+ if ( getDiscriminatorAssembler () != null ) {
112+ concreteDescriptor = determineConcreteEntityDescriptor (
113+ rowProcessingState ,
114+ getDiscriminatorAssembler (),
115+ entityPersister
116+ );
117+ if ( concreteDescriptor == null ) {
118+ // If we find no discriminator it means there's no entity in the target table
119+ if ( !referencedModelPart .isOptional () ) {
120+ throw new FetchNotFoundException ( entityPersister .getEntityName (), data .getEntityIdentifier () );
166121 }
167- stage = stage .thenAccept ( v -> {
168- if ( data .getInstance () != null ) {
169- data .setInstance ( persistenceContext .proxyFor ( data .getInstance () ) );
170- }
171- } );
122+ data .setInstance ( null );
123+ data .setState ( State .MISSING );
124+ return voidFuture ();
172125 }
173- else {
174- final EntityKey entityKey = new EntityKey ( data .getEntityIdentifier (), concreteDescriptor );
175- final EntityHolder holder = persistenceContext .getEntityHolder ( entityKey );
176- if ( holder != null && holder .getEntity () != null ) {
177- data .setInstance ( persistenceContext .proxyFor ( holder , concreteDescriptor ) );
178- }
179- // For primary key based mappings we only use bytecode-laziness if the attribute is optional,
180- // because the non-optionality implies that it is safe to have a proxy
181- else if ( referencedModelPart .isOptional () && referencedModelPart .isLazy () ) {
126+ }
127+ else {
128+ concreteDescriptor = entityPersister ;
129+ }
130+
131+ return initialize ( data , null , concreteDescriptor );
132+ }
133+
134+ private CompletionStage <Void > initialize (
135+ ReactiveEntityDelayedFetchInitializerData data ,
136+ EntityKey entityKey ,
137+ EntityPersister concreteDescriptor ) {
138+ final RowProcessingState rowProcessingState = data .getRowProcessingState ();
139+ final SharedSessionContractImplementor session = rowProcessingState .getSession ();
140+ final PersistenceContext persistenceContext = session .getPersistenceContextInternal ();
141+ if ( isSelectByUniqueKey () ) {
142+ final String uniqueKeyPropertyName = referencedModelPart .getReferencedPropertyName ();
143+ final Type uniqueKeyPropertyType = uniqueKeyPropertyName == null
144+ ? concreteDescriptor .getIdentifierType ()
145+ : session .getFactory ()
146+ .getRuntimeMetamodels ()
147+ .getReferencedPropertyType ( concreteDescriptor .getEntityName (), uniqueKeyPropertyName );
148+ final EntityUniqueKey euk = new EntityUniqueKey (
149+ concreteDescriptor .getEntityName (),
150+ uniqueKeyPropertyName ,
151+ data .getEntityIdentifier (),
152+ uniqueKeyPropertyType ,
153+ session .getFactory ()
154+ );
155+ data .setInstance ( persistenceContext .getEntity ( euk ) );
156+ CompletionStage <Void > stage = voidFuture ();
157+ if ( data .getInstance () == null ) {
158+ // For unique-key mappings, we always use bytecode-laziness if possible,
159+ // because we can't generate a proxy based on the unique key yet
160+ if ( referencedModelPart .isLazy () ) {
182161 data .setInstance ( LazyPropertyInitializer .UNFETCHED_PROPERTY );
183162 }
184163 else {
185- stage = stage .thenCompose ( v -> ReactiveQueryExecutorLookup
186- .extract ( session )
187- .reactiveInternalLoad (
188- concreteDescriptor .getEntityName (),
189- data .getEntityIdentifier (),
190- false ,
191- false
192- )
164+ stage = stage
165+ .thenCompose ( v -> ( (ReactiveEntityPersister ) concreteDescriptor )
166+ .reactiveLoadByUniqueKey (
167+ uniqueKeyPropertyName ,
168+ data .getEntityIdentifier (),
169+ session
170+ ) )
193171 .thenAccept ( data ::setInstance )
194- );
172+ .thenAccept ( v -> {
173+ // If the entity was not in the Persistence Context, but was found now,
174+ // add it to the Persistence Context
175+ if ( data .getInstance () != null ) {
176+ persistenceContext .addEntity ( euk , data .getInstance () );
177+ }
178+ } );
179+ }
180+ }
181+ return stage .thenAccept ( v -> {
182+ if ( data .getInstance () != null ) {
183+ data .setInstance ( persistenceContext .proxyFor ( data .getInstance () ) );
195184 }
196- stage = stage
197- .thenAccept ( v -> {
198- final LazyInitializer lazyInitializer = HibernateProxy .extractLazyInitializer ( data .getInstance () );
199- if ( lazyInitializer != null ) {
200- lazyInitializer .setUnwrap ( referencedModelPart .isUnwrapProxy () && concreteDescriptor .isInstrumented () );
201- }
202- } );
185+ } );
186+ }
187+ else {
188+ CompletionStage <Void > stage = voidFuture ();
189+ final EntityKey ek = entityKey == null
190+ ? new EntityKey ( data .getEntityIdentifier (), concreteDescriptor )
191+ : entityKey ;
192+ final EntityHolder holder = persistenceContext .getEntityHolder ( ek );
193+ if ( holder != null && holder .getEntity () != null ) {
194+ data .setInstance ( persistenceContext .proxyFor ( holder , concreteDescriptor ) );
195+ }
196+ // For primary key based mappings we only use bytecode-laziness if the attribute is optional,
197+ // because the non-optionality implies that it is safe to have a proxy
198+ else if ( referencedModelPart .isOptional () && referencedModelPart .isLazy () ) {
199+ data .setInstance ( LazyPropertyInitializer .UNFETCHED_PROPERTY );
200+ }
201+ else {
202+ stage = stage .thenCompose ( v -> ReactiveQueryExecutorLookup
203+ .extract ( session )
204+ .reactiveInternalLoad (
205+ concreteDescriptor .getEntityName (),
206+ data .getEntityIdentifier (),
207+ false ,
208+ false
209+ )
210+ .thenAccept ( data ::setInstance )
211+ );
203212 }
213+ return stage
214+ .thenAccept ( v -> {
215+ final LazyInitializer lazyInitializer = HibernateProxy .extractLazyInitializer ( data .getInstance () );
216+ if ( lazyInitializer != null ) {
217+ lazyInitializer .setUnwrap ( referencedModelPart .isUnwrapProxy () && concreteDescriptor .isInstrumented () );
218+ }
219+ } );
204220 }
205- return stage ;
206221 }
207222
208223 @ Override
0 commit comments