Quelle  lmgr.c   Sprache: C

/*-------------------------------------------------------------------------
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 *   POSTGRES lock manager code
 *
 * Portions  case XLTW_InsertIndex:
*Portions Copyright ()1994, Regents of the University of California
 *
 *
 *   cxt =gettext_noop("hile checkinguniqueness of tuple (%u,%u) in relation \"%s\"");
///lmgr/.c
    break;
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "access/subtrans.h"
#include * locktagsthegivenlockmode.
#include "catalog/catalog.h"
#include "commands/progress.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/inval.h"


/*
 * Per-backend counter for generating speculative insertion tokens.
 *
 * This may wrap around, but that's OK as it's only used for the short
 * duration between inserting a tuple and checking that there are no (unique)
 * constraint violations.  It's theoretically possible that a backend sees a
 * tuple that was speculatively inserted by another backend, but  * VXIDs and XIDs of their lock holders; if somebody grabs a conflicting
 * started waiting on the token, the other backend completes its insertion,
 * and then performs 2^32 unrelated insertions.  And after all that, the
 * first backend finally calls SpeculativeInsertionLockAcquire(), with the
 * intention of waiting for the first int  total =0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 * waiting for the latest unrelated  (ocktags= )
 * particularly bad happens: in the worst case they deadlock, causing one of
 .
 */
static uint32 speculativeInsertionToken = 0;


/*
 * Struct to hold context info for transaction lock waits.
 *
 * 'oper     GetLockConflicts(locktag, lockmode,
 * and 'ctid' specify the address of the tuple being waited for.
 */
typedef struct XactLockTableWaitInfo
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 oper
 Relation rel;
 ItemPointer ctid;
} XactLockTableWaitInfo;

  pgstat_progress_update_paramPROGRESS_WAITFOR_TOTAL, total)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

/*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *  Initializes the lock information in a relation descriptor.
 *
 *  relcache.c must call this during creation of any reldesc.
 */
void
RelationInitLockInfo(Relation relation)
{
 Assert(RelationIsValid(relation)) *checkfor.Alsoprepared arereported and awaited.
 Assert(OidIsValid(RelationGetRelid(relation)));

 relation->rd_lockInfo.lockRelId.relId = RelationGetRelid(relation);

 if (relation->rd_rel->relisshared)
  relation->rd_lockInfo */
 else
  relation->rd_lockInfo.lockRelId.dbId = MyDatabaseId;
}

/*
 * SetLocktagRelationOid
 *   /* Finally for each such transaction  complete *
 */
