Java Code Examples for org.hibernate.LockOptions#getLockMode()

/**
 * Get the <tt>FOR UPDATE OF column_list</tt> fragment appropriate for this
 * dialect given the aliases of the columns to be write locked.
 *
 * @param aliases The columns to be write locked.
 * @param lockOptions the lock options to apply
 * @return The appropriate <tt>FOR UPDATE OF column_list</tt> clause string.
 */
@SuppressWarnings({"unchecked", "UnusedParameters"})
public String getForUpdateString(String aliases, LockOptions lockOptions) {
	LockMode lockMode = lockOptions.getLockMode();
	final Iterator<Map.Entry<String, LockMode>> itr = lockOptions.getAliasLockIterator();
	while ( itr.hasNext() ) {
		// seek the highest lock mode
		final Map.Entry<String, LockMode>entry = itr.next();
		final LockMode lm = entry.getValue();
		if ( lm.greaterThan( lockMode ) ) {
			lockMode = lm;
		}
	}
	lockOptions.setLockMode( lockMode );
	return getForUpdateString( lockOptions );
}
 

@Override
public String appendLockHint(LockOptions lockOptions, String tableName) {
	final LockMode mode = lockOptions.getLockMode();
	switch ( mode ) {
		case UPGRADE:
		case UPGRADE_NOWAIT:
		case PESSIMISTIC_WRITE:
		case WRITE:
			return tableName + " with (updlock, rowlock)";
		case PESSIMISTIC_READ:
			return tableName + " with (holdlock, rowlock)";
		case UPGRADE_SKIPLOCKED:
			return tableName + " with (updlock, rowlock, readpast)";
		default:
			return tableName;
	}
}
 

@Override
public void cascade(
		EventSource session,
		Object child,
		String entityName,
		Object anything,
		boolean isCascadeDeleteEnabled) {
	LOG.tracev( "Cascading to lock: {0}", entityName );
	LockMode lockMode = LockMode.NONE;
	LockOptions lr = new LockOptions();
	if ( anything instanceof LockOptions ) {
		LockOptions lockOptions = (LockOptions) anything;
		lr.setTimeOut( lockOptions.getTimeOut() );
		lr.setScope( lockOptions.getScope() );
		lr.setFollowOnLocking( lockOptions.getFollowOnLocking() );
		if ( lockOptions.getScope() ) {
			lockMode = lockOptions.getLockMode();
		}
	}
	lr.setLockMode( lockMode );
	session.buildLockRequest( lr ).lock( entityName, child );
}
 

public ReactiveDynamicBatchingEntityLoader(
		OuterJoinLoadable persister,
		int maxBatchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) {
	this( persister, maxBatchSize, lockOptions.getLockMode(), factory, loadQueryInfluencers );
}
 

@Override
protected LockMode[] getLockModes(LockOptions lockOptions) {

	// unfortunately this stuff can't be cached because
	// it is per-invocation, not constant for the
	// QueryTranslator instance
	HashMap nameLockOptions = new HashMap();
	if ( lockOptions == null ) {
		lockOptions = LockOptions.NONE;
	}

	if ( lockOptions.getAliasLockCount() > 0 ) {
		Iterator iter = lockOptions.getAliasLockIterator();
		while ( iter.hasNext() ) {
			Map.Entry me = (Map.Entry) iter.next();
			nameLockOptions.put(
					getAliasName( (String) me.getKey() ),
					me.getValue()
			);
		}
	}
	LockMode[] lockModesArray = new LockMode[names.length];
	for ( int i = 0; i < names.length; i++ ) {
		LockMode lm = (LockMode) nameLockOptions.get( names[i] );
		//if ( lm == null ) lm = LockOptions.NONE;
		if ( lm == null ) {
			lm = lockOptions.getLockMode();
		}
		lockModesArray[i] = lm;
	}
	return lockModesArray;
}
 

