PostgreSQL Source Code: src/include/access/transam.h File Reference (original) (raw)

Go to the source code of this file.

◆ AssertTransactionIdInAllowableRange

| #define AssertTransactionIdInAllowableRange | ( | | xid | ) | ((void)true) | | ------------------------------------------- | - | | --- | - | --------------------------------------------------------------- |

◆ BootstrapTransactionId

◆ EpochFromFullTransactionId

| #define EpochFromFullTransactionId | ( | | x | ) | ((uint32) ((x).value >> 32)) | | ---------------------------------- | - | | ---------------------------------------------------- | - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

◆ FirstGenbkiObjectId

#define FirstGenbkiObjectId 10000

◆ FirstNormalFullTransactionId

◆ FirstNormalObjectId

#define FirstNormalObjectId 16384

◆ FirstNormalTransactionId

◆ FirstUnpinnedObjectId

#define FirstUnpinnedObjectId 12000

◆ FrozenTransactionId

◆ FullTransactionIdEquals

◆ FullTransactionIdFollows

◆ FullTransactionIdFollowsOrEquals

| #define FullTransactionIdFollowsOrEquals | ( | | a, | | ------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ----------------------------------------------------- | | | b | | | | | ) | ((a).value >= (b).value) | | |

◆ FullTransactionIdIsNormal

◆ FullTransactionIdIsValid

◆ FullTransactionIdPrecedes

◆ FullTransactionIdPrecedesOrEquals

| #define FullTransactionIdPrecedesOrEquals | ( | | a, | | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ----------------------------------------------------- | | | b | | | | | ) | ((a).value <= (b).value) | | |

◆ InvalidFullTransactionId

◆ InvalidTransactionId

◆ MaxTransactionId

◆ NormalTransactionIdFollows

| #define NormalTransactionIdFollows | ( | | id1, | | ---------------------------------- | - | | ---- | | | id2 | | | | | ) | | | |

Value:

(int32) ((id1) - (id2)) > 0)

#define AssertMacro(condition)

#define TransactionIdIsNormal(xid)

Definition at line 152 of file transam.h.

◆ NormalTransactionIdPrecedes

| #define NormalTransactionIdPrecedes | ( | | id1, | | ----------------------------------- | - | | ---- | | | id2 | | | | | ) | | | |

◆ StoreInvalidTransactionId

◆ TransactionIdAdvance

| #define TransactionIdAdvance | ( | | dest | ) | | ---------------------------- | - | | ---- | - |

Value:

do { \

} while(0)

#define FirstNormalTransactionId

Definition at line 91 of file transam.h.

◆ TransactionIdEquals

| #define TransactionIdEquals | ( | | id1, | | --------------------------- | ---------------- | | ---- | | | id2 | | | | | ) | ((id1) == (id2)) | | |

◆ TransactionIdIsNormal

◆ TransactionIdIsValid

◆ TransactionIdRetreat

| #define TransactionIdRetreat | ( | | dest | ) | | ---------------------------- | - | | ---- | - |

◆ TransactionIdStore

| #define TransactionIdStore | ( | | xid, | | -------------------------- | ------------------ | | ---- | | | dest | | | | | ) | (*(dest) = (xid)) | | |

◆ U64FromFullTransactionId

| #define U64FromFullTransactionId | ( | | x | ) | ((x).value) | | -------------------------------- | - | | ---------------------------------------------------- | - | ---------------------------------------------------------------------------------------------------------------------- |

◆ XidFromFullTransactionId

◆ FullTransactionId

◆ TransamVariablesData

◆ AdvanceNextFullTransactionIdPastXid()

Definition at line 304 of file varsup.c.

305{

309

310

311

312

313

314

316

317

320 return;

321

322

323

324

325

326

327

328

329

332 if (unlikely(xid < next_xid))

335

336

337

338

339

343}

Assert(PointerIsAligned(start, uint64))

bool LWLockAcquire(LWLock *lock, LWLockMode mode)

void LWLockRelease(LWLock *lock)

#define AmStartupProcess()

FullTransactionId nextXid

