org.hibernate.loader.entity.UniqueEntityLoader Java Examples

private UniqueEntityLoader getAppropriateLoader(LockMode lockMode, SessionImplementor session) {
	final Map enabledFilters = session.getEnabledFilters();
	if ( queryLoader != null ) {
		return queryLoader;
	}
	else if ( enabledFilters == null || enabledFilters.isEmpty() ) {
		if ( session.getFetchProfile()!=null && LockMode.UPGRADE.greaterThan(lockMode) ) {
			return (UniqueEntityLoader) loaders.get( session.getFetchProfile() );
		}
		else {
			return (UniqueEntityLoader) loaders.get( lockMode );
		}
	}
	else {
		return createEntityLoader( lockMode, enabledFilters );
	}
}
 

@Override
protected UniqueEntityLoader buildNonBatchingLoader(
		OuterJoinLoadable persister,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return EntityLoader.forEntity( persister ).withLockMode( lockMode ).withInfluencers( influencers ).byPrimaryKey();
}
 

/**
 * Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>,
 * depending upon the value of the <tt>lock</tt> parameter
 */
public Object load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)
		throws HibernateException {

	if ( log.isTraceEnabled() ) {
		log.trace(
				"Fetching entity: " +
				MessageHelper.infoString( this, id, getFactory() )
			);
	}

	final UniqueEntityLoader loader = getAppropriateLoader( lockMode, session );
	return loader.load( id, optionalObject, session );
}
 

private void createLoaders() {
	loaders.put( LockMode.NONE, createEntityLoader( LockMode.NONE ) );

	UniqueEntityLoader readLoader = createEntityLoader( LockMode.READ );
	loaders.put( LockMode.READ, readLoader );

	//TODO: inexact, what we really need to know is: are any outer joins used?
	boolean disableForUpdate = getSubclassTableSpan() > 1 &&
			hasSubclasses() &&
			!getFactory().getDialect().supportsOuterJoinForUpdate();

	loaders.put(
			LockMode.UPGRADE,
			disableForUpdate ?
					readLoader :
					createEntityLoader( LockMode.UPGRADE )
		);
	loaders.put(
			LockMode.UPGRADE_NOWAIT,
			disableForUpdate ?
					readLoader :
					createEntityLoader( LockMode.UPGRADE_NOWAIT )
		);
	loaders.put(
			LockMode.FORCE,
			disableForUpdate ?
					readLoader :
					createEntityLoader( LockMode.FORCE )
		);

	loaders.put(
			"merge",
			new CascadeEntityLoader( this, CascadingAction.MERGE, getFactory() )
		);
	loaders.put(
			"refresh",
			new CascadeEntityLoader( this, CascadingAction.REFRESH, getFactory() )
		);
}
 

protected UniqueEntityLoader getAppropriateLoader(LockOptions lockOptions, SharedSessionContractImplementor session) {
	if ( queryLoader != null ) {
		// if the user specified a custom query loader we need to that
		// regardless of any other consideration
		return queryLoader;
	}
	else if ( isAffectedByEnabledFilters( session ) ) {
		// because filters affect the rows returned (because they add
		// restrictions) these need to be next in precedence
		return createEntityLoader( lockOptions, session.getLoadQueryInfluencers() );
	}
	else if ( session.getLoadQueryInfluencers().getInternalFetchProfile() != null && LockMode.UPGRADE.greaterThan(
			lockOptions.getLockMode()
	) ) {
		// Next, we consider whether an 'internal' fetch profile has been set.
		// This indicates a special fetch profile Hibernate needs applied
		// (for its merge loading process e.g.).
		return loaders.get( session.getLoadQueryInfluencers().getInternalFetchProfile() );
	}
	else if ( isAffectedByEnabledFetchProfiles( session ) ) {
		// If the session has associated influencers we need to adjust the
		// SQL query used for loading based on those influencers
		return createEntityLoader( lockOptions, session.getLoadQueryInfluencers() );
	}
	else if ( isAffectedByEntityGraph( session ) ) {
		return createEntityLoader( lockOptions, session.getLoadQueryInfluencers() );
	}
	else if ( lockOptions.getTimeOut() != LockOptions.WAIT_FOREVER ) {
		return createEntityLoader( lockOptions, session.getLoadQueryInfluencers() );
	}
	else {
		return getLoaderByLockMode( lockOptions.getLockMode() );
	}
}
 

