Skip to content

Commit c5dd2c3

Browse files
gavinkinggavinking
committed
reorganize code in AbstractMultiNaturalIdLoader and AbstractMultiIdEntityLoader
1 parent 32bf13d commit c5dd2c3

File tree

6 files changed

+130
-106
lines changed

6 files changed

+130
-106
lines changed

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/AbstractMultiIdEntityLoader.java‎

Lines changed: 19 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -92,27 +92,28 @@ private List<T> performUnorderedMultiLoad(
9292
assert !loadOptions.isOrderReturnEnabled();
9393
assert ids != null;
9494
if ( MULTI_KEY_LOAD_LOGGER.isTraceEnabled() ) {
95-
MULTI_KEY_LOAD_LOGGER.tracef( "#performUnorderedMultiLoad(`%s`, ..)", getLoadable().getEntityName() );
95+
MULTI_KEY_LOAD_LOGGER.tracef( "Unordered MultiLoad starting: "
96+
+ getLoadable().getEntityName() );
9697
}
97-
return unorderedMultiLoad( ids, loadOptions, lockOptions( loadOptions ), session );
98+
return unorderedMultiLoad( ids, loadOptions, session );
9899
}
99100

100-
protected List<T> performOrderedMultiLoad(
101+
private List<T> performOrderedMultiLoad(
101102
Object[] ids,
102103
MultiIdLoadOptions loadOptions,
103104
SharedSessionContractImplementor session) {
104105
assert loadOptions.isOrderReturnEnabled();
105106
assert ids != null;
106107
if ( MULTI_KEY_LOAD_LOGGER.isTraceEnabled() ) {
107-
MULTI_KEY_LOAD_LOGGER.tracef( "#performOrderedMultiLoad(`%s`, ..)", getLoadable().getEntityName() );
108+
MULTI_KEY_LOAD_LOGGER.tracef( "Ordered MultiLoad starting: "
109+
+ getLoadable().getEntityName() );
108110
}
109-
return orderedMultiLoad( ids, loadOptions, lockOptions( loadOptions ), session );
111+
return orderedMultiLoad( ids, loadOptions, session );
110112
}
111113

112114
private List<T> orderedMultiLoad(
113115
Object[] ids,
114116
MultiIdLoadOptions loadOptions,
115-
LockOptions lockOptions,
116117
SharedSessionContractImplementor session) {
117118
final boolean idCoercionEnabled = isIdCoercionEnabled();
118119
final JavaType<?> idType = getLoadable().getIdentifierMapping().getJavaType();
@@ -124,6 +125,8 @@ private List<T> orderedMultiLoad(
124125
final List<Object> idsInBatch = new ArrayList<>();
125126
final List<Integer> elementPositionsLoadedByBatch = new ArrayList<>();
126127

128+
final LockOptions lockOptions = lockOptions( loadOptions );
129+
127130
for ( int i = 0; i < ids.length; i++ ) {
128131
final Object id = idCoercionEnabled ? idType.coerce( ids[i], session ) : ids[i];
129132
final EntityKey entityKey = new EntityKey( id, getLoadable().getEntityPersister() );
@@ -158,15 +161,15 @@ private List<T> orderedMultiLoad(
158161
return (List<T>) result;
159162
}
160163

161-
protected static LockOptions lockOptions(MultiIdLoadOptions loadOptions) {
164+
private static LockOptions lockOptions(MultiIdLoadOptions loadOptions) {
162165
return loadOptions.getLockOptions() == null
163166
? new LockOptions( LockMode.NONE )
164167
: loadOptions.getLockOptions();
165168
}
166169

167170
protected abstract int maxBatchSize(Object[] ids, MultiIdLoadOptions loadOptions);
168171

169-
protected void handleResults(
172+
private void handleResults(
170173
MultiIdLoadOptions loadOptions,
171174
SharedSessionContractImplementor session,
172175
List<Integer> elementPositionsLoadedByBatch,
@@ -199,7 +202,7 @@ protected abstract void loadEntitiesById(
199202
MultiIdLoadOptions loadOptions,
200203
SharedSessionContractImplementor session);
201204

202-
protected boolean loadFromEnabledCaches(
205+
private boolean loadFromEnabledCaches(
203206
MultiIdLoadOptions loadOptions,
204207
SharedSessionContractImplementor session,
205208
Object id,
@@ -250,14 +253,14 @@ private boolean isLoadFromCaches(
250253
protected List<T> unorderedMultiLoad(
251254
Object[] ids,
252255
MultiIdLoadOptions loadOptions,
253-
LockOptions lockOptions,
254256
SharedSessionContractImplementor session) {
257+
final LockOptions lockOptions = lockOptions( loadOptions );
255258
final List<T> result = arrayList( ids.length );
256259
final Object[] unresolvableIds =
257260
resolveInCachesIfEnabled( ids, loadOptions, lockOptions, session,
258261
(position, entityKey, resolvedRef) -> result.add( (T) resolvedRef ) );
259262
if ( !isEmpty( unresolvableIds ) ) {
260-
loadEntitiesWithUnresolvedIds( loadOptions, lockOptions, session, unresolvableIds, result );
263+
loadEntitiesWithUnresolvedIds( unresolvableIds, loadOptions, lockOptions, result, session );
261264
final BatchFetchQueue batchFetchQueue = session.getPersistenceContextInternal().getBatchFetchQueue();
262265
final EntityPersister persister = getLoadable().getEntityPersister();
263266
for ( Object id : unresolvableIds ) {
@@ -273,13 +276,13 @@ protected List<T> unorderedMultiLoad(
273276
}
274277

275278
protected abstract void loadEntitiesWithUnresolvedIds(
279+
Object[] unresolvableIds,
276280
MultiIdLoadOptions loadOptions,
277281
LockOptions lockOptions,
278-
SharedSessionContractImplementor session,
279-
Object[] unresolvableIds,
280-
List<T> results);
282+
List<T> results,
283+
SharedSessionContractImplementor session);
281284

282-
protected final <R> Object[] resolveInCachesIfEnabled(
285+
private <R> Object[] resolveInCachesIfEnabled(
283286
Object[] ids,
284287
@NonNull MultiIdLoadOptions loadOptions,
285288
@NonNull LockOptions lockOptions,
@@ -296,7 +299,7 @@ protected final <R> Object[] resolveInCachesIfEnabled(
296299
: ids;
297300
}
298301

299-
protected final <R> Object[] resolveInCaches(
302+
private <R> Object[] resolveInCaches(
300303
Object[] ids,
301304
MultiIdLoadOptions loadOptions,
302305
LockOptions lockOptions,

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/AbstractMultiNaturalIdLoader.java‎

Lines changed: 91 additions & 80 deletions
Original file line numberDiff line numberDiff line change
@@ -13,141 +13,152 @@
1313
import org.hibernate.loader.ast.spi.MultiNaturalIdLoadOptions;
1414
import org.hibernate.loader.ast.spi.MultiNaturalIdLoader;
1515
import org.hibernate.metamodel.mapping.EntityMappingType;
16+
import org.hibernate.metamodel.mapping.NaturalIdMapping;
1617

17-
import java.util.Collections;
1818
import java.util.List;
1919

20+
import static java.util.Collections.emptyList;
2021
import static org.hibernate.internal.util.collections.CollectionHelper.arrayList;
2122
import static org.hibernate.internal.util.collections.CollectionHelper.isEmpty;
2223
import static org.hibernate.loader.ast.internal.LoaderHelper.upgradeLock;
24+
import static org.hibernate.loader.ast.internal.MultiKeyLoadLogging.MULTI_KEY_LOAD_LOGGER;
2325

2426
/**
2527
* @author Jan Schatteman
2628
*/
2729
public abstract class AbstractMultiNaturalIdLoader<E> implements MultiNaturalIdLoader<E> {
2830
private final EntityMappingType entityDescriptor;
2931

30-
protected MultiNaturalIdLoadOptions options;
31-
3232
public AbstractMultiNaturalIdLoader(EntityMappingType entityDescriptor) {
3333
this.entityDescriptor = entityDescriptor;
3434
}
3535

3636
@Override
3737
public <K> List<E> multiLoad(K[] naturalIds, MultiNaturalIdLoadOptions options, SharedSessionContractImplementor session) {
3838
assert naturalIds != null;
39-
40-
this.options = options;
41-
4239
if ( naturalIds.length == 0 ) {
43-
return Collections.emptyList();
40+
return emptyList();
41+
}
42+
else {
43+
return options.isOrderReturnEnabled()
44+
? performOrderedMultiLoad( naturalIds, options, session )
45+
: performUnorderedMultiLoad( naturalIds, options, session );
4446
}
45-
46-
return options.isOrderReturnEnabled()
47-
? performOrderedMultiLoad( naturalIds, options, session )
48-
: performUnorderedMultiLoad( naturalIds, options, session );
4947
}
5048

51-
private <K> List<E> performUnorderedMultiLoad(K[] naturalIds, MultiNaturalIdLoadOptions options, SharedSessionContractImplementor session) {
52-
if ( MultiKeyLoadLogging.MULTI_KEY_LOAD_LOGGER.isTraceEnabled() ) {
53-
MultiKeyLoadLogging.MULTI_KEY_LOAD_LOGGER.tracef( "Unordered MultiLoad Starting - `%s`", getEntityDescriptor().getEntityName() );
49+
private <K> List<E> performUnorderedMultiLoad(
50+
K[] naturalIds,
51+
MultiNaturalIdLoadOptions loadOptions,
52+
SharedSessionContractImplementor session) {
53+
if ( MULTI_KEY_LOAD_LOGGER.isTraceEnabled() ) {
54+
MULTI_KEY_LOAD_LOGGER.tracef( "Unordered MultiLoad starting: "
55+
+ getEntityDescriptor().getEntityName() );
5456
}
57+
return unorderedMultiLoad( naturalIds, loadOptions, session );
58+
}
5559

56-
return unorderedMultiLoad(
57-
naturalIds,
58-
session,
59-
options.getLockOptions() == null ? LockOptions.NONE : options.getLockOptions()
60-
);
60+
private static LockOptions lockOptions(MultiNaturalIdLoadOptions loadOptions) {
61+
final LockOptions lockOptions = loadOptions.getLockOptions();
62+
return lockOptions == null ? LockOptions.NONE : lockOptions;
6163
}
6264

63-
protected <K> List<E> unorderedMultiLoad(K[] naturalIds, SharedSessionContractImplementor session, LockOptions lockOptions) {
65+
private <K> List<E> unorderedMultiLoad(
66+
K[] naturalIds,
67+
MultiNaturalIdLoadOptions loadOptions,
68+
SharedSessionContractImplementor session) {
6469
final List<E> results = arrayList( naturalIds.length );
70+
final LockOptions lockOptions = lockOptions( loadOptions );
6571
final Object[] unresolvedIds =
66-
checkPersistenceContextForCachedResults( naturalIds, session, lockOptions, results );
72+
checkPersistenceContextForCachedResults( naturalIds, loadOptions, session, lockOptions, results );
6773
if ( !isEmpty( unresolvedIds ) ) {
68-
results.addAll( loadEntitiesWithUnresolvedIds(unresolvedIds, session, lockOptions) );
74+
results.addAll( loadEntitiesWithUnresolvedIds( unresolvedIds, loadOptions, lockOptions, session ) );
6975
}
70-
7176
return results;
7277
}
7378

74-
protected abstract List<E> loadEntitiesWithUnresolvedIds(Object[] unresolvedIds, SharedSessionContractImplementor session, LockOptions lockOptions);
79+
protected abstract List<E> loadEntitiesWithUnresolvedIds(
80+
Object[] unresolvedIds,
81+
MultiNaturalIdLoadOptions loadOptions,
82+
LockOptions lockOptions,
83+
SharedSessionContractImplementor session);
7584

7685
private <K> List<E> performOrderedMultiLoad(K[] naturalIds, MultiNaturalIdLoadOptions options, SharedSessionContractImplementor session) {
77-
if ( MultiKeyLoadLogging.MULTI_KEY_LOAD_LOGGER.isTraceEnabled() ) {
78-
MultiKeyLoadLogging.MULTI_KEY_LOAD_LOGGER.tracef( "Ordered MultiLoad Starting - `%s`", getEntityDescriptor().getEntityName() );
86+
if ( MULTI_KEY_LOAD_LOGGER.isTraceEnabled() ) {
87+
MULTI_KEY_LOAD_LOGGER.trace( "Ordered MultiLoad starting: "
88+
+ getEntityDescriptor().getEntityName() );
7989
}
80-
81-
return orderedMultiLoad(
82-
naturalIds,
83-
session,
84-
options.getLockOptions() == null ? LockOptions.NONE : options.getLockOptions()
85-
);
90+
return orderedMultiLoad( naturalIds, options, session );
8691
}
8792

88-
protected <K> List<E> orderedMultiLoad( K[] naturalIds, SharedSessionContractImplementor session, LockOptions lockOptions ) {
89-
90-
unorderedMultiLoad( naturalIds, session, lockOptions );
91-
92-
return sortResults( naturalIds, session, lockOptions );
93+
private <K> List<E> orderedMultiLoad(
94+
K[] naturalIds,
95+
MultiNaturalIdLoadOptions loadOptions,
96+
SharedSessionContractImplementor session) {
97+
unorderedMultiLoad( naturalIds, loadOptions, session );
98+
return sortResults( naturalIds, loadOptions, session );
9399
}
94100

95-
protected <K> List<E> sortResults( K[] naturalIds, SharedSessionContractImplementor session, LockOptions lockOptions ) {
96-
List<E> results = arrayList(naturalIds.length);
97-
for ( int i = 0; i < naturalIds.length; i++ ) {
98-
final PersistenceContext persistenceContext = session.getPersistenceContextInternal();
99-
100-
Object id = persistenceContext.getNaturalIdResolutions().findCachedIdByNaturalId( naturalIds[i], getEntityDescriptor() );
101-
102-
// Id can be null if a non-existent natural id is requested
103-
Object entity = (id == null) ? null : persistenceContext.getEntity( new EntityKey( id, getEntityDescriptor().getEntityPersister() ) );
104-
if ( entity != null && !options.isReturnOfDeletedEntitiesEnabled() ) {
105-
// make sure it is not DELETED
106-
final EntityEntry entry = persistenceContext.getEntry( entity );
107-
if ( entry.getStatus().isDeletedOrGone() ) {
108-
// the entity is locally deleted, and the options ask that we not return such entities...
109-
entity = null;
110-
}
111-
else {
112-
entity = persistenceContext.proxyFor( entity );
113-
}
101+
private <K> List<E> sortResults(
102+
K[] naturalIds,
103+
MultiNaturalIdLoadOptions loadOptions,
104+
SharedSessionContractImplementor session) {
105+
final PersistenceContext context = session.getPersistenceContextInternal();
106+
final List<E> results = arrayList( naturalIds.length );
107+
for ( K naturalId : naturalIds ) {
108+
final Object entity = entityForNaturalId( context, naturalId );
109+
final Object result;
110+
if ( entity == null
111+
// the entity is locally deleted, and the options ask that we not return such entities
112+
|| !loadOptions.isReturnOfDeletedEntitiesEnabled()
113+
&& context.getEntry( entity ).getStatus().isDeletedOrGone() ) {
114+
result = null;
114115
}
115-
results.add( (E) entity );
116+
else {
117+
result = context.proxyFor( entity );
118+
}
119+
results.add( (E) result );
116120
}
117-
118121
return results;
119122
}
120123

121-
private <K> Object[] checkPersistenceContextForCachedResults( K[] naturalIds, SharedSessionContractImplementor session, LockOptions lockOptions, List<E> results ) {
122-
List<K> unresolvedIds = arrayList(naturalIds.length);
123-
124-
final PersistenceContext persistenceContext = session.getPersistenceContextInternal();
125-
for ( int i = 0; i < naturalIds.length; i++ ) {
126-
127-
final Object normalizedNaturalId = getEntityDescriptor().getNaturalIdMapping().normalizeInput( naturalIds[i] );
128-
Object id = persistenceContext.getNaturalIdResolutions().findCachedIdByNaturalId( normalizedNaturalId, getEntityDescriptor() );
129-
130-
// Id can be null if a non-existent natural id is requested, or a mutable natural id was changed and then deleted
131-
Object entity = id == null ? null : persistenceContext.getEntity( new EntityKey( id, getEntityDescriptor().getEntityPersister() ) );
124+
private <K> Object entityForNaturalId(PersistenceContext context, K naturalId) {
125+
final EntityMappingType descriptor = getEntityDescriptor();
126+
final Object id = context.getNaturalIdResolutions().findCachedIdByNaturalId( naturalId, descriptor );
127+
// id can be null if a non-existent natural id is requested, or a mutable natural id was changed and then deleted
128+
return id == null ? null : context.getEntity( new EntityKey( id, descriptor.getEntityPersister() ) );
129+
}
132130

131+
private <K> Object[] checkPersistenceContextForCachedResults(
132+
K[] naturalIds,
133+
MultiNaturalIdLoadOptions loadOptions,
134+
SharedSessionContractImplementor session,
135+
LockOptions lockOptions,
136+
List<E> results ) {
137+
final List<K> unresolvedIds = arrayList( naturalIds.length );
138+
final PersistenceContext context = session.getPersistenceContextInternal();
139+
final NaturalIdMapping naturalIdMapping = getEntityDescriptor().getNaturalIdMapping();
140+
for ( K naturalId : naturalIds ) {
141+
final Object entity = entityForNaturalId( context, naturalIdMapping.normalizeInput( naturalId ) );
133142
if ( entity != null ) {
134143
// Entity is already in the persistence context
135-
final EntityEntry entry = persistenceContext.getEntry( entity );
136-
// either a managed entry, or a deleted one with returnDeleted enabled
137-
if ( !entry.getStatus().isDeletedOrGone() || options.isReturnOfDeletedEntitiesEnabled() ) {
138-
results.add( (E) persistenceContext.proxyFor(entity) );
139-
upgradeLock( entity, entry, lockOptions, session.getSession().asEventSource() );
144+
final EntityEntry entry = context.getEntry( entity );
145+
if ( loadOptions.isReturnOfDeletedEntitiesEnabled()
146+
|| !entry.getStatus().isDeletedOrGone() ) {
147+
// either a managed entry, or a deleted one with returnDeleted enabled
148+
upgradeLock( entity, entry, lockOptions, session );
149+
final Object result = context.proxyFor( entity );
150+
results.add( (E) result );
140151
}
141152
}
142153
else {
143-
// entity either doesn't exist or hasn't been loaded in the PC yet, in both cases we add the natural id
144-
// to the ids that still need to be recovered, in case the id corresponds to a non-existent
145-
// instance nothing will be in the results for it, which is ok in unordered multiload
146-
unresolvedIds.add(naturalIds[i]);
154+
// entity either doesn't exist or hasn't been loaded in the PC yet, in both cases we add
155+
// the natural id to the ids that still need to be recovered, in case the id corresponds
156+
// to a nonexistent instance nothing will be in the results for it, which is ok in
157+
// unordered multiload
158+
unresolvedIds.add( naturalId );
147159
}
148160
}
149-
150-
return unresolvedIds.toArray( new Object[0] );
161+
return unresolvedIds.toArray();
151162
}
152163

153164
@Override

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiIdEntityLoaderArrayParam.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -126,11 +126,11 @@ public LockOptions getLockOptions() {
126126

127127
@Override
128128
protected void loadEntitiesWithUnresolvedIds(
129+
Object[] unresolvableIds,
129130
MultiIdLoadOptions loadOptions,
130131
LockOptions lockOptions,
131-
SharedSessionContractImplementor session,
132-
Object[] unresolvableIds,
133-
List<E> result) {
132+
List<E> result,
133+
SharedSessionContractImplementor session) {
134134
final SelectStatement sqlAst = createSelectBySingleArrayParameter(
135135
getLoadable(),
136136
getIdentifierMapping(),

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiIdEntityLoaderInPredicate.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -174,11 +174,11 @@ private List<T> performSingleMultiLoad(Object id, LockOptions lockOptions, Share
174174

175175
@Override
176176
protected void loadEntitiesWithUnresolvedIds(
177+
Object[] unresolvableIds,
177178
MultiIdLoadOptions loadOptions,
178179
LockOptions lockOptions,
179-
SharedSessionContractImplementor session,
180-
Object[] unresolvableIds,
181-
List<T> result) {
180+
List<T> result,
181+
SharedSessionContractImplementor session) {
182182
final int maxBatchSize = maxBatchSize( unresolvableIds, loadOptions );
183183
int numberOfIdsLeft = unresolvableIds.length;
184184
int idPosition = 0;

‎hibernate-core/src/main/java/org/hibernate/loader/ast/internal/MultiNaturalIdLoaderArrayParam.java‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
import org.hibernate.LockOptions;
1010
import org.hibernate.engine.spi.SessionFactoryImplementor;
1111
import org.hibernate.engine.spi.SharedSessionContractImplementor;
12+
import org.hibernate.loader.ast.spi.MultiNaturalIdLoadOptions;
1213
import org.hibernate.loader.ast.spi.SqlArrayMultiKeyLoader;
1314
import org.hibernate.metamodel.mapping.EntityMappingType;
1415
import org.hibernate.metamodel.mapping.JdbcMapping;
@@ -44,7 +45,11 @@ protected BasicAttributeMapping getNaturalIdAttribute() {
4445
}
4546

4647
@Override
47-
public List<E> loadEntitiesWithUnresolvedIds(Object[] naturalIds, SharedSessionContractImplementor session, LockOptions lockOptions) {
48+
public List<E> loadEntitiesWithUnresolvedIds(
49+
Object[] naturalIds,
50+
MultiNaturalIdLoadOptions loadOptions,
51+
LockOptions lockOptions,
52+
SharedSessionContractImplementor session) {
4853

4954
final SessionFactoryImplementor sessionFactory = session.getFactory();
5055

0 commit comments

Comments
 (0)