233 #define TargetTagIsCoveredBy(covered_target, covering_target) \
234 ((GET_PREDICATELOCKTARGETTAG_RELATION(covered_target) == \
235 GET_PREDICATELOCKTARGETTAG_RELATION(covering_target)) \
236 && (GET_PREDICATELOCKTARGETTAG_OFFSET(covering_target) == \
237 InvalidOffsetNumber) \
238 && (((GET_PREDICATELOCKTARGETTAG_OFFSET(covered_target) != \
239 InvalidOffsetNumber) \
240 && (GET_PREDICATELOCKTARGETTAG_PAGE(covering_target) == \
241 GET_PREDICATELOCKTARGETTAG_PAGE(covered_target))) \
242 || ((GET_PREDICATELOCKTARGETTAG_PAGE(covering_target) == \
243 InvalidBlockNumber) \
244 && (GET_PREDICATELOCKTARGETTAG_PAGE(covered_target) \
245 != InvalidBlockNumber))) \
246 && (GET_PREDICATELOCKTARGETTAG_DB(covered_target) == \
247 GET_PREDICATELOCKTARGETTAG_DB(covering_target)))
256 #define PredicateLockHashPartition(hashcode) \
257 ((hashcode) % NUM_PREDICATELOCK_PARTITIONS)
258 #define PredicateLockHashPartitionLock(hashcode) \
259 (&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + \
260 PredicateLockHashPartition(hashcode)].lock)
261 #define PredicateLockHashPartitionLockByIndex(i) \
262 (&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)
264 #define NPREDICATELOCKTARGETENTS() \
265 mul_size(max_predicate_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))
267 #define SxactIsOnFinishedList(sxact) (!dlist_node_is_detached(&(sxact)->finishedLink))
277 #define SxactIsCommitted(sxact) (((sxact)->flags & SXACT_FLAG_COMMITTED) != 0)
278 #define SxactIsPrepared(sxact) (((sxact)->flags & SXACT_FLAG_PREPARED) != 0)
279 #define SxactIsRolledBack(sxact) (((sxact)->flags & SXACT_FLAG_ROLLED_BACK) != 0)
280 #define SxactIsDoomed(sxact) (((sxact)->flags & SXACT_FLAG_DOOMED) != 0)
281 #define SxactIsReadOnly(sxact) (((sxact)->flags & SXACT_FLAG_READ_ONLY) != 0)
282 #define SxactHasSummaryConflictIn(sxact) (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_IN) != 0)
283 #define SxactHasSummaryConflictOut(sxact) (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_OUT) != 0)
289 #define SxactHasConflictOut(sxact) (((sxact)->flags & SXACT_FLAG_CONFLICT_OUT) != 0)
290 #define SxactIsDeferrableWaiting(sxact) (((sxact)->flags & SXACT_FLAG_DEFERRABLE_WAITING) != 0)
291 #define SxactIsROSafe(sxact) (((sxact)->flags & SXACT_FLAG_RO_SAFE) != 0)
292 #define SxactIsROUnsafe(sxact) (((sxact)->flags & SXACT_FLAG_RO_UNSAFE) != 0)
293 #define SxactIsPartiallyReleased(sxact) (((sxact)->flags & SXACT_FLAG_PARTIALLY_RELEASED) != 0)
303 #define PredicateLockTargetTagHashCode(predicatelocktargettag) \
304 get_hash_value(PredicateLockTargetHash, predicatelocktargettag)
316 #define PredicateLockHashCodeFromTargetHashCode(predicatelocktag, targethash) \
317 ((targethash) ^ ((uint32) PointerGetDatum((predicatelocktag)->myXact)) \
318 << LOG2_NUM_PREDICATELOCK_PARTITIONS)
326 #define SerialSlruCtl (&SerialSlruCtlData)
328 #define SERIAL_PAGESIZE BLCKSZ
329 #define SERIAL_ENTRYSIZE sizeof(SerCommitSeqNo)
330 #define SERIAL_ENTRIESPERPAGE (SERIAL_PAGESIZE / SERIAL_ENTRYSIZE)
335 #define SERIAL_MAX_PAGE (MaxTransactionId / SERIAL_ENTRIESPERPAGE)
337 #define SerialNextPage(page) (((page) >= SERIAL_MAX_PAGE) ? 0 : (page) + 1)
339 #define SerialValue(slotno, xid) (*((SerCommitSeqNo *) \
340 (SerialSlruCtl->shared->page_buffer[slotno] + \
341 ((((uint32) (xid)) % SERIAL_ENTRIESPERPAGE) * SERIAL_ENTRYSIZE))))
343 #define SerialPage(xid) (((uint32) (xid)) / SERIAL_ENTRIESPERPAGE)
634 if (conflict->
sxactIn == writer)
652 (
errcode(ERRCODE_OUT_OF_MEMORY),
653 errmsg(
"not enough elements in RWConflictPool to record a read/write conflict"),
654 errhint(
"You might need to run fewer transactions at a time or increase max_connections.")));
671 Assert(roXact != activeXact);
677 (
errcode(ERRCODE_OUT_OF_MEMORY),
678 errmsg(
"not enough elements in RWConflictPool to record a potential read/write conflict"),
679 errhint(
"You might need to run fewer transactions at a time or increase max_connections.")));
745 #ifdef USE_ASSERT_CHECKING
747 SerialPagePrecedesLogicallyUnitTests(
void)
750 offset = per_page / 2;
760 newestXact = newestPage * per_page + offset;
761 Assert(newestXact / per_page == newestPage);
762 oldestXact = newestXact + 1;
763 oldestXact -= 1U << 31;
764 oldestPage = oldestXact / per_page;
776 targetPage = oldestPage;
794 targetPage = newestPage;
818 #ifdef USE_ASSERT_CHECKING
819 SerialPagePrecedesLogicallyUnitTests();
919 if (firstZeroPage == targetPage)
1038 int truncateCutoffPage;
1065 truncateCutoffPage = tailPage;
1143 long max_table_size;
1147 #ifndef EXEC_BACKEND
1199 max_table_size *= 2;
1222 max_table_size *= 10;
1245 for (
i = 0;
i < max_table_size;
i++)
1296 max_table_size *= 5;
1312 for (
i = 0;
i < max_table_size;
i++)
1345 long max_table_size;
1353 max_table_size *= 2;
1365 max_table_size *= 10;
1375 max_table_size *= 5;
1451 data->nelements = els;
1590 errmsg_internal(
"deferrable snapshot was unsafe; trying a new one")));
1615 int num_written = 0;
1627 if (sxact->
pid == blocked_pid)
1629 blocking_sxact = sxact;
1645 if (num_written >= output_size)
1679 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1680 errmsg(
"cannot use serializable mode in a hot standby"),
1681 errdetail(
"default_transaction_isolation is set to \"serializable\"."),
1682 errhint(
"You can use \"SET default_transaction_isolation = 'repeatable read'\" to change the default.")));
1732 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1733 errmsg(
"a snapshot-importing transaction must not be READ ONLY DEFERRABLE")));
1769 elog(
ERROR,
"cannot establish serializable snapshot during a parallel operation");
1787 #ifdef TEST_SUMMARIZE_SERIAL
1811 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1812 errmsg(
"could not import the requested snapshot"),
1813 errdetail(
"The source process with PID %d is not running anymore.",
2010 &targettag, targettaghash,
2014 return (target != NULL);
2101 targettag = *newtargettag;
2106 targettag = parenttag;
2183 Assert(rmtarget == target);
2218 oldlocktag = predlock->
tag;
2221 oldtargettag = oldtarget->
tag;
2242 Assert(rmpredlock == predlock);
2322 targettag = *reqtag;
2327 targettag = nexttag;
2334 parentlock->
held =
false;
2349 promotiontag = targettag;
2381 parenttag = *targettag;
2389 parenttag = nexttag;
2393 &parenttag, targettaghash,
2401 if (parentlock == NULL)
2421 &parenttag, targettaghash,
2423 Assert(rmlock == parentlock);
2458 targettag, targettaghash,
2462 (
errcode(ERRCODE_OUT_OF_MEMORY),
2463 errmsg(
"out of shared memory"),
2464 errhint(
"You might need to increase %s.",
"max_pred_locks_per_transaction")));
2477 (
errcode(ERRCODE_OUT_OF_MEMORY),
2478 errmsg(
"out of shared memory"),
2479 errhint(
"You might need to increase %s.",
"max_pred_locks_per_transaction")));
2521 targettag, targettaghash,
2523 locallock->
held =
true;
2720 LWLock *oldpartitionLock;
2723 LWLock *newpartitionLock;
2725 bool outOfShmem =
false;
2749 if (oldpartitionLock < newpartitionLock)
2755 else if (oldpartitionLock > newpartitionLock)
2797 newpredlocktag.
myTarget = newtarget;
2873 if (oldpartitionLock < newpartitionLock)
2878 else if (oldpartitionLock > newpartitionLock)
2933 uint32 heaptargettaghash;
2948 relId = relation->
rd_id;
2957 heapId = relation->
rd_index->indrelid;
2960 Assert(transfer || !isIndex);
2964 heaptargettaghash = 0;
2994 if (transfer && !isIndex
3009 if (transfer && heaptarget == NULL)
3057 newpredlocktag.
myTarget = heaptarget;
3058 newpredlocktag.
myXact = oldXact;
3152 Assert(oldblkno != newblkno);
3299 bool partiallyReleasing =
false;
3313 bool topLevelIsDeclaredReadOnly;
3316 Assert(!(isCommit && isReadOnlySafe));
3319 if (!isReadOnlySafe)
3398 partiallyReleasing =
true;
3467 if (!topLevelIsDeclaredReadOnly)
3558 if (!topLevelIsDeclaredReadOnly)
3571 roXact = possibleUnsafeConflict->
sxactIn;
3621 needToClear =
false;
3622 if ((partiallyReleasing ||
3755 bool canDoPartialCleanup;
3767 if (canDoPartialCleanup)
3775 tag = predlock->
tag;
3777 targettag = target->
tag;
3848 tag = predlock->
tag;
3850 targettag = target->
tag;
3874 (
errcode(ERRCODE_OUT_OF_MEMORY),
3875 errmsg(
"out of shared memory"),
3876 errhint(
"You might need to increase %s.",
"max_pred_locks_per_transaction")));
3986 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
3987 errdetail_internal(
"Reason code: Canceled on identification as a pivot, during conflict out checking."),
3988 errhint(
"The transaction might succeed if retried.")));
4022 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4023 errdetail_internal(
"Reason code: Canceled on identification as a pivot, during conflict out checking."),
4024 errhint(
"The transaction might succeed if retried.")));
4047 if (conflictCommitSeqNo != 0)
4051 || conflictCommitSeqNo
4055 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4057 errhint(
"The transaction might succeed if retried.")));
4063 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4064 errdetail_internal(
"Reason code: Canceled on identification as a pivot, with conflict out to old committed transaction %u.", xid),
4065 errhint(
"The transaction might succeed if retried.")));
4102 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4104 errhint(
"The transaction might succeed if retried.")));
4170 targettag, targettaghash,
4206 mypredlock = predlock;
4207 mypredlocktag = predlock->
tag;
4247 if (mypredlock != NULL)
4264 (&mypredlocktag, targettaghash);
4270 if (rmpredlock != NULL)
4272 Assert(rmpredlock == mypredlock);
4282 Assert(rmpredlock == mypredlock);
4293 if (rmpredlock != NULL)
4301 targettag, targettaghash,
4332 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4333 errdetail_internal(
"Reason code: Canceled on identification as a pivot, during conflict in checking."),
4334 errhint(
"The transaction might succeed if retried.")));
4433 heapId = relation->
rd_id;
4488 Assert(reader != writer);
4651 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4652 errdetail_internal(
"Reason code: Canceled on identification as a pivot, during write."),
4653 errhint(
"The transaction might succeed if retried.")));
4663 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4665 errhint(
"The transaction might succeed if retried.")));
4710 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4711 errdetail_internal(
"Reason code: Canceled on identification as a pivot, during commit attempt."),
4712 errhint(
"The transaction might succeed if retried.")));
4746 errmsg(
"could not serialize access due to read/write dependencies among transactions"),
4747 errdetail_internal(
"Reason code: Canceled on commit attempt with conflict in from prepared pivot."),
4748 errhint(
"The transaction might succeed if retried.")));
4803 &record,
sizeof(record));
4830 &record,
sizeof(record));
4921 (
errcode(ERRCODE_OUT_OF_MEMORY),
4922 errmsg(
"out of shared memory")));
bool ParallelContextActive(void)
#define InvalidBlockNumber
static bool BlockNumberIsValid(BlockNumber blockNumber)
#define unconstify(underlying_type, expr)
#define PG_USED_FOR_ASSERTS_ONLY
#define Assert(condition)
uint32 LocalTransactionId
void hash_destroy(HTAB *hashp)
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
long hash_get_num_entries(HTAB *hashp)
Size hash_estimate_size(long num_entries, Size entrysize)
void * hash_search_with_hash_value(HTAB *hashp, const void *keyPtr, uint32 hashvalue, HASHACTION action, bool *foundPtr)
void * hash_seq_search(HASH_SEQ_STATUS *status)
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
int errmsg_internal(const char *fmt,...)
int errdetail_internal(const char *fmt,...)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
#define dlist_foreach(iter, lhead)
static void dlist_init(dlist_head *head)
#define dlist_head_element(type, membername, lhead)
static void dlist_delete_thoroughly(dlist_node *node)
static void dlist_delete(dlist_node *node)
static dlist_node * dlist_pop_head_node(dlist_head *head)
#define dlist_foreach_modify(iter, lhead)
static bool dlist_is_empty(const dlist_head *head)
static void dlist_push_tail(dlist_head *head, dlist_node *node)
static void dlist_node_init(dlist_node *node)
#define dlist_container(type, membername, ptr)
#define IsParallelWorker()
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
#define GET_VXID_FROM_PGPROC(vxid_dst, proc)
#define SetInvalidVirtualTransactionId(vxid)
bool LWLockHeldByMe(LWLock *lock)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
void LWLockInitialize(LWLock *lock, int tranche_id)
@ LWTRANCHE_SERIAL_BUFFER
@ LWTRANCHE_PER_XACT_PREDICATE_LIST
#define NUM_PREDICATELOCK_PARTITIONS
static bool pg_lfind32(uint32 key, const uint32 *base, uint32 nelem)
static rewind_source * source
#define ERRCODE_T_R_SERIALIZATION_FAILURE
void CheckPointPredicate(void)
void PredicateLockPageSplit(Relation relation, BlockNumber oldblkno, BlockNumber newblkno)
static void DecrementParentLocks(const PREDICATELOCKTARGETTAG *targettag)
static HTAB * PredicateLockHash
static void SetPossibleUnsafeConflict(SERIALIZABLEXACT *roXact, SERIALIZABLEXACT *activeXact)
#define PredicateLockTargetTagHashCode(predicatelocktargettag)
static void SetNewSxactGlobalXmin(void)
void PredicateLockTwoPhaseFinish(TransactionId xid, bool isCommit)
PredicateLockData * GetPredicateLockStatusData(void)
void InitPredicateLocks(void)
static void ReleasePredXact(SERIALIZABLEXACT *sxact)
void SetSerializableTransactionSnapshot(Snapshot snapshot, VirtualTransactionId *sourcevxid, int sourcepid)
static bool RWConflictExists(const SERIALIZABLEXACT *reader, const SERIALIZABLEXACT *writer)
static bool PredicateLockingNeededForRelation(Relation relation)
static bool SerializationNeededForRead(Relation relation, Snapshot snapshot)
static Snapshot GetSafeSnapshot(Snapshot origSnapshot)
#define SxactIsCommitted(sxact)
static SerialControl serialControl
void PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot)
#define SxactIsROUnsafe(sxact)
static Snapshot GetSerializableTransactionSnapshotInt(Snapshot snapshot, VirtualTransactionId *sourcevxid, int sourcepid)
static LWLock * ScratchPartitionLock
static void PredicateLockAcquire(const PREDICATELOCKTARGETTAG *targettag)
#define SxactIsDeferrableWaiting(sxact)
static void ReleasePredicateLocksLocal(void)
static HTAB * LocalPredicateLockHash
int max_predicate_locks_per_page
struct SerialControlData * SerialControl
static PredXactList PredXact
static void SetRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
int GetSafeSnapshotBlockingPids(int blocked_pid, int *output, int output_size)
static uint32 ScratchTargetTagHash
static void RemoveTargetIfNoLongerUsed(PREDICATELOCKTARGET *target, uint32 targettaghash)
static uint32 predicatelock_hash(const void *key, Size keysize)
void CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot snapshot)
#define SxactIsReadOnly(sxact)
#define SerialNextPage(page)
static void DropAllPredicateLocksFromTable(Relation relation, bool transfer)
bool PageIsPredicateLocked(Relation relation, BlockNumber blkno)
static SlruCtlData SerialSlruCtlData
static void CreatePredicateLock(const PREDICATELOCKTARGETTAG *targettag, uint32 targettaghash, SERIALIZABLEXACT *sxact)
static void SerialAdd(TransactionId xid, SerCommitSeqNo minConflictCommitSeqNo)
static void ClearOldPredicateLocks(void)
#define SxactHasSummaryConflictIn(sxact)
static SERIALIZABLEXACT * CreatePredXact(void)
static bool GetParentPredicateLockTag(const PREDICATELOCKTARGETTAG *tag, PREDICATELOCKTARGETTAG *parent)
#define PredicateLockHashCodeFromTargetHashCode(predicatelocktag, targethash)
static void RestoreScratchTarget(bool lockheld)
#define SerialValue(slotno, xid)
static void DeleteChildTargetLocks(const PREDICATELOCKTARGETTAG *newtargettag)
static void DeleteLockTarget(PREDICATELOCKTARGET *target, uint32 targettaghash)
static SERIALIZABLEXACT * OldCommittedSxact
#define SxactHasConflictOut(sxact)
void CheckForSerializableConflictIn(Relation relation, ItemPointer tid, BlockNumber blkno)
static bool MyXactDidWrite
static int MaxPredicateChildLocks(const PREDICATELOCKTARGETTAG *tag)
static void FlagSxactUnsafe(SERIALIZABLEXACT *sxact)
static void SerialInit(void)
void CheckTableForSerializableConflictIn(Relation relation)
#define SxactIsPrepared(sxact)
void PredicateLockTID(Relation relation, ItemPointer tid, Snapshot snapshot, TransactionId tuple_xid)
void AttachSerializableXact(SerializableXactHandle handle)
struct SerialControlData SerialControlData
SerializableXactHandle ShareSerializableXact(void)
static bool PredicateLockExists(const PREDICATELOCKTARGETTAG *targettag)
static void RemoveScratchTarget(bool lockheld)
#define SxactIsOnFinishedList(sxact)
#define SxactIsPartiallyReleased(sxact)
static void SerialSetActiveSerXmin(TransactionId xid)
static dlist_head * FinishedSerializableTransactions
static bool SerializationNeededForWrite(Relation relation)
static HTAB * SerializableXidHash
static bool CheckAndPromotePredicateLockRequest(const PREDICATELOCKTARGETTAG *reqtag)
void PredicateLockPageCombine(Relation relation, BlockNumber oldblkno, BlockNumber newblkno)
static bool SerialPagePrecedesLogically(int64 page1, int64 page2)
static void CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag)
int max_predicate_locks_per_relation
#define SxactIsROSafe(sxact)
void PreCommit_CheckForSerializationFailure(void)
void ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
static void FlagRWConflict(SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static const PREDICATELOCKTARGETTAG ScratchTargetTag
#define PredicateLockHashPartitionLockByIndex(i)
static void OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static bool CoarserLockCovers(const PREDICATELOCKTARGETTAG *newtargettag)
void PredicateLockRelation(Relation relation, Snapshot snapshot)
static SERIALIZABLEXACT * MySerializableXact
void predicatelock_twophase_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
Size PredicateLockShmemSize(void)
#define SxactIsDoomed(sxact)
#define NPREDICATELOCKTARGETENTS()
static SerCommitSeqNo SerialGetMinConflictCommitSeqNo(TransactionId xid)
static void SummarizeOldestCommittedSxact(void)
bool check_serial_buffers(int *newval, void **extra, GucSource source)
#define TargetTagIsCoveredBy(covered_target, covering_target)
static RWConflictPoolHeader RWConflictPool
static void ReleaseRWConflict(RWConflict conflict)
static bool TransferPredicateLocksToNewTarget(PREDICATELOCKTARGETTAG oldtargettag, PREDICATELOCKTARGETTAG newtargettag, bool removeOld)
void AtPrepare_PredicateLocks(void)
void RegisterPredicateLockingXid(TransactionId xid)
#define PredicateLockHashPartitionLock(hashcode)
#define SERIAL_ENTRIESPERPAGE
static bool XidIsConcurrent(TransactionId xid)
static void ReleaseOneSerializableXact(SERIALIZABLEXACT *sxact, bool partial, bool summarize)
static HTAB * PredicateLockTargetHash
bool CheckForSerializableConflictOutNeeded(Relation relation, Snapshot snapshot)
#define SxactIsRolledBack(sxact)
static SERIALIZABLEXACT * SavedSerializableXact
#define SxactHasSummaryConflictOut(sxact)
void TransferPredicateLocksToHeapRelation(Relation relation)
void PostPrepare_PredicateLocks(TransactionId xid)
static void CreateLocalPredicateLockHash(void)
int max_predicate_locks_per_xact
Snapshot GetSerializableTransactionSnapshot(Snapshot snapshot)
void * SerializableXactHandle
#define RWConflictDataSize
#define SXACT_FLAG_DEFERRABLE_WAITING
#define SXACT_FLAG_SUMMARY_CONFLICT_IN
@ TWOPHASEPREDICATERECORD_XACT
@ TWOPHASEPREDICATERECORD_LOCK
#define FirstNormalSerCommitSeqNo
#define InvalidSerCommitSeqNo
struct PREDICATELOCKTAG PREDICATELOCKTAG
#define SXACT_FLAG_CONFLICT_OUT
#define PredXactListDataSize
#define SXACT_FLAG_READ_ONLY
#define SXACT_FLAG_DOOMED
struct LOCALPREDICATELOCK LOCALPREDICATELOCK
#define GET_PREDICATELOCKTARGETTAG_DB(locktag)
#define GET_PREDICATELOCKTARGETTAG_RELATION(locktag)
#define RWConflictPoolHeaderDataSize
struct SERIALIZABLEXIDTAG SERIALIZABLEXIDTAG
#define InvalidSerializableXact
struct PREDICATELOCKTARGET PREDICATELOCKTARGET
#define SET_PREDICATELOCKTARGETTAG_PAGE(locktag, dboid, reloid, blocknum)
#define RecoverySerCommitSeqNo
struct PREDICATELOCKTARGETTAG PREDICATELOCKTARGETTAG
struct SERIALIZABLEXID SERIALIZABLEXID
#define GET_PREDICATELOCKTARGETTAG_TYPE(locktag)
#define SET_PREDICATELOCKTARGETTAG_RELATION(locktag, dboid, reloid)
#define SXACT_FLAG_ROLLED_BACK
#define SXACT_FLAG_COMMITTED
#define SXACT_FLAG_RO_UNSAFE
#define SXACT_FLAG_PREPARED
#define SET_PREDICATELOCKTARGETTAG_TUPLE(locktag, dboid, reloid, blocknum, offnum)
#define SXACT_FLAG_PARTIALLY_RELEASED
#define GET_PREDICATELOCKTARGETTAG_PAGE(locktag)
#define SXACT_FLAG_RO_SAFE
struct PREDICATELOCK PREDICATELOCK
#define SXACT_FLAG_SUMMARY_CONFLICT_OUT
#define GET_PREDICATELOCKTARGETTAG_OFFSET(locktag)
Snapshot GetSnapshotData(Snapshot snapshot)
bool ProcArrayInstallImportedXmin(TransactionId xmin, VirtualTransactionId *sourcevxid)
#define INVALID_PROC_NUMBER
#define RelationUsesLocalBuffers(relation)
bool ShmemAddrIsValid(const void *addr)
void * ShmemAlloc(Size size)
Size add_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Size mul_size(Size s1, Size s2)
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
static pg_noinline void Size size
void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns, const char *subdir, int buffer_tranche_id, int bank_tranche_id, SyncRequestHandler sync_handler, bool long_segment_names)
int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, TransactionId xid)
void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
int SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok, TransactionId xid)
int SimpleLruZeroPage(SlruCtl ctl, int64 pageno)
void SimpleLruTruncate(SlruCtl ctl, int64 cutoffPage)
Size SimpleLruShmemSize(int nslots, int nlsns)
bool check_slru_buffers(const char *name, int *newval)
static LWLock * SimpleLruGetBankLock(SlruCtl ctl, int64 pageno)
#define SlruPagePrecedesUnitTests(ctl, per_page)
#define SLRU_PAGES_PER_SEGMENT
Snapshot GetTransactionSnapshot(void)
#define IsMVCCSnapshot(snapshot)
void ProcSendSignal(ProcNumber procNumber)
void ProcWaitForSignal(uint32 wait_event_info)
SERIALIZABLEXACT * myXact
PREDICATELOCKTARGET * myTarget
PREDICATELOCKTARGETTAG tag
dlist_head predicateLocks
SerCommitSeqNo commitSeqNo
SERIALIZABLEXACT * element
SerCommitSeqNo LastSxactCommitSeqNo
SerCommitSeqNo CanPartialClearThrough
SERIALIZABLEXACT * OldCommittedSxact
SerCommitSeqNo HavePartialClearedThrough
TransactionId SxactGlobalXmin
SERIALIZABLEXACT * sxactIn
SERIALIZABLEXACT * sxactOut
RelFileLocator rd_locator
VirtualTransactionId vxid
LWLock perXactPredicateListLock
union SERIALIZABLEXACT::@115 SeqNo
SerCommitSeqNo lastCommitBeforeSnapshot
dlist_head possibleUnsafeConflicts
SerCommitSeqNo prepareSeqNo
dlist_head predicateLocks
SerCommitSeqNo commitSeqNo
TransactionId finishedBefore
SerCommitSeqNo earliestOutConflictCommit
SERIALIZABLEXACT * myXact
FullTransactionId nextXid
PREDICATELOCKTARGETTAG target
TwoPhasePredicateRecordType type
union TwoPhasePredicateRecord::@116 data
TwoPhasePredicateLockRecord lockRecord
TwoPhasePredicateXactRecord xactRecord
LocalTransactionId localTransactionId
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)
#define FirstUnpinnedObjectId
#define InvalidTransactionId
#define TransactionIdEquals(id1, id2)
#define XidFromFullTransactionId(x)
#define FirstNormalTransactionId
#define TransactionIdIsValid(xid)
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
#define TWOPHASE_RM_PREDICATELOCK_ID
TransamVariablesData * TransamVariables
TransactionId GetTopTransactionIdIfAny(void)
bool IsSubTransaction(void)
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
bool IsInParallelMode(void)
#define IsolationIsSerializable()
bool RecoveryInProgress(void)