private LoadEvent(
		Serializable entityId,
		String entityClassName,
		Object instanceToLoad,
		LockOptions lockOptions,
		boolean isAssociationFetch,
		EventSource source) {

	super(source);

	if ( entityId == null ) {
		throw new IllegalArgumentException("id to load is required for loading");
	}

	if ( lockOptions.getLockMode() == LockMode.WRITE ) {
		throw new IllegalArgumentException("Invalid lock mode for loading");
	}
	else if ( lockOptions.getLockMode() == null ) {
		lockOptions.setLockMode(DEFAULT_LOCK_MODE);
	}

	this.entityId = entityId;
	this.entityClassName = entityClassName;
	this.instanceToLoad = instanceToLoad;
	this.lockOptions = lockOptions;
	this.isAssociationFetch = isAssociationFetch;
	this.postLoadEvent = new PostLoadEvent( source );
}
 

@Override
public String appendLockHint(LockOptions lockOptions, String tableName) {

	LockMode lockMode = lockOptions.getAliasSpecificLockMode( tableName );
	if(lockMode == null) {
		lockMode = lockOptions.getLockMode();
	}

	final String writeLockStr = lockOptions.getTimeOut() == LockOptions.SKIP_LOCKED ? "updlock" : "updlock, holdlock";
	final String readLockStr = lockOptions.getTimeOut() == LockOptions.SKIP_LOCKED ? "updlock" : "holdlock";

	final String noWaitStr = lockOptions.getTimeOut() == LockOptions.NO_WAIT ? ", nowait" : "";
	final String skipLockStr = lockOptions.getTimeOut() == LockOptions.SKIP_LOCKED ? ", readpast" : "";

	switch ( lockMode ) {
		case UPGRADE:
		case PESSIMISTIC_WRITE:
		case WRITE: {
			return tableName + " with (" + writeLockStr + ", rowlock" + noWaitStr + skipLockStr + ")";
		}
		case PESSIMISTIC_READ: {
			return tableName + " with (" + readLockStr + ", rowlock" + noWaitStr + skipLockStr + ")";
		}
		case UPGRADE_SKIPLOCKED:
			return tableName + " with (updlock, rowlock, readpast" + noWaitStr + ")";
		case UPGRADE_NOWAIT:
			return tableName + " with (updlock, holdlock, rowlock, nowait)";
		default: {
			return tableName;
		}
	}
}
 

/**
 * @param lockOptions a collection of lock modes specified dynamically via the Query interface
 */
@Override
protected LockMode[] getLockModes(LockOptions lockOptions) {
	if ( lockOptions == null ) {
		return defaultLockModes;
	}

	if ( lockOptions.getAliasLockCount() == 0
			&& ( lockOptions.getLockMode() == null || LockMode.NONE.equals( lockOptions.getLockMode() ) ) ) {
		return defaultLockModes;
	}

	// unfortunately this stuff can't be cached because
	// it is per-invocation, not constant for the
	// QueryTranslator instance

	LockMode[] lockModesArray = new LockMode[entityAliases.length];
	for ( int i = 0; i < entityAliases.length; i++ ) {
		LockMode lockMode = lockOptions.getEffectiveLockMode( entityAliases[i] );
		if ( lockMode == null ) {
			//NONE, because its the requested lock mode, not the actual!
			lockMode = LockMode.NONE;
		}
		lockModesArray[i] = lockMode;
	}

	return lockModesArray;
}
 

protected LockMode determineFollowOnLockMode(LockOptions lockOptions) {
	final LockMode lockModeToUse = lockOptions.findGreatestLockMode();

	if ( lockOptions.hasAliasSpecificLockModes() ) {
		if ( lockOptions.getLockMode() == LockMode.NONE && lockModeToUse == LockMode.NONE ) {
			return lockModeToUse;
		}
		else {
			LOG.aliasSpecificLockingWithFollowOnLocking( lockModeToUse );
		}
	}
	return lockModeToUse;
}
 