/**
 * Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>,
 * depending upon the value of the <tt>lock</tt> parameter
 */
public Object load(Serializable id, Object optionalObject, LockOptions lockOptions, SharedSessionContractImplementor session)
		throws HibernateException {

	if ( LOG.isTraceEnabled() ) {
		LOG.tracev( "Fetching entity: {0}", MessageHelper.infoString( this, id, getFactory() ) );
	}

	final UniqueEntityLoader loader = getAppropriateLoader( lockOptions, session );
	return loader.load( id, optionalObject, session, lockOptions );
}
 

private UniqueEntityLoader generateDelayedEntityLoader(Object lockModeObject) {
	// Unfortunately, the loaders map mixes LockModes and Strings as keys so we need to accept an Object.
	// The cast is safe as we will always call this method with a LockMode.
	LockMode lockMode = (LockMode) lockModeObject;

	switch ( lockMode ) {
		case NONE:
		case READ:
		case OPTIMISTIC:
		case OPTIMISTIC_FORCE_INCREMENT: {
			return createEntityLoader( lockMode );
		}
		case UPGRADE:
		case UPGRADE_NOWAIT:
		case UPGRADE_SKIPLOCKED:
		case FORCE:
		case PESSIMISTIC_READ:
		case PESSIMISTIC_WRITE:
		case PESSIMISTIC_FORCE_INCREMENT: {
			//TODO: inexact, what we really need to know is: are any outer joins used?
			boolean disableForUpdate = getSubclassTableSpan() > 1
					&& hasSubclasses()
					&& !getFactory().getDialect().supportsOuterJoinForUpdate();

			return disableForUpdate ? readLockLoader : createEntityLoader( lockMode );
		}
		default: {
			throw new IllegalStateException( String.format( Locale.ROOT, "Lock mode %1$s not supported by entity loaders.", lockMode ) );
		}
	}
}
 

protected final UniqueEntityLoader getLoaderByLockMode(LockMode lockMode) {
	if ( LockMode.NONE == lockMode ) {
		return noneLockLoader;
	}
	else if ( LockMode.READ == lockMode ) {
		return readLockLoader;
	}

	return loaders.computeIfAbsent( lockMode, this::generateDelayedEntityLoader );
}
 

protected UniqueEntityLoader createEntityLoader(
		LockOptions lockOptions,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	//TODO: disable batch loading if lockMode > READ?
	return BatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockOptions, getFactory(), loadQueryInfluencers );
}
 

protected UniqueEntityLoader createEntityLoader(
		LockMode lockMode,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	//TODO: disable batch loading if lockMode > READ?
	return BatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockMode, getFactory(), loadQueryInfluencers );
}
 

@Override
protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new LegacyBatchingEntityLoader( persister, batchSize, lockOptions, factory, influencers );
}
 

@Override
protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new LegacyBatchingEntityLoader( persister, batchSize, lockMode, factory, influencers );
}
 

@Override
protected UniqueEntityLoader buildNonBatchingLoader(
		OuterJoinLoadable persister,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return EntityLoader.forEntity( persister ).withLockOptions( lockOptions ).withInfluencers( influencers ).byPrimaryKey();
}
 

@Override
protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new ReactiveDynamicBatchingEntityDelegator( persister, batchSize, lockMode, factory, influencers );
}
 

protected UniqueEntityLoader buildNonBatchingLoader(
			OuterJoinLoadable persister,
			LockOptions lockOptions,
			SessionFactoryImplementor factory,
			LoadQueryInfluencers influencers) {
		return new ReactivePlanEntityLoader.Builder( persister )
				.withLockMode( lockOptions.getLockMode() )
				.withInfluencers( influencers )
				.byPrimaryKey();
//		return new ReactiveEntityLoader( persister, factory, lockOptions.getLockMode(), influencers);
	}
 

@Override
protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new ReactiveDynamicBatchingEntityDelegator( persister, batchSize, lockOptions, factory, influencers );
}
 