#define EpochFromFullTransactionId(x)

static bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2)

#define XidFromFullTransactionId(x)

static FullTransactionId FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)

#define TransactionIdAdvance(dest)

TransamVariablesData * TransamVariables

static const unsigned __int64 epoch

References AmStartupProcess, Assert(), epoch, EpochFromFullTransactionId, FullTransactionIdFromEpochAndXid(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, TransactionIdAdvance, TransactionIdFollowsOrEquals(), TransamVariables, unlikely, and XidFromFullTransactionId.

Referenced by ApplyWalRecord(), multixact_redo(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), RecordKnownAssignedTransactionIds(), xact_redo_abort(), and xact_redo_commit().

◆ AdvanceOldestClogXid()

◆ ForceTransactionIdLimitUpdate()

Definition at line 517 of file varsup.c.

518{

522 Oid oldestXidDB;

523

524

531

533 return true;

535 return true;

537 return true;

539 return true;

540 return false;

541}

static Datum ObjectIdGetDatum(Oid X)

TransactionId xidVacLimit

#define SearchSysCacheExists1(cacheId, key1)

#define TransactionIdIsValid(xid)

References LW_SHARED, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, ObjectIdGetDatum(), TransamVariablesData::oldestXid, TransamVariablesData::oldestXidDB, SearchSysCacheExists1, TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransactionIdIsValid, TransamVariables, XidFromFullTransactionId, and TransamVariablesData::xidVacLimit.

Referenced by vac_update_datfrozenxid().

◆ FullTransactionIdAdvance()

◆ FullTransactionIdFromAllowableAt()

Definition at line 443 of file transam.h.

445{

447

448

451

454

455

456

457

458

459

460

461

462

463

464

465

466

467

470 {

473 }

474

476}

static bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)

References Assert(), epoch, EpochFromFullTransactionId, FullTransactionIdFromEpochAndXid(), TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), unlikely, and XidFromFullTransactionId.

Referenced by AdjustToFullTransactionId(), pg_current_snapshot(), PrepareRedoAdd(), PrepareRedoRemove(), ProcessStandbyPSRequestMessage(), removable_cutoff(), TransactionIdInRecentPast(), and XLogRecGetFullXid().

◆ FullTransactionIdFromEpochAndXid()

◆ FullTransactionIdFromU64()

◆ FullTransactionIdNewer()

◆ FullTransactionIdRetreat()

◆ GetNewObjectId()

Definition at line 555 of file varsup.c.

556{

557 Oid result;

558

559

561 elog(ERROR, "cannot assign OIDs during recovery");

562

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

580 {

582 {

583

586 }

587 else

588 {

589

591 {

592

595 }

596 }

597 }

598

599

601 {

604 }

605

607

610

612

613 return result;

614}

bool IsPostmasterEnvironment

#define FirstGenbkiObjectId

#define FirstNormalObjectId

bool RecoveryInProgress(void)

void XLogPutNextOid(Oid nextOid)

References elog, ERROR, FirstGenbkiObjectId, FirstNormalObjectId, IsPostmasterEnvironment, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextOid, TransamVariablesData::oidCount, RecoveryInProgress(), TransamVariables, VAR_OID_PREFETCH, and XLogPutNextOid().

Referenced by GetNewOidWithIndex(), and GetNewRelFileNumber().

◆ GetNewTransactionId()

Definition at line 77 of file varsup.c.