protected boolean shouldUseFollowOnLocking(
		QueryParameters parameters,
		Dialect dialect,
		List<AfterLoadAction> afterLoadActions) {
	if ( ( parameters.getLockOptions().getFollowOnLocking() == null && dialect.useFollowOnLocking( parameters ) ) ||
			( parameters.getLockOptions().getFollowOnLocking() != null && parameters.getLockOptions().getFollowOnLocking() ) ) {
		// currently only one lock mode is allowed in follow-on locking
		final LockMode lockMode = determineFollowOnLockMode( parameters.getLockOptions() );
		final LockOptions lockOptions = new LockOptions( lockMode );
		if ( lockOptions.getLockMode() != LockMode.UPGRADE_SKIPLOCKED ) {
			if ( lockOptions.getLockMode() != LockMode.NONE ) {
				LOG.usingFollowOnLocking();
			}
			lockOptions.setTimeOut( parameters.getLockOptions().getTimeOut() );
			lockOptions.setScope( parameters.getLockOptions().getScope() );
			afterLoadActions.add(
					new AfterLoadAction() {
						@Override
						public void afterLoad(SharedSessionContractImplementor session, Object entity, Loadable persister) {
							( (Session) session ).buildLockRequest( lockOptions ).lock(
									persister.getEntityName(),
									entity
							);
						}
					}
			);
			parameters.setLockOptions( new LockOptions() );
			return true;
		}
	}
	return false;
}
 

@Override
protected String applyLocks(
		String sql,
		QueryParameters parameters,
		Dialect dialect,
		List<AfterLoadAction> afterLoadActions) throws QueryException {
	final LockOptions lockOptions = parameters.getLockOptions();
	if ( lockOptions == null ||
			( lockOptions.getLockMode() == LockMode.NONE && lockOptions.getAliasLockCount() == 0 ) ) {
		return sql;
	}

	// user is request locking, lets see if we can apply locking directly to the SQL...

	// 		some dialects wont allow locking with paging...
	afterLoadActions.add(
			new AfterLoadAction() {
				private final LockOptions originalLockOptions = lockOptions.makeCopy();

				@Override
				public void afterLoad(SharedSessionContractImplementor session, Object entity, Loadable persister) {
					( (Session) session ).buildLockRequest( originalLockOptions ).lock(
							persister.getEntityName(),
							entity
					);
				}
			}
	);
	parameters.getLockOptions().setLockMode( LockMode.READ );

	return sql;
}
 

@Override
protected LockMode[] getLockModes(LockOptions lockOptions) {
	final String[] entityAliases = getAliases();
	if ( entityAliases == null ) {
		return null;
	}
	final int size = entityAliases.length;
	LockMode[] lockModesArray = new LockMode[size];
	for ( int i=0; i<size; i++ ) {
		LockMode lockMode = lockOptions.getAliasSpecificLockMode( entityAliases[i] );
		lockModesArray[i] = lockMode==null ? lockOptions.getLockMode() : lockMode;
	}
	return lockModesArray;
}
 

public DynamicEntityLoader(
		OuterJoinLoadable persister,
		int maxBatchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) {
	this( persister, maxBatchSize, lockOptions.getLockMode(), factory, loadQueryInfluencers );
}
 

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