@Override
protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new ReactivePaddedBatchingEntityLoader( persister, batchSize, lockMode, factory, influencers );
}
 

@Override
protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new ReactivePaddedBatchingEntityLoader( persister, batchSize, lockOptions, factory, influencers );
}
 

/**
 * Builds a batch-fetch capable loader based on the given persister, lock-mode, etc.
 *
 * @param persister The entity persister
 * @param batchSize The maximum number of ids to batch-fetch at once
 * @param lockMode The lock mode
 * @param factory The SessionFactory
 * @param influencers Any influencers that should affect the built query
 *
 * @return The loader.
 */
public UniqueEntityLoader buildLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	if ( batchSize <= 1 ) {
		// no batching
		return buildNonBatchingLoader( persister, lockMode, factory, influencers );
	}
	return buildBatchingLoader( persister, batchSize, lockMode, factory, influencers );
}
 

protected UniqueEntityLoader buildNonBatchingLoader(
			OuterJoinLoadable persister,
			LockMode lockMode,
			SessionFactoryImplementor factory,
			LoadQueryInfluencers influencers) {
		return new ReactivePlanEntityLoader.Builder( persister )
				.withLockMode( lockMode )
				.withInfluencers( influencers )
				.byPrimaryKey();
//		return new ReactiveEntityLoader( persister, factory, lockMode, influencers);
	}
 

/**
 * Builds a batch-fetch capable loader based on the given persister, lock-options, etc.
 *
 * @param persister The entity persister
 * @param batchSize The maximum number of ids to batch-fetch at once
 * @param lockOptions The lock options
 * @param factory The SessionFactory
 * @param influencers Any influencers that should affect the built query
 *
 * @return The loader.
 */
public UniqueEntityLoader buildLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	if ( batchSize <= 1 ) {
		// no batching
		return buildNonBatchingLoader( persister, lockOptions, factory, influencers );
	}
	return buildBatchingLoader( persister, batchSize, lockOptions, factory, influencers );
}
 

protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new ReactiveEntityLoader( persister, factory, lockMode, influencers);
}
 

protected UniqueEntityLoader buildBatchingLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return new ReactiveEntityLoader( persister, factory, lockOptions.getLockMode(), influencers);
}
 

@Override
protected UniqueEntityLoader createEntityLoader(LockMode lockMode, LoadQueryInfluencers loadQueryInfluencers)
		throws MappingException {
	return ReactiveBatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockMode, getFactory(), loadQueryInfluencers );
}
 

@Override
protected UniqueEntityLoader createEntityLoader(LockMode lockMode, LoadQueryInfluencers loadQueryInfluencers)
		throws MappingException {
	return ReactiveBatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockMode, getFactory(), loadQueryInfluencers );
}
 

@Override
protected UniqueEntityLoader createEntityLoader(LockOptions lockOptions, LoadQueryInfluencers loadQueryInfluencers)
		throws MappingException {
	return ReactiveBatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockOptions, getFactory(), loadQueryInfluencers );
}
 

protected UniqueEntityLoader createEntityLoader(LockMode lockMode, Map enabledFilters) throws MappingException {
	//TODO: disable batch loading if lockMode > READ?
	return BatchingEntityLoader.createBatchingEntityLoader( this, batchSize, lockMode, getFactory(), enabledFilters );
}
 

protected UniqueEntityLoader createEntityLoader(LockMode lockMode) throws MappingException {
	return createEntityLoader( lockMode, CollectionHelper.EMPTY_MAP );
}
 

@Override
protected UniqueEntityLoader createEntityLoader(LockMode lockMode, LoadQueryInfluencers loadQueryInfluencers)
		throws MappingException {
	return ReactiveBatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockMode, getFactory(), loadQueryInfluencers );
}
 

@Override
protected UniqueEntityLoader createEntityLoader(LockOptions lockOptions, LoadQueryInfluencers loadQueryInfluencers)
		throws MappingException {
	return ReactiveBatchingEntityLoaderBuilder.getBuilder( getFactory() )
			.buildLoader( this, batchSize, lockOptions, getFactory(), loadQueryInfluencers );
}