78{

81

82

83

84

85

87 elog(ERROR, "cannot assign TransactionIds during a parallel operation");

88

89

90

91

92

94 {

99 }

100

101

103 elog(ERROR, "cannot assign TransactionIds during recovery");

104

106

109

110

111

112

113

114

115

116

117

118

119

120

121

122

124 {

125

126

127

128

129

130

131

136

138

139

140

141

142

143

146

149 {

151

152

153 if (oldest_datname)

155 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

156 errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database \"%s\"",

157 oldest_datname),

158 errhint("Execute a database-wide VACUUM in that database.\n"

159 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

160 else

162 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

163 errmsg("database is not accepting commands that assign new transaction IDs to avoid wraparound data loss in database with OID %u",

164 oldest_datoid),

165 errhint("Execute a database-wide VACUUM in that database.\n"

166 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

167 }

169 {

171

172

173 if (oldest_datname)

175 (errmsg("database \"%s\" must be vacuumed within %u transactions",

176 oldest_datname,

177 xidWrapLimit - xid),

178 errhint("To avoid transaction ID assignment failures, execute a database-wide VACUUM in that database.\n"

179 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

180 else

182 (errmsg("database with OID %u must be vacuumed within %u transactions",

183 oldest_datoid,

184 xidWrapLimit - xid),

185 errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"

186 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

187 }

188

189

193 }

194

195

196

197

198

199

200

201

202

203

207

208

209

210

211

212

213

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250 if (!isSubXact)

251 {

256

257

260 }

261 else

262 {

265

268

270 {

274 }

275 else

277 }

278

280

281 return full_xid;

282}

#define pg_write_barrier()

void ExtendCLOG(TransactionId newestXact)

void ExtendCommitTs(TransactionId newestXact)

int errhint(const char *fmt,...)

int errcode(int sqlerrcode)

int errmsg(const char *fmt,...)

#define ereport(elevel,...)

char * get_database_name(Oid dbid)

#define IsBootstrapProcessingMode()

void SendPostmasterSignal(PMSignalReason reason)

@ PMSIGNAL_START_AUTOVAC_LAUNCHER

#define PGPROC_MAX_CACHED_SUBXIDS

XidCacheStatus subxidStatus

XidCacheStatus * subxidStates

TransactionId xidStopLimit

TransactionId xidWarnLimit

TransactionId xidWrapLimit

TransactionId xids[PGPROC_MAX_CACHED_SUBXIDS]

void ExtendSUBTRANS(TransactionId newestXact)

#define BootstrapTransactionId

static void FullTransactionIdAdvance(FullTransactionId *dest)

bool IsInParallelMode(void)

References Assert(), BootstrapTransactionId, XidCacheStatus::count, elog, ereport, errcode(), errhint(), errmsg(), ERROR, ExtendCLOG(), ExtendCommitTs(), ExtendSUBTRANS(), FullTransactionIdAdvance(), FullTransactionIdFromEpochAndXid(), get_database_name(), IsBootstrapProcessingMode, IsInParallelMode(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MyProc, TransamVariablesData::nextXid, TransamVariablesData::oldestXidDB, XidCacheStatus::overflowed, pg_write_barrier, PGPROC_MAX_CACHED_SUBXIDS, PGPROC::pgxactoff, PMSIGNAL_START_AUTOVAC_LAUNCHER, ProcGlobal, RecoveryInProgress(), SendPostmasterSignal(), PGPROC::subxids, PROC_HDR::subxidStates, PGPROC::subxidStatus, TransactionIdFollowsOrEquals(), TransamVariables, WARNING, PGPROC::xid, XidFromFullTransactionId, XidCache::xids, PROC_HDR::xids, TransamVariablesData::xidStopLimit, TransamVariablesData::xidVacLimit, TransamVariablesData::xidWarnLimit, and TransamVariablesData::xidWrapLimit.

Referenced by AssignTransactionId(), and consume_xids_common().

◆ NormalTransactionIdOlder()

◆ ReadNextFullTransactionId()

Definition at line 288 of file varsup.c.

289{

291

295

296 return fullXid;

297}

References LW_SHARED, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, and TransamVariables.

Referenced by _bt_unlink_halfdead_page(), AdjustToFullTransactionId(), consume_xids(), consume_xids_common(), gistdeletepage(), pg_current_snapshot(), ProcessStandbyPSRequestMessage(), ReadNextTransactionId(), removable_cutoff(), ResolveRecoveryConflictWithSnapshotFullXid(), TransactionIdInRecentPast(), and XLogWalRcvSendHSFeedback().

◆ ReadNextTransactionId()

Definition at line 377 of file transam.h.

378{

380}

FullTransactionId ReadNextFullTransactionId(void)

References ReadNextFullTransactionId(), and XidFromFullTransactionId.

Referenced by ActivateCommitTs(), AutoVacWorkerMain(), do_start_worker(), GetStableLatestTransactionId(), ginDeletePage(), heap_vacuum_rel(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), and vacuum_xid_failsafe_check().

◆ SetTransactionIdLimit()

Definition at line 372 of file varsup.c.

373{

379

381

382

383

384

385

386

387

388

389 xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);

392

393

394

395

396

397

398

399

400

401

402

403

404

405 xidStopLimit = xidWrapLimit - 3000000;

408

409

410

411

412

413

414

415

416

417

418

419 xidWarnLimit = xidWrapLimit - 40000000;

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

441

442

452

453

455 (errmsg_internal("transaction ID wrap limit is %u, limited by database with OID %u",

456 xidWrapLimit, oldest_datoid)));

457

458

459

460

461

462

463

464

468

469

471 {

472 char *oldest_datname;

473

474

475

476

477

478

479

480

481

482

485 else

486 oldest_datname = NULL;

487

488 if (oldest_datname)

490 (errmsg("database \"%s\" must be vacuumed within %u transactions",

491 oldest_datname,

492 xidWrapLimit - curXid),

493 errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"

494 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

495 else

497 (errmsg("database with OID %u must be vacuumed within %u transactions",

498 oldest_datoid,

499 xidWrapLimit - curXid),

500 errhint("To avoid XID assignment failures, execute a database-wide VACUUM in that database.\n"

501 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));

502 }

503}

int autovacuum_freeze_max_age

int errmsg_internal(const char *fmt,...)

bool IsTransactionState(void)

References Assert(), autovacuum_freeze_max_age, DEBUG1, ereport, errhint(), errmsg(), errmsg_internal(), FirstNormalTransactionId, get_database_name(), InRecovery, IsTransactionState(), IsUnderPostmaster, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MaxTransactionId, TransamVariablesData::nextXid, TransamVariablesData::oldestXid, TransamVariablesData::oldestXidDB, PMSIGNAL_START_AUTOVAC_LAUNCHER, SendPostmasterSignal(), TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransamVariables, WARNING, XidFromFullTransactionId, TransamVariablesData::xidStopLimit, TransamVariablesData::xidVacLimit, TransamVariablesData::xidWarnLimit, and TransamVariablesData::xidWrapLimit.

Referenced by BootStrapXLOG(), StartupXLOG(), vac_truncate_clog(), and xlog_redo().

◆ StopGeneratingPinnedObjectIds()

◆ TransactionIdAbortTree()

◆ TransactionIdAsyncCommitTree()

◆ TransactionIdCommitTree()

◆ TransactionIdDidAbort()

Definition at line 188 of file transam.c.

189{

191

193

194

195

196

198 return true;

199

200

201

202

203

204

205

207 {

209

211 return true;

214 {

215

216 elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",

217 transactionId);

218 return true;

219 }

221 }

222

223

224

225

226 return false;

227}

#define TRANSACTION_STATUS_SUB_COMMITTED

TransactionId TransactionXmin

TransactionId SubTransGetParent(TransactionId xid)

static XidStatus TransactionLogFetch(TransactionId transactionId)

bool TransactionIdDidAbort(TransactionId transactionId)

References elog, SubTransGetParent(), TRANSACTION_STATUS_ABORTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdDidAbort(), TransactionIdIsValid, TransactionIdPrecedes(), TransactionLogFetch(), TransactionXmin, and WARNING.

Referenced by DoesMultiXactIdConflict(), heap_lock_updated_tuple_rec(), heap_update(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), TransactionIdDidAbort(), and TransactionIdIsInProgress().

◆ TransactionIdDidCommit()

Definition at line 126 of file transam.c.

127{

129

131

132

133

134

136 return true;

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

153 {

155

157 return false;

160 {

161 elog(WARNING, "no pg_subtrans entry for subcommitted XID %u",

162 transactionId);

163 return false;

164 }

166 }

167

168

169

170

171 return false;

172}

bool TransactionIdDidCommit(TransactionId transactionId)

References elog, SubTransGetParent(), TRANSACTION_STATUS_COMMITTED, TRANSACTION_STATUS_SUB_COMMITTED, TransactionIdDidCommit(), TransactionIdIsValid, TransactionIdPrecedes(), TransactionLogFetch(), TransactionXmin, and WARNING.

Referenced by AsyncNotifyFreezeXids(), asyncQueueProcessPageEntries(), check_safe_enum_use(), compute_new_xmax_infomask(), FreezeMultiXactId(), get_xid_status(), HandleConcurrentAbort(), heap_pre_freeze_checks(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), MultiXactIdExpand(), pg_xact_status(), ProcArrayApplyRecoveryInfo(), ProcessTwoPhaseBuffer(), RecordTransactionAbort(), RecordTransactionAbortPrepared(), ReorderBufferCheckAndTruncateAbortedTXN(), SetupCheckXidLive(), StandbyAcquireAccessExclusiveLock(), test_lockmode_for_conflict(), TransactionIdDidCommit(), UpdateLogicalMappings(), and UpdateXmaxHintBits().

◆ TransactionIdFollows()

Definition at line 297 of file transam.h.

298{

300

302 return (id1 > id2);

303

304 diff = (int32) (id1 - id2);

305 return (diff > 0);

306}

References TransactionIdIsNormal.

Referenced by find_inheritance_children_extended(), GetConflictingVirtualXIDs(), GetSerializableTransactionSnapshotInt(), heap_page_prune_and_freeze(), heap_page_would_be_all_visible(), heap_prune_record_unchanged_lp_normal(), HeapTupleHeaderAdvanceConflictHorizon(), predicatelock_twophase_recover(), ProcessTwoPhaseBuffer(), RecordKnownAssignedTransactionIds(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialSetActiveSerXmin(), SnapBuildInitialSnapshot(), SnapBuildWaitSnapshot(), SubTransSetParent(), update_local_synced_slot(), and xmin_cmp().

◆ TransactionIdFollowsOrEquals()

Definition at line 312 of file transam.h.

313{

315

317 return (id1 >= id2);

318

319 diff = (int32) (id1 - id2);

320 return (diff >= 0);

321}

References TransactionIdIsNormal.

Referenced by AdvanceNextFullTransactionIdPastXid(), ForceTransactionIdLimitUpdate(), GetNewTransactionId(), HeapCheckForSerializableConflictOut(), HeapTupleSatisfiesHistoricMVCC(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsRemovePreceding(), SetTransactionIdLimit(), SnapBuildCommitTxn(), SnapBuildPurgeOlderTxn(), SubTransGetParent(), SubTransGetTopmostTransaction(), vacuumLeafPage(), XidInMVCCSnapshot(), and XidIsConcurrent().

◆ TransactionIdGetCommitLSN()

◆ TransactionIdLatest()

◆ TransactionIdOlder()

◆ TransactionIdPrecedes()

Definition at line 263 of file transam.h.

264{

265

266

267

268

270

272 return (id1 < id2);

273

274 diff = (int32) (id1 - id2);

275 return (diff < 0);

276}

References TransactionIdIsNormal.

Referenced by AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AsyncNotifyFreezeXids(), bt_check_every_level(), check_exclusion_or_unique_constraint(), check_tuple_visibility(), CheckTargetForConflictsIn(), CLOGPagePrecedes(), collect_corrupt_items(), CommitTsPagePrecedes(), compute_min_nonremovable_xid(), copy_table_data(), do_start_worker(), ExpireOldKnownAssignedTransactionIds(), ExportSnapshot(), FreezeMultiXactId(), get_relation_info(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), heap_abort_speculative(), heap_page_would_be_all_visible(), heap_prepare_freeze_tuple(), heap_prune_record_prunable(), heap_prune_record_unchanged_lp_normal(), heap_tuple_should_freeze(), heap_vacuum_eager_scan_setup(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesVacuum(), IsIndexUsableForFindingDeletedTuple(), KnownAssignedXidsAdd(), KnownAssignedXidsGetAndSetXmin(), KnownAssignedXidsSearch(), logical_rewrite_heap_tuple(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), multixact_redo(), PhysicalReplicationSlotNewXmin(), PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcessStandbyHSFeedbackMessage(), ProcessStandbyPSRequestMessage(), RecordKnownAssignedTransactionIds(), relation_needs_vacanalyze(), ReorderBufferAbortOld(), ReplicationSlotsComputeRequiredXmin(), rewrite_heap_tuple(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialPagePrecedesLogically(), SerialSetActiveSerXmin(), SetCommitTsLimit(), SetNewSxactGlobalXmin(), SnapBuildCommitTxn(), SnapBuildProcessChange(), SnapBuildRestore(), SnapshotResetXmin(), StandbyReleaseOldLocks(), SubTransGetTopmostTransaction(), SubTransPagePrecedes(), TransactionIdDidAbort(), TransactionIdDidCommit(), TransactionIdGetCommitTsData(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TransactionIdLatest(), TransactionIdOlder(), TransactionTreeSetCommitTsData(), tuple_all_visible(), TwoPhaseGetOldestXidInCommit(), update_local_synced_slot(), vac_truncate_clog(), vac_update_datfrozenxid(), vac_update_relstats(), vacuum_get_cutoffs(), vacuum_xid_failsafe_check(), vacuumRedirectAndPlaceholder(), XidInMVCCSnapshot(), XidIsConcurrent(), xidLogicalComparator(), xlog_redo(), and xmin_cmp().

◆ TransactionIdPrecedesOrEquals()

Definition at line 282 of file transam.h.

283{

285

287 return (id1 <= id2);

288

289 diff = (int32) (id1 - id2);

290 return (diff <= 0);

291}

References TransactionIdIsNormal.

Referenced by ClearOldPredicateLocks(), ComputeXidHorizons(), DetermineSlotInvalidationCause(), FullTransactionIdFromAllowableAt(), get_candidate_xid(), GetCurrentVirtualXIDs(), GetSnapshotData(), GetSnapshotDataReuse(), heap_prepare_freeze_tuple(), heap_tuple_should_freeze(), heap_vacuum_rel(), KnownAssignedXidsAdd(), LogicalIncreaseXminForSlot(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SnapBuildFindSnapshot(), TransactionIdInRecentPast(), TransactionIdIsInProgress(), update_conflict_slot_xmin(), and vacuum_get_cutoffs().

◆ TransactionIdRetreatedBy()

◆ TransactionStartedDuringRecovery()

◆ VarsupShmemInit()

◆ VarsupShmemSize()

◆ TransamVariables

Definition at line 34 of file varsup.c.

Referenced by ActivateCommitTs(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), BootStrapXLOG(), ComputeXidHorizons(), consume_xids_shortcut(), CreateCheckPoint(), DeactivateCommitTs(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ForceTransactionIdLimitUpdate(), get_xid_status(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestSafeDecodingTransactionId(), GetRunningTransactionData(), GetSnapshotData(), GetSnapshotDataReuse(), GetStrictOldestNonRemovableTransactionId(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), PrepareRedoAdd(), PrepareRedoRemove(), PrescanPreparedTransactions(), ProcArrayApplyRecoveryInfo(), ProcArrayClearTransaction(), ProcArrayEndTransactionInternal(), ProcArrayRemove(), ProcArrayShmemInit(), ProcessTwoPhaseBuffer(), ReadNextFullTransactionId(), ReleasePredicateLocks(), SetCommitTsLimit(), SetNextObjectId(), SetTransactionIdLimit(), StartupCLOG(), StartupSUBTRANS(), StartupXLOG(), TransactionIdGetCommitTsData(), TransactionIdInRecentPast(), TransactionIdIsInProgress(), TransactionTreeSetCommitTsData(), TrimCLOG(), update_cached_xid_range(), VarsupShmemInit(), XidCacheRemoveRunningXids(), xlog_redo(), and XLogRecGetFullXid().