@Override
protected String applyLocks(
		String sql,
		QueryParameters parameters,
		Dialect dialect,
		List<AfterLoadAction> afterLoadActions) throws QueryException {
	// can't cache this stuff either (per-invocation)
	// we are given a map of user-alias -> lock mode
	// create a new map of sql-alias -> lock mode

	final LockOptions lockOptions = parameters.getLockOptions();

	if ( lockOptions == null ||
			( lockOptions.getLockMode() == LockMode.NONE && lockOptions.getAliasLockCount() == 0 ) ) {
		return sql;
	}


	// user is request locking, lets see if we can apply locking directly to the SQL...

	// 		some dialects wont allow locking with paging...
	if ( shouldUseFollowOnLocking( parameters, dialect, afterLoadActions ) ) {
		return sql;
	}

	//		there are other conditions we might want to add here, such as checking the result types etc
	//		but those are better served after we have redone the SQL generation to use ASTs.


	// we need both the set of locks and the columns to reference in locks
	// as the ultimate output of this section...
	final LockOptions locks = new LockOptions( lockOptions.getLockMode() );
	final Map<String, String[]> keyColumnNames = dialect.forUpdateOfColumns()
			? new HashMap<>()
			: null;

	locks.setScope( lockOptions.getScope() );
	locks.setTimeOut( lockOptions.getTimeOut() );

	for ( Map.Entry<String, String> entry : sqlAliasByEntityAlias.entrySet() ) {
		final String userAlias = entry.getKey();
		final String drivingSqlAlias = entry.getValue();
		if ( drivingSqlAlias == null ) {
			throw new IllegalArgumentException( "could not locate alias to apply lock mode : " + userAlias );
		}
		// at this point we have (drivingSqlAlias) the SQL alias of the driving table
		// corresponding to the given user alias.  However, the driving table is not
		// (necessarily) the table against which we want to apply locks.  Mainly,
		// the exception case here is joined-subclass hierarchies where we instead
		// want to apply the lock against the root table (for all other strategies,
		// it just happens that driving and root are the same).
		final QueryNode select = (QueryNode) queryTranslator.getSqlAST();
		final Lockable drivingPersister = (Lockable) select.getFromClause()
				.findFromElementByUserOrSqlAlias( userAlias, drivingSqlAlias )
				.getQueryable();
		final String sqlAlias = drivingPersister.getRootTableAlias( drivingSqlAlias );

		final LockMode effectiveLockMode = lockOptions.getEffectiveLockMode( userAlias );
		locks.setAliasSpecificLockMode( sqlAlias, effectiveLockMode );

		if ( keyColumnNames != null ) {
			keyColumnNames.put( sqlAlias, drivingPersister.getRootTableIdentifierColumnNames() );
		}
	}

	// apply the collected locks and columns
	return dialect.applyLocksToSql( sql, locks, keyColumnNames );
}
 

/**
 * Performs a pessimistic lock upgrade on a given entity, if needed.
 *
 * @param object The entity for which to upgrade the lock.
 * @param entry The entity's EntityEntry instance.
 * @param lockOptions contains the requested lock mode.
 * @param source The session which is the source of the event being processed.
 */
protected CompletionStage<Void> upgradeLock(Object object, EntityEntry entry,
											LockOptions lockOptions,
											EventSource source) {

	LockMode requestedLockMode = lockOptions.getLockMode();
	if ( requestedLockMode.greaterThan( entry.getLockMode() ) ) {
		// The user requested a "greater" (i.e. more restrictive) form of
		// pessimistic lock

		if ( entry.getStatus() != Status.MANAGED ) {
			throw new ObjectDeletedException(
					"attempted to lock a deleted instance",
					entry.getId(),
					entry.getPersister().getEntityName()
			);
		}

		final EntityPersister persister = entry.getPersister();

		if ( log.isTraceEnabled() ) {
			log.tracev(
					"Locking {0} in mode: {1}",
					MessageHelper.infoString( persister, entry.getId(), source.getFactory() ),
					requestedLockMode
			);
		}

		final boolean cachingEnabled = persister.canWriteToCache();
		final SoftLock lock;
		final Object ck;
		if ( cachingEnabled ) {
			EntityDataAccess cache = persister.getCacheAccessStrategy();
			ck = cache.generateCacheKey(
					entry.getId(),
					persister,
					source.getFactory(),
					source.getTenantIdentifier()
			);
			lock = cache.lockItem( source, ck, entry.getVersion() );
		}
		else {
			lock = null;
			ck = null;
		}

		return ((ReactiveEntityPersister) persister).lockReactive(
				entry.getId(),
				entry.getVersion(),
				object,
				lockOptions,
				source
		).thenAccept( v -> entry.setLockMode(requestedLockMode) )
				.whenComplete( (r, e) -> {
					// the database now holds a lock + the object is flushed from the cache,
					// so release the soft lock
					if ( cachingEnabled ) {
						persister.getCacheAccessStrategy().unlockItem( source, ck, lock );
					}
				} );

	}
	else {
		return CompletionStages.nullFuture();
	}
}
 