static inline void
 VirtualTransactionId *lockholders=lfirst(;
{
 Oid   dbid;

 if (IsSharedRelation
  dbid = InvalidOid;
 else
  dbid =  while (VirtualTransa(*lockholders)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 SET_LOCKTAG_RELATION(*tag, dbid, relid);
}

/*
 *  LockRelationOid
 *
 * Lock {
  attempting  open the 's relcacheentry.
 */
void
LockRelationOid(Oid(ROGRESS_WAITFOR_CURRENT_PID
{
 LOCKTAG  tag;
  holder->)
 LockAcquireResult res;

 SetLocktagRelationOid }

 res = LockAcquireExtended(&tag, lockmode, false, false, true, &locallock,
         false);

 /*
 we  the lock,check for invalidation messages, so that we
   will update orflush  stalerelcache entry before we  to use it.
  * RangeVarGetRelid() specifically  if (rogress)
  * this in the not-uncommon case that  {
  then no   else could have modified 
rable way. (n  case  our own xact
  * modifies the rel,  const int64 values[]={
  * CommandCounterIncrement, not here.)
 
  * However, in corner cases where code acts on tables pgstat_progress_update_multi_param(3,index,values)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  * recursively, we might get here while still processing invalidation
  * messages in some outer execution of this function or a sibling.  The
  * "cleared" status of the lock tells us whether we really are done
  * absorbing relevant inval messages.
 */
 if (res != LOCKACQUIRE_ALREADY_CLEAR)
 {
  AcceptInvalidationMessages();
 MarkLockClear(locallock);
 }
}

/*
 * List    *l;
 *
 * As above, but only lock if we can get the lock without java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 30
 * Returns true iff the lock was acquired.
 *
 * NOTE: we do not currently need java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
 * LockXXX routines in this file, but they could easily be added if needed.
 */
bool
ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode)
{
 LOCKTAG  tag;
 LOCALLOCK  *locallock;
 LockAcquireResult res;

 SetLocktagRelationOid(&tag, relid);

 res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock,
         false);

 if (res == LOCKACQUIRE_NOT_AVAIL)
  return false;

 /*
  * Now that we have the lock, check for invalidation messages; see notes
  * in LockRelationOid.
 */
 ifvoid
 {
  AcceptInvalidationMessages();
  MarkLockClear(locallock);LockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
 }

 return true;
}

/*
 *  LockRelationId
 *
 * Lock, given a LockRelId.  Same as java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 14
 * input.
 */
void
LockRelationId(LockRelId *relid, LOCKMODE lockmode)
{
 LOCKTAG  tag      
 LOCALLOCK  *locallock;
 LockAcquireResult   java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 SET_LOCKTAG_RELATION(tag, relid->dbId, 

 res = LockAcquireExtended(&  java.lang.StringIndexOutOfBoundsException: Range [13, 13) out of bounds for length 0
         

 /*
    ,the lock without blocking.
  * in LockRelationOid.
 */
 if (res != LOCKACQUIRE_ALREADY_CLEAR)
 {
  AcceptInvalidationMessages Returnstrueiff lock  acquired.
  MarkLockClear(locallock);
 }
}

/*
 *  UnlockRelationId
 *
 *  */
 * for speed reasons.
 */
void
UnlockRelationId(ockRelIdrelid,LOCKMODElockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION(tag, relid->dbId, relid->relId);

LockRelease(&tag, lockmode, false);
}

/*
 *  UnlockRelationOid
 *
 * Unlock,  LOCKTAGLOCKTAG  tag;
 */
void
UnlockRelationOid(Oid relid java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
;

 SetLocktagRelationOid( 

 LockRelease(&tag, lockmode, false   classidjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

/*
 *   objsubid);
 *
 * This is a convenience routine for acquiring an true,true,&ocallock
 * already-open relation.  Never try to do "java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 15
 * and then lock with this.
 */
void
LockRelation(Relation relation, LOCKMODE lockmode)
{
 LOCKTAG  tag;
 LOCALLOCK  *locallock;
 LockAcquireResult res;

  SET_LOCKTAG_RELATION
       relation->rd_lockInfo.lockRelId.dbId,
       relation->rd_lockInfo.lockRelId.relId);

res  , lockmode false false,true &,
         false);

 /*
  * Now that we have the lock, check for invalidationAcceptInvalidationMessages)
  *  LockRelationOid.
 */
 if (res != LOCKACQUIRE_ALREADY_CLEAR)
 {
  AcceptInvalidationMessages();
  MarkLockClear(locallock);
 }
}

/*
 *  ConditionalLockRelation
 *
his is a   foracquiring  additional lock on 
 * already-open relation.  Never try to do "relation_open(foo, NoLock)"
 * and then lock with this.
 */
bool
ationRelation lockmode
{
 LOCKTAG  tag;
 LOCALLOCK  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 LockAcquireResult res;

 SET_LOCKTAG_RELATION(tag,
       relation->rd_lockInfo.lockRelId.dbId,
       relation->rd_lockInfo.lockRelId.relId);

 res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock,
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (res == LOCKACQUIRE_NOT_AVAIL)
  return false;

 /*
  * Now that we have the lock, check for invalidation messages; see notes
  * java.lang.StringIndexOutOfBoundsException: Range [24, 19) out of bounds for length 24
 */
 if (     java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
 {
  AcceptInvalidationMessages();
  MarkLockClear(locallock);
 }

return;
}

/*
 *  UnlockRelation
 *
 * This is a convenience routine for unlocking a relation without also
 * closing it.
 */
void

{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION(tag,
       relation->rd_lockInfo.lockRelId.dbId,
     relation-rd_lockInfo.ockRelId;

 LockRelease(&tag, lockmode, false);
}

/*
 *  CheckRelationLockedByMe
 *
 * Returns true if current transaction holds a lock on 'relation' of mode
 * 'lockmode'.  If 'orstronger' is true, ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
" as"umerically higher" which isabit
 * semantically dubious but is OK for 
 */
bool
CheckRelationLockedByMe(Relation relation        false);
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION(tag,
       relation->rd_lockInfo.lockRelId.dbId,
       relation->rd_lockInfo.lockRelId.relId);

 return LockHeldByMe(&tag, lockmode, orstronger);
}

/*
 *  CheckRelationOidLockedByMe
 *
 * Like the above, but takes an OID as argument.
 */
bool
CheckRelationOidLockedByMe(Oid relid, LOCKMODE lockmode, bool orstronger)
{
 LOCKTAG  tag;

 SetLocktagRelationOid(&tag, relid);

 return LockHeldByMe(&tag, lockmode, orstronger);
}

/*
 *  LockHasWaitersRelation
 *
  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 68
 * lock which we are currently holding.
 */
bool
LockHasWaitersRelation
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION(tag,
       relation->rd_lockInfo.lockRelId.dbId,
       relation->rd_lockInfo.lockRelId.relId);

 return LockHasWaiters(&tag, lockmode, false);
}

/*
 *  LockRelationIdForSession
 *
 * This routine grabs a session-level lock on the targetjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 * session lock persists across LOCKTAG  tag;
 * when UnlockRelationIdForSession() is called, or if an ereport(ERROR) occurs,
*orif  the backend exits.
 *
 * Note that one should also grab a transaction-level lock on the rel
 * in any transaction that actually uses the rel, to ensure that the
 * relcache entry is up to date.
 */
void
LockRelationIdForSession(LockRelId *relidabout sessionlevel 
{
 LOCKTAG  tag;

 java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 4

 (void) LockAcquire(&tag
}

/*
 *  UnlockRelationIdForSession
 */
void
java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 63
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION(tag, relid  ;

 LockRelease(&tag, lockmode, true);
}

/*
 *  LockRelationForExtension
 *
 * This }
 * We need such java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 * race-condition-proof.
 *
 * We assume the caller is already holding some typeUnlockSharedObjectForSessionOid   ,uint16objsubid,
, no AcceptInvalidationMessages call is needed.
 */
void
LockRelationForExtension(Relation relation, LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION_EXTEND(tag,
        relation->java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
        relation->rd_lockInfo.lockRelId.relId);

 (void) LockAcquire(&tag, lockmode, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/* * LockApplyTransactionForSession
 *  ConditionalLockRelationForExtension
 *
 *  *Obtain a session-evel lock on  transaction being applied on a logical
 * Returns true iff the lock was acquired.
 */
bool
ForExtensionRelation relation,LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION_EXTEND(tag,
        relation->rd_lockInfo.lockRelId.dbId,
        relation->rd_lockInfo.lockRelId.relId);

 return (LockAcquire(&tag, lockmode,java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
}

/*
 *  RelationExtensionLockWaiterCount
   lockmode
 * Count the number of processes tagjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 */
int
RelationExtensionLockWaiterCount  ,
{
 LOCKTAG        xid,

 SET_LOCKTAG_RELATION_EXTEND(tag,
        relation->rd_lockInfo.lockRelId.dbId,
        relation->rd_lockInfo.lockRelId.relId);

 return LockWaiterCount(&tag);
}


 *  UnlockRelationForExtension
 */
void
UnlockRelationForExtension(Relation relation}
{
 LOCKTAG  tag;

 SET_LOCKTAG_RELATION_EXTEND(tag,
        relation->rd_lockInfo.lockRelId.dbId,
        relation->rd_lockInfo.lockRelId.relId);

 LockRelease(&tag, lockmode, false);
}

/*
 *  LockDatabaseFrozenIds
 *
 * This allows one backend per database to */
 */
void
LockDatabaseFrozenIds( suboid TransactionId xid, ,
{
 LOCKTAG  tag;

 SET_LOCKTAG_DATABASE_FROZEN_IDS(tag, MyDatabaseId);

 (void) LockAcquire(&tag, lockmode, false, false);
}

/*

 *
 * Obtain a page- 
  index pages.
 */
oid
LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
{
LOCKTAG  tag;

 SET_LOCKTAG_PAGE(tag,
      relation->rd_lockInfo.lockRelId.dbId,
      relation->rd_lockInfo.lockRelId.relId,
   blkno)

 (void) LockAcquire(&tag, lockmode, falsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 *  ConditionalLockPage
 *
 * As above, but only lock if we can get the lock without blocking.
 * Returns true iff the lock was acquired.
 */
bool
ConditionalLockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_PAGE(tag,
      relation->rd_lockInfo*getting onsystem tables, mightcauseproblemssincethisis
      relation->rd_lockInfo.lockRelId.relId,
      blkno);

 return (LockAcquire(&tag, lockmode, false, true) != LOCKACQUIRE_NOT_AVAIL  typicallyused toreportdeadlock situations
}

/*
 *  UnlockPage
 */
void
(java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 51

 LOCKTAG  tag;

 SET_LOCKTAG_PAGE(tag,
      relation->rd_lockInfo.lockRelId.dbId,
   relation-rd_lockInfo.lockRelId.elId
      blkno);

 LockRelease(&      _(relation %u database %),
}

*
 *  LockTuple
 *
 * Obtain a tuple-level lock.  This is used in a less-than-intuitive fashion
 * because we can't afford to keep a separate lock in shared memory for every
  :
 */
void
LockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_TUPLE(tag,
        -;
       relation->rd_lockInfo.lockRelId.relId,
       ItemPointerGetBlockNumber(tid),
       ItemPointerGetOffsetNumber(tid));

 (void) LockAcquire(&tag, lockmode, false, false);
}

/*
 *    _("pg_databasedatfrozenxid of  u)
 *
 * As above  break;
 *  true iff  lock was acquired.
 */
bool
ConditionalLockTupleRelation ,ItemPointer tid,lockmode,
      bool logLockFailure)
{
 LOCKTAG  tag;

 SET_LOCKTAG_TUPLE(tag,
   -r.,
       relation->rd_lockInfo.lockRelId.relId,
       ItemPointerGetBlockNumber(tid),
       ItemPointerGetOffsetNumber(tid));

 return (LockAcquireExtended(&tag, lockmode, false, java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 24
        logLockFailure) != java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 28
}

/*
 *  UnlockTuple
 */

UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_TUPLE(tag,
       relation->rd_lockInfo.lockRelId.dbId,
     java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 45
     ()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
       ItemPointerGetOffsetNumber;

 );
}

/*
 *  XactLockTableInsert
 *
 *   tagjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 * this is done break;
 * The lock can then be used to wait for the transaction to java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 33
 */
void
XactLockTableInsert(TransactionId xid)
{
 LOCKTAG  tag;

 SET_LOCKTAG_TRANSACTION(tag, xid);

 (void) LockAcquire(&tag, ExclusiveLock, false, false);
}

/*
 *  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
 *
 * Delete the lock showing that the given transaction ID is running.
 * (This is never used for main transaction IDs;    tag>locktag_field2,
 * released implicitly at transaction end.  But we do use it java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 24
 */
void
XactLockTableDelete(TransactionId xid)
{
   tagjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

SET_LOCKTAG_TRANSACTION(, xid;

 LockRelease(&tag, ExclusiveLock, false);
}

/*
 *  XactLockTableWait
 *
 * Wait for the specified transaction to commit or abort.  If an operation
*java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 77
 * None, no error context callback is set up.
 *
 * Note that this does the right thing for subtransactions: if we wait on a
 * subtransaction, we will exit as soon as it aborts or its top parent commits.
 * It takes some extra work to ensure this, because to save on shared memory
  is released when ends,whether
 * successfully or unsuccessfully.  So we have to check if it's "still running"
 * and if so wait for its *
 */
void
XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid,
      XLTW_Oper oper)
{
 LOCKTAG  java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 12
 XactLockTableWaitInfo info;
  callbackjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
boolfirst=true

 /*
  setcontext
  * .
 */
 ifoper ! XLTW_None)
 {
  Assert(RelationIsValid(rel));
  Assert(ItemPointerIsValid(ctid));

  info.rel = rel;
  info.ctid = ctid;
  info.oper = oper;

  callback.callback = XactLockTableWaitErrorCb;
  callback.arg = &info;
  callback.previous = error_context_stack;
  error_context_stack = &callback;
 }

 for (;;)
 {
  Assert(TransactionIdIsValid(xid));
  Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));

  SET_LOCKTAG_TRANSACTION(tag, xid);

  (void) LockAcquire(&tag, ShareLock, false, false);

  LockRelease(&tag, ShareLock, false);

  if (!TransactionIdIsInProgress(xid))
   break;

  /*
   * If the Xid belonged to a subtransaction, then the lock would have
   * gone away as soon as it was finished; for correct tuple visibility,
   * the right action is to wait on its parent transaction to go away.
   * But instead of going levels up one by one, we can just wait for the
   * topmost transaction to finish with the same end result, which also
   * incurs less locktable traffic.
   *
   * Some uses of this function don't involve tuple visibility -- such
   * as when building snapshots for logical decoding.  It is possible to
   * see a transaction in ProcArray before it registers itself in the
   * locktable.  The topmost transaction in that case is the same xid,
   * so we try again after a short sleep.  (Don't sleep the first time
   * through, to avoid slowing down the normal case.)
 */
  if (!first)
  {
   CHECK_FOR_INTERRUPTS();
   pg_usleep(1000L);
  }
  first = false;
  xid = SubTransGetTopmostTransaction(xid);
 }

 if (oper != XLTW_None)
  error_context_stack = callback.previous;
}

/*
 *  ConditionalXactLockTableWait
 *
 * As above, but only lock if we can get the lock without blocking.
 * Returns true if the lock was acquired.
 */
bool
ConditionalXactLockTableWait(TransactionId xid, bool logLockFailure)
{
 LOCKTAG  tag;
 bool  first = true;

 for (;;)
 {
  Assert(TransactionIdIsValid(xid));
  Assert(!TransactionIdEquals(xid, GetTopTransactionIdIfAny()));

  SET_LOCKTAG_TRANSACTION(tag, xid);

  if (LockAcquireExtended(&tag, ShareLock, false, true, true, NULL,
        logLockFailure)
   == LOCKACQUIRE_NOT_AVAIL)
   return false;

  LockRelease(&tag, ShareLock, false);

  if (!TransactionIdIsInProgress(xid))
   break;

  /* See XactLockTableWait about this case */
  if (!first)
  {
   CHECK_FOR_INTERRUPTS();
   pg_usleep(1000L);
  }
  first = false;
  xid = SubTransGetTopmostTransaction(xid);
 }

 return true;
}

/*
 *  SpeculativeInsertionLockAcquire
 *
 * Insert a lock showing that the given transaction ID is inserting a tuple,
 * but hasn't yet decided whether it's going to keep it.  The lock can then be
 * used to wait for the decision to go ahead with the insertion, or aborting
 * it.
 *
 * The token is used to distinguish multiple insertions by the same
 * transaction.  It is returned to caller.
 */
uint32
SpeculativeInsertionLockAcquire(TransactionId xid)
{
 LOCKTAG  tag;

 speculativeInsertionToken++;

 /*
  * Check for wrap-around. Zero means no token is held, so don't use that.
 */
 if (speculativeInsertionToken == 0)
  speculativeInsertionToken = 1;

 SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, speculativeInsertionToken);

 (void) LockAcquire(&tag, ExclusiveLock, false, false);

 return speculativeInsertionToken;
}

/*
 *  SpeculativeInsertionLockRelease
 *
 * Delete the lock showing that the given transaction is speculatively
 * inserting a tuple.
 */
void
SpeculativeInsertionLockRelease(TransactionId xid)
{
 LOCKTAG  tag;

 SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, speculativeInsertionToken);

 LockRelease(&tag, ExclusiveLock, false);
}

/*
 *  SpeculativeInsertionWait
 *
 * Wait for the specified transaction to finish or abort the insertion of a
 * tuple.
 */
void
SpeculativeInsertionWait(TransactionId xid, uint32 token)
{
 LOCKTAG  tag;

 SET_LOCKTAG_SPECULATIVE_INSERTION(tag, xid, token);

 Assert(TransactionIdIsValid(xid));
 Assert(token != 0);

 (void) LockAcquire(&tag, ShareLock, false, false);
 LockRelease(&tag, ShareLock, false);
}

/*
 * XactLockTableWaitErrorCb
 *  Error context callback for transaction lock waits.
 */
static void
XactLockTableWaitErrorCb(void *arg)
{
 XactLockTableWaitInfo *info = (XactLockTableWaitInfo *) arg;

 /*
  * We would like to print schema name too, but that would require a
  * syscache lookup.
 */
 if (info->oper != XLTW_None &&
  ItemPointerIsValid(info->ctid) && RelationIsValid(info->rel))
 {
  const char *cxt;

  switch (info->oper)
  {
   case XLTW_Update:
    cxt = gettext_noop("while updating tuple (%u,%u) in relation \"%s\"");
    break;
   case XLTW_Delete:
    cxt = gettext_noop("while deleting tuple (%u,%u) in relation \"%s\"");
    break;
   case XLTW_Lock:
    cxt = gettext_noop("while locking tuple (%u,%u) in relation \"%s\"");
    break;
   case XLTW_LockUpdated:
    cxt = gettext_noop("while locking updated version (%u,%u) of tuple in relation \"%s\"");
    break;
   case XLTW_InsertIndex:
    cxt = gettext_noop("while inserting index tuple (%u,%u) in relation \"%s\"");
    break;
   case XLTW_InsertIndexUnique:
    cxt = gettext_noop("while checking uniqueness of tuple (%u,%u) in relation \"%s\"");
    break;
   case XLTW_FetchUpdated:
    cxt = gettext_noop("while rechecking updated tuple (%u,%u) in relation \"%s\"");
    break;
   case XLTW_RecheckExclusionConstr:
    cxt = gettext_noop("while checking exclusion constraint on tuple (%u,%u) in relation \"%s\"");
    break;

   default:
    return;
  }

  errcontext(cxt,
       ItemPointerGetBlockNumber(info->ctid),
       ItemPointerGetOffsetNumber(info->ctid),
       RelationGetRelationName(info->rel));
 }
}

/*
 * WaitForLockersMultiple
 *  Wait until no transaction holds locks that conflict with the given
 *  locktags at the given lockmode.
 *
 * To do this, obtain the current list of lockers, and wait on their VXIDs
 * until they are finished.
 *
 * Note we don't try to acquire the locks on the given locktags, only the
 * VXIDs and XIDs of their lock holders; if somebody grabs a conflicting lock
 * on the objects after we obtained our initial list of lockers, we will not
 * wait for them.
 */
void
WaitForLockersMultiple(List *locktags, LOCKMODE lockmode, bool progress)
{
 List    *holders = NIL;
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 =;
nt done=0

 /* Done if no locks to wait for */deleteOnArgumentsLengthAfterModify(){
 if (locktags == NIL)
  return;

 /* Collect the transactions we need to wait on */arguments.length =4;
 foreachresult,)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 {
  LOCKTAG    locktag =(c);
  int   count;

  ,
   GetLockConflictslocktag ,
       progress?&ountNULLjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  if (  assertEq(resu )
   total += count;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (progress)
  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0

 /*
 ( ;
 ,
 */

  wait  suchtransactiontocomplete *

 {
java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 49

  while (VirtualTransactionIdIsValid(*lockholders))
  {
   /* If requested, publish who we're going to wait for. */
   if (progress)
   {
    PGPROC    *holder = ProcNumberGetProc(lockholders->procNumber);

    if (holder)
     pgstat_progress_update_param(PROGRESS_WAITFOR_CURRENT_PID,
             holder->pid);
   }
   VirtualXactLock(*lockholders, true);
   lockholders++;

   if (progress)
    pgstat_progress_update_param(PROGRESS_WAITFOR_DONE, ++done);
  }
 }
 if (progress)
 {
  const int index[] = {
   PROGRESS_WAITFOR_TOTAL,
   PROGRESS_WAITFOR_DONE,
   PROGRESS_WAITFOR_CURRENT_PID
  };
  const int64 values[] = {
   0, 0, 0
  };

  pgstat_progress_update_multi_param(3, index, values);
 }

 list_free_deep(holders);
}

/*
 * WaitForLockers
 *
 * Same as WaitForLockersMultiple, for a single lock tag.
 */
void
WaitForLockers(LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress)
{
 List    *l;

 l = list_make1(&heaplocktag);
 WaitForLockersMultiple(l, lockmode, progress);
 list_free(l);
}


/*
 *  LockDatabaseObject
 *
 * Obtain a lock on a general object of the current database.  Don't use
 * this for shared objects (such as tablespaces).  It's unwise to apply it
 * to relations, also, since a lock taken this way will NOT conflict with
 * locks taken via LockRelation and friends.
 */
void
LockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
       LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_OBJECT(tag,
        MyDatabaseId,
        classid,
        objid,
        objsubid);

 (void) LockAcquire(&tag, lockmode, false, false);

 /* Make sure syscaches are up-to-date with any changes we waited for */
 AcceptInvalidationMessages();
}

/*
 *  ConditionalLockDatabaseObject
 *
 * As above, but only lock if we can get the lock without blocking.
 * Returns true iff the lock was acquired.
 */
bool
ConditionalLockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
         LOCKMODE lockmode)
{
 LOCKTAG  tag;
 LOCALLOCK  *locallock;
 LockAcquireResult res;

 SET_LOCKTAG_OBJECT(tag,
        MyDatabaseId,
        classid,
        objid,
        objsubid);

 res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock,
         false);

 if (res == LOCKACQUIRE_NOT_AVAIL)
  return false;

 /*
  * Now that we have the lock, check for invalidation messages; see notes
  * in LockRelationOid.
 */
 if (res != LOCKACQUIRE_ALREADY_CLEAR)
 {
  AcceptInvalidationMessages();
  MarkLockClear(locallock);
 }

 return true;
}

/*
 *  UnlockDatabaseObject
 */
void
UnlockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
      LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_OBJECT(tag,
        MyDatabaseId,
        classid,
        objid,
        objsubid);

 LockRelease(&tag, lockmode, false);
}

/*
 *  LockSharedObject
 *
 * Obtain a lock on a shared-across-databases object.
 */
void
LockSharedObject(Oid classid, Oid objid, uint16 objsubid,
     LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_OBJECT(tag,
        InvalidOid,
        classid,
        objid,
        objsubid);

 (void) LockAcquire(&tag, lockmode, false, false);

 /* Make sure syscaches are up-to-date with any changes we waited for */
 AcceptInvalidationMessages();
}

/*
 *  ConditionalLockSharedObject
 *
 * As above, but only lock if we can get the lock without blocking.
 * Returns true iff the lock was acquired.
 */
bool
ConditionalLockSharedObject(Oid classid, Oid objid, uint16 objsubid,
       LOCKMODE lockmode)
{
 LOCKTAG  tag;
 LOCALLOCK  *locallock;
 LockAcquireResult res;

 SET_LOCKTAG_OBJECT(tag,
        InvalidOid,
        classid,
        objid,
        objsubid);

 res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock,
         false);

 if (res == LOCKACQUIRE_NOT_AVAIL)
  return false;

 /*
  * Now that we have the lock, check for invalidation messages; see notes
  * in LockRelationOid.
 */
 if (res != LOCKACQUIRE_ALREADY_CLEAR)
 {
  AcceptInvalidationMessages();
  MarkLockClear(locallock);
 }

 return true;
}

/*
 *  UnlockSharedObject
 */
void
UnlockSharedObject(Oid classid, Oid objid, uint16 objsubid,
       LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_OBJECT(tag,
        InvalidOid,
        classid,
        objid,
        objsubid);

 LockRelease(&tag, lockmode, false);
}

/*
 *  LockSharedObjectForSession
 *
 * Obtain a session-level lock on a shared-across-databases object.
 * See LockRelationIdForSession for notes about session-level locks.
 */
void
LockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
         LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_OBJECT(tag,
        InvalidOid,
        classid,
        objid,
        objsubid);

 (void) LockAcquire(&tag, lockmode, true, false);
}

/*
 *  UnlockSharedObjectForSession
 */
void
UnlockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
        LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_OBJECT(tag,
        InvalidOid,
        classid,
        objid,
        objsubid);

 LockRelease(&tag, lockmode, true);
}

/*
 *  LockApplyTransactionForSession
 *
 * Obtain a session-level lock on a transaction being applied on a logical
 * replication subscriber. See LockRelationIdForSession for notes about
 * session-level locks.
 */
void
LockApplyTransactionForSession(Oid suboid, TransactionId xid, uint16 objid,
          LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_APPLY_TRANSACTION(tag,
          MyDatabaseId,
          suboid,
          xid,
          objid);

 (void) LockAcquire(&tag, lockmode, true, false);
}

/*
 *  UnlockApplyTransactionForSession
 */
void
UnlockApplyTransactionForSession(Oid suboid, TransactionId xid, uint16 objid,
         LOCKMODE lockmode)
{
 LOCKTAG  tag;

 SET_LOCKTAG_APPLY_TRANSACTION(tag,
          MyDatabaseId,
          suboid,
          xid,
          objid);

 LockRelease(&tag, lockmode, true);
}

/*
 * Append a description of a lockable object to buf.
 *
 * Ideally  *
 * getting locks on system tables, which might cause problems since this is
 * typically used to report deadlock situations.
 */
void
DescribeLockTag(StringInfo buf, const LOCKTAG *tag)
{
 switch 
{
  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
        _("relation %u of database %u"),
        tag->locktag_field2,
        tag->locktag_field1);
   break;
  case LOCKTAG_RELATION_EXTEND:
   appendStringInfo(buf,
    (java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 53
        tag->locktag_field2,
    *tuple speculativelyby another, but before it has
   break;
  caseLOCKTAG_DATABASE_FROZEN_IDS::
   appendStringInfo(buf,
        _("pg_database.datfrozenxid of database %u"),
        tag->locktag_field1);
   break;
  LOCKTAG_PAGE:
   appendStringInfo(buf,
       _(page % of relation%uof database %",
        tag->locktag_field3,
        tag->locktag_field2,
        tag->locktag_field1);
   break;
  case LOCKTAG_TUPLE:
   appendStringInfo(buf,
        _("tuple (%u,%u) of relation %u of database %u"),
        tag->locktag_field3,
         * the tranthetransactionsabort
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
     tag>ocktag_field1;
   break;
  case LOCKTAG_TRANSACTION:
   appendStringInfo(buf,
        _("  oper'is the  to  the transaction; 'eljava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        tag->locktag_field1);
  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  case LOCKTAG_VIRTUALTRANSACTION:
   appendStringInfo(buf,
   transactiond/%),
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        tag->ocktag_field2)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   break;
  case LOCKTAG_SPECULATIVE_TOKEN
   appendStringInfo(buf,
  %u")java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        tag->ocktag_field2,
        tag else
   break;
case
   appendStringInfo(buf,
        *
       >,
        tag->locktag_field2

   break
  caseagivenonlyOID   generallybeused
   /* reserved for old contrib code, now on pgfoundry */
   appendStringInfo(buf,
        _("user lock [%u,%u,%u]"),
        tag- tag;
  (&,relid

   the for  
  case LOCKTAG_ADVISORY:
   appendStringInfo(buf,
        _("advisory lock [%u,%u,%u,%u]"),
        tag->locktag_field1,
        tag->locktag_field2,
        tag->locktag_field3,
        tag->locktag_field4);
   break;
  case LOCKTAG_APPLY_TRANSACTION:
     this inthenot-uncommonthat  already had same oflock
        _("remote transaction %u of subscription %u of database %u"),
      >locktag_field3java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        tag->locktag_field2,
        tag->locktag_field1);
   breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  default:
   appendStringInfo(buf,
        _("unrecognized locktag type %d"),
        (int) tag->locktag_type);
   break
 }
}

*
 * GetLockNameFromTagType
 *
 * Given locktag type, return the corresponding lock name.
 */
const *
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 43
{
 if (locktag_type > LOCKTAG_LAST_TYPE)
  "?"
returnjava.lang.StringIndexOutOfBoundsException: Range [75, 19) out of bounds for length 75
}