/// <summary>
/// Performs a pessimistic lock upgrade on a given entity, if needed.
/// </summary>
/// <param name="entity">The entity for which to upgrade the lock.</param>
/// <param name="entry">The entity's EntityEntry instance.</param>
/// <param name="requestedLockMode">The lock mode being requested for locking. </param>
/// <param name="source">The session which is the source of the event being processed.</param>
protected virtual void UpgradeLock(object entity, EntityEntry entry, LockMode requestedLockMode, ISessionImplementor source)
{
if (requestedLockMode.GreaterThan(entry.LockMode))
{
// The user requested a "greater" (i.e. more restrictive) form of
// pessimistic lock
if (entry.Status != Status.Loaded)
{
throw new ObjectDeletedException("attempted to lock a deleted instance", entry.Id, entry.EntityName);
}
IEntityPersister persister = entry.Persister;
if (log.IsDebugEnabled)
{
log.Debug(string.Format("locking {0} in mode: {1}", MessageHelper.InfoString(persister, entry.Id, source.Factory), requestedLockMode));
}
ISoftLock slock;
CacheKey ck;
if (persister.HasCache)
{
ck = new CacheKey(entry.Id, persister.IdentifierType, persister.RootEntityName, source.EntityMode, source.Factory);
slock = persister.Cache.Lock(ck, entry.Version);
}
else
{
ck = null;
slock = null;
}
try
{
if (persister.IsVersioned && requestedLockMode == LockMode.Force)
{
// todo : should we check the current isolation mode explicitly?
object nextVersion = persister.ForceVersionIncrement(entry.Id, entry.Version, source);
entry.ForceLocked(entity, nextVersion);
}
else
{
persister.Lock(entry.Id, entry.Version, entity, requestedLockMode, source);
}
entry.LockMode = requestedLockMode;
}
finally
{
// the database now holds a lock + the object is flushed from the cache,
// so release the soft lock
if (persister.HasCache)
{
persister.Cache.Release(ck, slock);
}
}
}
}
public override ILockingStrategy GetLockingStrategy(ILockable lockable, LockMode lockMode)
{
if (lockMode.GreaterThan(LockMode.Read))
{
return(new UpdateLockingStrategy(lockable, lockMode));
}
else
{
return(new SelectLockingStrategy(lockable, lockMode));
}
}
public override SqlString ApplyLocksToSql(SqlString sql, IDictionary <string, LockMode> aliasedLockModes, IDictionary <string, string[]> keyColumnNames)
{
// TODO: merge additional lockoptions support in Dialect.applyLocksToSql
var buffer = new StringBuilder(sql.ToString());
int correction = 0;
foreach (KeyValuePair <string, LockMode> entry in aliasedLockModes)
{
LockMode mode = entry.Value;
if (mode.GreaterThan(LockMode.Read))
{
string alias = entry.Key;
int start = -1;
int end = -1;
if (sql.EndsWith(" " + alias))
{
start = (sql.Length - alias.Length) + correction;
end = start + alias.Length;
}
else
{
int position = sql.IndexOfCaseInsensitive(" " + alias + " ");
if (position <= -1)
{
position = sql.IndexOfCaseInsensitive(" " + alias + ",");
}
if (position > -1)
{
start = position + correction + 1;
end = start + alias.Length;
}
}
if (start > -1)
{
string lockHint = AppendLockHint(mode, alias);
buffer.Remove(start, end - start + 1);
buffer.Insert(start, lockHint);
correction += (lockHint.Length - alias.Length);
}
}
}
return(new SqlString(buffer.ToString()));
}
private bool NeedsLockHint(LockMode lockMode)
{
return lockMode.GreaterThan(LockMode.Read);
}
public override string AppendLockHint(LockMode lockMode, string tableName)
{
if (lockMode.GreaterThan(LockMode.Read))
return tableName + " holdlock";
return tableName;
}
protected bool NeedsLockHint(LockMode lockMode)
{
return lockMode.GreaterThan(LockMode.Read);
}
protected bool NeedsLockHint(LockMode lockMode)
{
return(lockMode.GreaterThan(LockMode.Read));
}
private bool NeedsLockHint(LockMode lockMode)
{
return(lockMode.GreaterThan(LockMode.Read));
}
/// <summary>
/// Disable outer join fetching if this loader obtains an
/// upgrade lock mode
/// </summary>
protected override bool IsJoinedFetchEnabled(IAssociationType type, FetchMode config, CascadeStyle cascadeStyle)
{
return(lockMode.GreaterThan(LockMode.Read) ? false : base.IsJoinedFetchEnabled(type, config, cascadeStyle));
}
public override ILockingStrategy GetLockingStrategy(ILockable lockable, LockMode lockMode)
{
if (lockMode.GreaterThan(LockMode.Read))
{
return new UpdateLockingStrategy(lockable, lockMode);
}
else
{
return new SelectLockingStrategy(lockable, lockMode);
}
}
private void UpgradeLock( object obj, EntityEntry entry, LockMode lockMode )
{
if( lockMode.GreaterThan( entry.LockMode ) )
{
if( entry.Status != Status.Loaded )
{
throw new ObjectDeletedException( "attempted to lock a deleted instance", entry.Id, obj.GetType() );
}
IClassPersister persister = entry.Persister;
if( log.IsDebugEnabled )
{
log.Debug( "locking " + MessageHelper.InfoString( persister, entry.Id ) + " in mode: " + lockMode );
}
ISoftLock myLock = null;
if( persister.HasCache )
{
myLock = persister.Cache.Lock( entry.Id, entry.Version );
}
try
{
persister.Lock( entry.Id, entry.Version, obj, lockMode, this );
entry.LockMode = lockMode;
}
finally
{
// the database now holds a lock + the object is flushed from the cache,
// so release the soft lock
if( persister.HasCache )
{
persister.Cache.Release( entry.Id, myLock );
}
}
}
}