@Override
default CompletionStage<?> lockReactive(
		Serializable id,
		Object version,
		Object object,
		LockOptions lockOptions,
		SharedSessionContractImplementor session) throws HibernateException {

	LockMode lockMode = lockOptions.getLockMode();

	Object nextVersion = nextVersionForLock( lockMode, id, version, object, session );

	String sql;
	boolean writeLock;
	switch (lockMode) {
		case READ:
		case PESSIMISTIC_READ:
		case PESSIMISTIC_WRITE:
		case UPGRADE_NOWAIT:
		case UPGRADE_SKIPLOCKED:
		case UPGRADE:
			sql = generateSelectLockString( lockOptions );
			writeLock = false;
			break;
		case PESSIMISTIC_FORCE_INCREMENT:
		case FORCE:
		case WRITE:
			sql = generateUpdateLockString( lockOptions );
			writeLock = true;
			break;
		case NONE:
			return CompletionStages.nullFuture();
		default:
			throw new IllegalArgumentException("lock mode not supported");
	}

	PreparedStatementAdaptor statement = new PreparedStatementAdaptor();
	try {
		int offset = 1;
		if ( writeLock ) {
			getVersionType().nullSafeSet( statement, nextVersion, offset, session );
			offset++;
		}
		getIdentifierType().nullSafeSet( statement, id, offset, session );
		offset += getIdentifierType().getColumnSpan( getFactory() );
		if ( isVersioned() ) {
			getVersionType().nullSafeSet( statement, version, offset, session );
		}
	}
	catch ( SQLException e) {
		throw new HibernateException( e );
	}
	Object[] parameters = statement.getParametersAsArray();

	ReactiveConnection connection = getReactiveConnection( session );
	CompletionStage<Boolean> lock;
	if (writeLock) {
		lock = connection.update(sql, parameters).thenApply(affected -> affected > 0);
	}
	else {
		lock = connection.select(sql, parameters).thenApply(Iterator::hasNext);
	}

	return lock.thenAccept( found -> {
		if (!found) {
			throw new StaleObjectStateException( getEntityName(), id );
		}
	} ).handle( (r ,e) -> {
		CompletionStages.logSqlException( e,
				() -> "could not lock: "
						+ infoString( this, id, getFactory() ),
				sql
		);
		return CompletionStages.returnOrRethrow( e, r );
	} );
}
 

