/** @see LockManager#getTimeoutInfo */
@Override
TimeoutInfo getTimeoutInfo(
boolean isLockNotTxnTimeout,
Locker locker,
long lsn,
LockType type,
LockGrantType grantType,
Lock useLock,
long timeout,
long start,
long now,
DatabaseImpl database)
throws DatabaseException {
if (locker.lockingRequired()) {
return superiorLockManager.getTimeoutInfo(
isLockNotTxnTimeout,
locker,
lsn,
type,
grantType,
useLock,
timeout,
start,
now,
database);
}
return null;
}
/** @see LockManager#demote */
@Override
void demote(long lsn, Locker locker) throws DatabaseException {
if (locker.lockingRequired()) {
superiorLockManager.demote(lsn, locker);
} else {
return;
}
}
/** @see LockManager#stealLock */
@Override
public LockAttemptResult stealLock(Long lsn, Locker locker, LockType lockType)
throws DatabaseException {
if (locker.lockingRequired()) {
return superiorLockManager.stealLock(lsn, locker, lockType);
}
return null;
}
/** @see LockManager#validateOwnership */
@Override
boolean validateOwnership(
Long lsn, Locker locker, LockType type, boolean flushFromWaiters, MemoryBudget mb)
throws DatabaseException {
if (locker.lockingRequired()) {
return superiorLockManager.validateOwnership(lsn, locker, type, flushFromWaiters, mb);
}
return true;
}
/** @see LockManager#attemptLock */
@Override
LockAttemptResult attemptLock(
Long lsn,
Locker locker,
LockType type,
boolean nonBlockingRequest,
boolean jumpAheadOfWaiters)
throws DatabaseException {
if (locker.lockingRequired()) {
return superiorLockManager.attemptLock(
lsn, locker, type, nonBlockingRequest, jumpAheadOfWaiters);
}
return new LockAttemptResult(null, LockGrantType.NEW, true);
}
/** @see LockManager#releaseAndFindNotifyTargets */
@Override
Set<Locker> releaseAndFindNotifyTargets(long lsn, Locker locker) throws DatabaseException {
/*
* Unconditionally release the lock. This does not detract from the
* performance benefit of disabled locking, since this method is only
* called if a lock was previously acquired, i.e., it is held by a
* Locker.
*
* The comment below is now obsolete because handle locks are no longer
* transferred.
* If the release of the lock were conditional, a lock transferred
* between Lockers (as we do with Database handle locks) would never
* be released, since the destination Locker's lockingRequired
* property is not set to true. In general, it is safer to
* unconditionally release locks than to rely on the lockingRequired
* property. [#17985]
*/
return superiorLockManager.releaseAndFindNotifyTargets(lsn, locker);
}
/** @see LockManager#lookupLock */
@Override
Lock lookupLock(Long lsn) throws DatabaseException {
Lock ret = superiorLockManager.lookupLock(lsn);
return ret;
}
@Override
public boolean isLockUncontended(Long lsn) {
return superiorLockManager.isLockUncontended(lsn);
}
@Override
public LockType getOwnedLockType(Long lsn, Locker locker) {
return superiorLockManager.getOwnedLockType(lsn, locker);
}
@Override
public Set<LockInfo> getOwners(Long lsn) {
return superiorLockManager.getOwners(lsn);
}
/** @see LockManager#dumpLockTable */
@Override
void dumpLockTable(StatGroup stats, boolean clear) throws DatabaseException {
superiorLockManager.dumpLockTable(stats, clear);
}
/** @see LockManager#getWriterOwnerLocker */
@Override
Locker getWriteOwnerLocker(Long lsn) throws DatabaseException {
return superiorLockManager.getWriteOwnerLocker(lsn);
}
/** @see LockManager#nOwners */
@Override
int nOwners(Long lsn) throws DatabaseException {
return superiorLockManager.nOwners(lsn);
}
/** @see LockManager#isWaiter */
@Override
boolean isWaiter(Long lsn, Locker locker) throws DatabaseException {
return superiorLockManager.isWaiter(lsn, locker);
}
/** @see LockManager#isOwner */
@Override
boolean isOwner(Long lsn, Locker locker, LockType type) throws DatabaseException {
return superiorLockManager.isOwner(lsn, locker, type);
}
/** @see LockManager#isLocked */
@Override
boolean isLocked(Long lsn) throws DatabaseException {
return superiorLockManager.isLocked(lsn);
}