public ResolveNaturalIdEvent(
		Map<String, Object> naturalIdValues,
		EntityPersister entityPersister,
		LockOptions lockOptions,
		EventSource source) {
	super( source );

	if ( entityPersister == null ) {
		throw new IllegalArgumentException( "EntityPersister is required for loading" );
	}

	if ( ! entityPersister.hasNaturalIdentifier() ) {
		throw new HibernateException( "Entity did not define a natural-id" );
	}

	if ( naturalIdValues == null || naturalIdValues.isEmpty() ) {
		throw new IllegalArgumentException( "natural-id to load is required" );
	}

	if ( entityPersister.getNaturalIdentifierProperties().length != naturalIdValues.size() ) {
		throw new HibernateException(
				String.format(
					"Entity [%s] defines its natural-id with %d properties but only %d were specified",
					entityPersister.getEntityName(),
					entityPersister.getNaturalIdentifierProperties().length,
					naturalIdValues.size()
				)
		);
	}

	if ( lockOptions.getLockMode() == LockMode.WRITE ) {
		throw new IllegalArgumentException( "Invalid lock mode for loading" );
	}
	else if ( lockOptions.getLockMode() == null ) {
		lockOptions.setLockMode( DEFAULT_LOCK_MODE );
	}

	this.entityPersister = entityPersister;
	this.naturalIdValues = naturalIdValues;
	this.lockOptions = lockOptions;

	int[] naturalIdPropertyPositions = entityPersister.getNaturalIdentifierProperties();
	orderedNaturalIdValues = new Object[naturalIdPropertyPositions.length];
	int i = 0;
	for ( int position : naturalIdPropertyPositions ) {
		final String propertyName = entityPersister.getPropertyNames()[position];
		if ( ! naturalIdValues.containsKey( propertyName ) ) {
			throw new HibernateException(
					String.format( "No value specified for natural-id property %s#%s", getEntityName(), propertyName )
			);
		}
		orderedNaturalIdValues[i++] = naturalIdValues.get( entityPersister.getPropertyNames()[position] );
	}
}
 

/**
 * Performs a pessimistic lock upgrade on a given entity, if needed.
 *
 * @param object The entity for which to upgrade the lock.
 * @param entry The entity's EntityEntry instance.
 * @param lockOptions contains the requested lock mode.
 * @param source The session which is the source of the event being processed.
 */
protected void upgradeLock(Object object, EntityEntry entry, LockOptions lockOptions, EventSource source) {

	LockMode requestedLockMode = lockOptions.getLockMode();
	if ( requestedLockMode.greaterThan( entry.getLockMode() ) ) {
		// The user requested a "greater" (i.e. more restrictive) form of
		// pessimistic lock

		if ( entry.getStatus() != Status.MANAGED ) {
			throw new ObjectDeletedException(
					"attempted to lock a deleted instance",
					entry.getId(),
					entry.getPersister().getEntityName()
			);
		}

		final EntityPersister persister = entry.getPersister();

		if ( log.isTraceEnabled() ) {
			log.tracev(
					"Locking {0} in mode: {1}",
					MessageHelper.infoString( persister, entry.getId(), source.getFactory() ),
					requestedLockMode
			);
		}

		final boolean cachingEnabled = persister.canWriteToCache();
		SoftLock lock = null;
		Object ck = null;
		try {
			if ( cachingEnabled ) {
				EntityDataAccess cache = persister.getCacheAccessStrategy();
				ck = cache.generateCacheKey( entry.getId(), persister, source.getFactory(), source.getTenantIdentifier() );
				lock = cache.lockItem( source, ck, entry.getVersion() );
			}

			if ( persister.isVersioned() && requestedLockMode == LockMode.FORCE  ) {
				// todo : should we check the current isolation mode explicitly?
				Object nextVersion = persister.forceVersionIncrement(
						entry.getId(), entry.getVersion(), source
				);
				entry.forceLocked( object, nextVersion );
			}
			else {
				persister.lock( entry.getId(), entry.getVersion(), object, lockOptions, source );
			}
			entry.setLockMode(requestedLockMode);
		}
		finally {
			// the database now holds a lock + the object is flushed from the cache,
			// so release the soft lock
			if ( cachingEnabled ) {
				persister.getCacheAccessStrategy().unlockItem( source, ck, lock );
			}
		}

	}
}
 

/**
 * Given LockOptions (lockMode, timeout), determine the appropriate for update fragment to use.
 *
 * @param lockOptions contains the lock mode to apply.
 * @return The appropriate for update fragment.
 */
public String getForUpdateString(LockOptions lockOptions) {
	final LockMode lockMode = lockOptions.getLockMode();
	return getForUpdateString( lockMode, lockOptions.getTimeOut() );
}