PostgreSQL Source Code  git master
inval.h File Reference
#include "access/htup.h"
#include "storage/relfilelocator.h"
#include "utils/relcache.h"
Include dependency graph for inval.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs

typedef void(* SyscacheCallbackFunction) (Datum arg, int cacheid, uint32 hashvalue)
 
typedef void(* RelcacheCallbackFunction) (Datum arg, Oid relid)
 

Functions

void AcceptInvalidationMessages (void)
 
void AtEOXact_Inval (bool isCommit)
 
void PreInplace_Inval (void)
 
void AtInplace_Inval (void)
 
void ForgetInplace_Inval (void)
 
void AtEOSubXact_Inval (bool isCommit)
 
void PostPrepare_Inval (void)
 
void CommandEndInvalidationMessages (void)
 
void CacheInvalidateHeapTuple (Relation relation, HeapTuple tuple, HeapTuple newtuple)
 
void CacheInvalidateHeapTupleInplace (Relation relation, HeapTuple tuple, HeapTuple newtuple)
 
void CacheInvalidateCatalog (Oid catalogId)
 
void CacheInvalidateRelcache (Relation relation)
 
void CacheInvalidateRelcacheAll (void)
 
void CacheInvalidateRelcacheByTuple (HeapTuple classTuple)
 
void CacheInvalidateRelcacheByRelid (Oid relid)
 
void CacheInvalidateSmgr (RelFileLocatorBackend rlocator)
 
void CacheInvalidateRelmap (Oid databaseId)
 
void CacheRegisterSyscacheCallback (int cacheid, SyscacheCallbackFunction func, Datum arg)
 
void CacheRegisterRelcacheCallback (RelcacheCallbackFunction func, Datum arg)
 
void CallSyscacheCallbacks (int cacheid, uint32 hashvalue)
 
void InvalidateSystemCaches (void)
 
void InvalidateSystemCachesExtended (bool debug_discard)
 
void LogLogicalInvalidations (void)
 

Variables

PGDLLIMPORT int debug_discard_caches
 

Typedef Documentation

◆ RelcacheCallbackFunction

typedef void(* RelcacheCallbackFunction) (Datum arg, Oid relid)

Definition at line 24 of file inval.h.

◆ SyscacheCallbackFunction

typedef void(* SyscacheCallbackFunction) (Datum arg, int cacheid, uint32 hashvalue)

Definition at line 23 of file inval.h.

Function Documentation

◆ AcceptInvalidationMessages()

void AcceptInvalidationMessages ( void  )

Definition at line 863 of file inval.c.

864 {
867 
868  /*----------
869  * Test code to force cache flushes anytime a flush could happen.
870  *
871  * This helps detect intermittent faults caused by code that reads a cache
872  * entry and then performs an action that could invalidate the entry, but
873  * rarely actually does so. This can spot issues that would otherwise
874  * only arise with badly timed concurrent DDL, for example.
875  *
876  * The default debug_discard_caches = 0 does no forced cache flushes.
877  *
878  * If used with CLOBBER_FREED_MEMORY,
879  * debug_discard_caches = 1 (formerly known as CLOBBER_CACHE_ALWAYS)
880  * provides a fairly thorough test that the system contains no cache-flush
881  * hazards. However, it also makes the system unbelievably slow --- the
882  * regression tests take about 100 times longer than normal.
883  *
884  * If you're a glutton for punishment, try
885  * debug_discard_caches = 3 (formerly known as CLOBBER_CACHE_RECURSIVELY).
886  * This slows things by at least a factor of 10000, so I wouldn't suggest
887  * trying to run the entire regression tests that way. It's useful to try
888  * a few simple tests, to make sure that cache reload isn't subject to
889  * internal cache-flush hazards, but after you've done a few thousand
890  * recursive reloads it's unlikely you'll learn more.
891  *----------
892  */
893 #ifdef DISCARD_CACHES_ENABLED
894  {
895  static int recursion_depth = 0;
896 
898  {
899  recursion_depth++;
901  recursion_depth--;
902  }
903  }
904 #endif
905 }
static int recursion_depth
Definition: elog.c:149
void InvalidateSystemCachesExtended(bool debug_discard)
Definition: inval.c:731
void LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg)
Definition: inval.c:762
void InvalidateSystemCaches(void)
Definition: inval.c:849
int debug_discard_caches
Definition: inval.c:258
void ReceiveSharedInvalidMessages(void(*invalFunction)(SharedInvalidationMessage *msg), void(*resetFunction)(void))
Definition: sinval.c:69

References debug_discard_caches, InvalidateSystemCaches(), InvalidateSystemCachesExtended(), LocalExecuteInvalidationMessage(), ReceiveSharedInvalidMessages(), and recursion_depth.

Referenced by apply_handle_commit_internal(), AtStart_Cache(), ConditionalLockDatabaseObject(), ConditionalLockRelation(), ConditionalLockRelationOid(), ConditionalLockSharedObject(), delay_execution_planner(), heap_inplace_update_and_unlock(), InitializeSessionUserId(), LockDatabaseObject(), LockRelation(), LockRelationId(), LockRelationOid(), LockSharedObject(), LogicalRepApplyLoop(), pgstat_init_function_usage(), ProcessCatchupInterrupt(), RangeVarGetRelidExtended(), relation_openrv(), relation_openrv_extended(), RelationBuildPartitionDesc(), RemoveRelations(), SearchSysCacheLocked1(), and write_relcache_init_file().

◆ AtEOSubXact_Inval()

void AtEOSubXact_Inval ( bool  isCommit)

Definition at line 1235 of file inval.c.

1236 {
1237  int my_level;
1238  TransInvalidationInfo *myInfo;
1239 
1240  /*
1241  * Successful inplace update must clear this, but we clear it on abort.
1242  * Inplace updates allocate this in CurrentMemoryContext, which has
1243  * lifespan <= subtransaction lifespan. Hence, don't free it explicitly.
1244  */
1245  if (isCommit)
1246  Assert(inplaceInvalInfo == NULL);
1247  else
1248  inplaceInvalInfo = NULL;
1249 
1250  /* Quick exit if no transactional messages. */
1251  myInfo = transInvalInfo;
1252  if (myInfo == NULL)
1253  return;
1254 
1255  /* Also bail out quickly if messages are not for this level. */
1256  my_level = GetCurrentTransactionNestLevel();
1257  if (myInfo->my_level != my_level)
1258  {
1259  Assert(myInfo->my_level < my_level);
1260  return;
1261  }
1262 
1263  if (isCommit)
1264  {
1265  /* If CurrentCmdInvalidMsgs still has anything, fix it */
1267 
1268  /*
1269  * We create invalidation stack entries lazily, so the parent might
1270  * not have one. Instead of creating one, moving all the data over,
1271  * and then freeing our own, we can just adjust the level of our own
1272  * entry.
1273  */
1274  if (myInfo->parent == NULL || myInfo->parent->my_level < my_level - 1)
1275  {
1276  myInfo->my_level--;
1277  return;
1278  }
1279 
1280  /*
1281  * Pass up my inval messages to parent. Notice that we stick them in
1282  * PriorCmdInvalidMsgs, not CurrentCmdInvalidMsgs, since they've
1283  * already been locally processed. (This would trigger the Assert in
1284  * AppendInvalidationMessageSubGroup if the parent's
1285  * CurrentCmdInvalidMsgs isn't empty; but we already checked that in
1286  * PrepareInvalidationState.)
1287  */
1289  &myInfo->PriorCmdInvalidMsgs);
1290 
1291  /* Must readjust parent's CurrentCmdInvalidMsgs indexes now */
1293  &myInfo->parent->PriorCmdInvalidMsgs);
1294 
1295  /* Pending relcache inval becomes parent's problem too */
1296  if (myInfo->ii.RelcacheInitFileInval)
1297  myInfo->parent->ii.RelcacheInitFileInval = true;
1298 
1299  /* Pop the transaction state stack */
1300  transInvalInfo = myInfo->parent;
1301 
1302  /* Need not free anything else explicitly */
1303  pfree(myInfo);
1304  }
1305  else
1306  {
1309 
1310  /* Pop the transaction state stack */
1311  transInvalInfo = myInfo->parent;
1312 
1313  /* Need not free anything else explicitly */
1314  pfree(myInfo);
1315  }
1316 }
#define Assert(condition)
Definition: c.h:837
static void ProcessInvalidationMessages(InvalidationMsgsGroup *group, void(*func)(SharedInvalidationMessage *msg))
Definition: inval.c:532
static InvalidationInfo * inplaceInvalInfo
Definition: inval.c:255
static TransInvalidationInfo * transInvalInfo
Definition: inval.c:253
static void AppendInvalidationMessages(InvalidationMsgsGroup *dest, InvalidationMsgsGroup *src)
Definition: inval.c:518
#define SetGroupToFollow(targetgroup, priorgroup)
Definition: inval.c:196
void CommandEndInvalidationMessages(void)
Definition: inval.c:1334
void pfree(void *pointer)
Definition: mcxt.c:1521
bool RelcacheInitFileInval
Definition: inval.c:234
InvalidationMsgsGroup CurrentCmdInvalidMsgs
Definition: inval.c:231
struct TransInvalidationInfo * parent
Definition: inval.c:247
struct InvalidationInfo ii
Definition: inval.c:241
InvalidationMsgsGroup PriorCmdInvalidMsgs
Definition: inval.c:244
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:928

References AppendInvalidationMessages(), Assert, CommandEndInvalidationMessages(), InvalidationInfo::CurrentCmdInvalidMsgs, GetCurrentTransactionNestLevel(), TransInvalidationInfo::ii, inplaceInvalInfo, LocalExecuteInvalidationMessage(), TransInvalidationInfo::my_level, TransInvalidationInfo::parent, pfree(), TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), InvalidationInfo::RelcacheInitFileInval, SetGroupToFollow, and transInvalInfo.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_Inval()

void AtEOXact_Inval ( bool  isCommit)

Definition at line 1126 of file inval.c.

1127 {
1128  inplaceInvalInfo = NULL;
1129 
1130  /* Quick exit if no transactional messages */
1131  if (transInvalInfo == NULL)
1132  return;
1133 
1134  /* Must be at top of stack */
1135  Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
1136 
1137  if (isCommit)
1138  {
1139  /*
1140  * Relcache init file invalidation requires processing both before and
1141  * after we send the SI messages. However, we need not do anything
1142  * unless we committed.
1143  */
1146 
1149 
1152 
1155  }
1156  else
1157  {
1160  }
1161 
1162  /* Need not free anything explicitly */
1163  transInvalInfo = NULL;
1164 }
static void ProcessInvalidationMessagesMulti(InvalidationMsgsGroup *group, void(*func)(const SharedInvalidationMessage *msgs, int n))
Definition: inval.c:544
void RelationCacheInitFilePostInvalidate(void)
Definition: relcache.c:6780
void RelationCacheInitFilePreInvalidate(void)
Definition: relcache.c:6755
void SendSharedInvalidMessages(const SharedInvalidationMessage *msgs, int n)
Definition: sinval.c:47

References AppendInvalidationMessages(), Assert, InvalidationInfo::CurrentCmdInvalidMsgs, TransInvalidationInfo::ii, inplaceInvalInfo, LocalExecuteInvalidationMessage(), TransInvalidationInfo::my_level, TransInvalidationInfo::parent, TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), ProcessInvalidationMessagesMulti(), RelationCacheInitFilePostInvalidate(), RelationCacheInitFilePreInvalidate(), InvalidationInfo::RelcacheInitFileInval, SendSharedInvalidMessages(), and transInvalInfo.

Referenced by AbortTransaction(), CommitTransaction(), and PostPrepare_Inval().

◆ AtInplace_Inval()

◆ CacheInvalidateCatalog()

void CacheInvalidateCatalog ( Oid  catalogId)

Definition at line 1530 of file inval.c.

1531 {
1532  Oid databaseId;
1533 
1534  if (IsSharedRelation(catalogId))
1535  databaseId = InvalidOid;
1536  else
1537  databaseId = MyDatabaseId;
1538 
1540  databaseId, catalogId);
1541 }
bool IsSharedRelation(Oid relationId)
Definition: catalog.c:273
Oid MyDatabaseId
Definition: globals.c:93
static InvalidationInfo * PrepareInvalidationState(void)
Definition: inval.c:629
static void RegisterCatalogInvalidation(InvalidationInfo *info, Oid dbId, Oid catId)
Definition: inval.c:579
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31

References InvalidOid, IsSharedRelation(), MyDatabaseId, PrepareInvalidationState(), and RegisterCatalogInvalidation().

Referenced by finish_heap_swap().

◆ CacheInvalidateHeapTuple()

void CacheInvalidateHeapTuple ( Relation  relation,
HeapTuple  tuple,
HeapTuple  newtuple 
)

Definition at line 1493 of file inval.c.

1496 {
1497  CacheInvalidateHeapTupleCommon(relation, tuple, newtuple,
1499 }
static void CacheInvalidateHeapTupleCommon(Relation relation, HeapTuple tuple, HeapTuple newtuple, InvalidationInfo *(*prepare_callback)(void))
Definition: inval.c:1361

References CacheInvalidateHeapTupleCommon(), and PrepareInvalidationState().

Referenced by AlterDomainAddConstraint(), AlterDomainDropConstraint(), heap_delete(), heap_inplace_update_and_unlock(), heap_insert(), heap_multi_insert(), and heap_update().

◆ CacheInvalidateHeapTupleInplace()

void CacheInvalidateHeapTupleInplace ( Relation  relation,
HeapTuple  tuple,
HeapTuple  newtuple 
)

Definition at line 1510 of file inval.c.

1513 {
1514  CacheInvalidateHeapTupleCommon(relation, tuple, newtuple,
1516 }
static InvalidationInfo * PrepareInplaceInvalidationState(void)
Definition: inval.c:698

References CacheInvalidateHeapTupleCommon(), and PrepareInplaceInvalidationState().

Referenced by heap_inplace_lock().

◆ CacheInvalidateRelcache()

◆ CacheInvalidateRelcacheAll()

◆ CacheInvalidateRelcacheByRelid()

void CacheInvalidateRelcacheByRelid ( Oid  relid)

Definition at line 1609 of file inval.c.

1610 {
1611  HeapTuple tup;
1612 
1613  tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1614  if (!HeapTupleIsValid(tup))
1615  elog(ERROR, "cache lookup failed for relation %u", relid);
1617  ReleaseSysCache(tup);
1618 }
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
void CacheInvalidateRelcacheByTuple(HeapTuple classTuple)
Definition: inval.c:1587
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221

References CacheInvalidateRelcacheByTuple(), elog, ERROR, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

Referenced by ATExecAlterConstraint(), ATExecAttachPartition(), DefineIndex(), DetachPartitionFinalize(), heap_drop_with_catalog(), InvalidatePublicationRels(), ReindexRelationConcurrently(), RemoveStatisticsById(), and StorePartitionBound().

◆ CacheInvalidateRelcacheByTuple()

void CacheInvalidateRelcacheByTuple ( HeapTuple  classTuple)

Definition at line 1587 of file inval.c.

1588 {
1589  Form_pg_class classtup = (Form_pg_class) GETSTRUCT(classTuple);
1590  Oid databaseId;
1591  Oid relationId;
1592 
1593  relationId = classtup->oid;
1594  if (classtup->relisshared)
1595  databaseId = InvalidOid;
1596  else
1597  databaseId = MyDatabaseId;
1599  databaseId, relationId);
1600 }
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153

References GETSTRUCT, InvalidOid, MyDatabaseId, PrepareInvalidationState(), and RegisterRelcacheInvalidation().

Referenced by CacheInvalidateRelcacheByRelid(), copy_table_data(), CreateTriggerFiringOn(), index_update_stats(), RemoveRoleFromObjectPolicy(), SetRelationHasSubclass(), SetRelationRuleStatus(), and swap_relation_files().

◆ CacheInvalidateRelmap()

void CacheInvalidateRelmap ( Oid  databaseId)

Definition at line 1677 of file inval.c.

1678 {
1680 
1681  msg.rm.id = SHAREDINVALRELMAP_ID;
1682  msg.rm.dbId = databaseId;
1683  /* check AddCatcacheInvalidationMessage() for an explanation */
1684  VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
1685 
1686  SendSharedInvalidMessages(&msg, 1);
1687 }
#define VALGRIND_MAKE_MEM_DEFINED(addr, size)
Definition: memdebug.h:26
#define SHAREDINVALRELMAP_ID
Definition: sinval.h:96
SharedInvalRelmapMsg rm
Definition: sinval.h:120

References SharedInvalRelmapMsg::dbId, SharedInvalRelmapMsg::id, SharedInvalidationMessage::rm, SendSharedInvalidMessages(), SHAREDINVALRELMAP_ID, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by write_relmap_file().

◆ CacheInvalidateSmgr()

void CacheInvalidateSmgr ( RelFileLocatorBackend  rlocator)

Definition at line 1647 of file inval.c.

1648 {
1650 
1651  msg.sm.id = SHAREDINVALSMGR_ID;
1652  msg.sm.backend_hi = rlocator.backend >> 16;
1653  msg.sm.backend_lo = rlocator.backend & 0xffff;
1654  msg.sm.rlocator = rlocator.locator;
1655  /* check AddCatcacheInvalidationMessage() for an explanation */
1656  VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
1657 
1658  SendSharedInvalidMessages(&msg, 1);
1659 }
#define SHAREDINVALSMGR_ID
Definition: sinval.h:85
RelFileLocator locator
uint16 backend_lo
Definition: sinval.h:92
RelFileLocator rlocator
Definition: sinval.h:93
SharedInvalSmgrMsg sm
Definition: sinval.h:119

References RelFileLocatorBackend::backend, SharedInvalSmgrMsg::backend_hi, SharedInvalSmgrMsg::backend_lo, SharedInvalSmgrMsg::id, RelFileLocatorBackend::locator, SharedInvalSmgrMsg::rlocator, SendSharedInvalidMessages(), SHAREDINVALSMGR_ID, SharedInvalidationMessage::sm, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by smgrdounlinkall(), smgrtruncate(), and vm_extend().

◆ CacheRegisterRelcacheCallback()

void CacheRegisterRelcacheCallback ( RelcacheCallbackFunction  func,
Datum  arg 
)

Definition at line 1746 of file inval.c.

1748 {
1750  elog(FATAL, "out of relcache_callback_list slots");
1751 
1754 
1756 }
#define FATAL
Definition: elog.h:41
static int relcache_callback_count
Definition: inval.c:291
static struct RELCACHECALLBACK relcache_callback_list[MAX_RELCACHE_CALLBACKS]
#define MAX_RELCACHE_CALLBACKS
Definition: inval.c:271
void * arg
RelcacheCallbackFunction function
Definition: inval.c:287

References RELCACHECALLBACK::arg, arg, elog, FATAL, RELCACHECALLBACK::function, MAX_RELCACHE_CALLBACKS, relcache_callback_count, and relcache_callback_list.

Referenced by init_rel_sync_cache(), InitializeRelfilenumberMap(), InitPlanCache(), logicalrep_partmap_init(), logicalrep_relmap_init(), and lookup_type_cache().

◆ CacheRegisterSyscacheCallback()

void CacheRegisterSyscacheCallback ( int  cacheid,
SyscacheCallbackFunction  func,
Datum  arg 
)

Definition at line 1704 of file inval.c.

1707 {
1708  if (cacheid < 0 || cacheid >= SysCacheSize)
1709  elog(FATAL, "invalid cache ID: %d", cacheid);
1711  elog(FATAL, "out of syscache_callback_list slots");
1712 
1713  if (syscache_callback_links[cacheid] == 0)
1714  {
1715  /* first callback for this cache */
1717  }
1718  else
1719  {
1720  /* add to end of chain, so that older callbacks are called first */
1721  int i = syscache_callback_links[cacheid] - 1;
1722 
1723  while (syscache_callback_list[i].link > 0)
1724  i = syscache_callback_list[i].link - 1;
1726  }
1727 
1732 
1734 }
static struct SYSCACHECALLBACK syscache_callback_list[MAX_SYSCACHE_CALLBACKS]
#define MAX_SYSCACHE_CALLBACKS
Definition: inval.c:270
static int16 syscache_callback_links[SysCacheSize]
Definition: inval.c:281
static int syscache_callback_count
Definition: inval.c:283
int i
Definition: isn.c:72
SyscacheCallbackFunction function
Definition: inval.c:277
int16 link
Definition: inval.c:276

References SYSCACHECALLBACK::arg, arg, elog, FATAL, SYSCACHECALLBACK::function, i, SYSCACHECALLBACK::id, SYSCACHECALLBACK::link, MAX_SYSCACHE_CALLBACKS, syscache_callback_count, syscache_callback_links, and syscache_callback_list.

Referenced by BuildEventTriggerCache(), find_oper_cache_entry(), GetConnection(), init_rel_sync_cache(), init_ts_config_cache(), initialize_acl(), InitializeAttoptCache(), InitializeLogRepWorker(), InitializeSearchPath(), InitializeShippableCache(), InitializeTableSpaceCache(), InitPlanCache(), lookup_proof_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), ParallelApplyWorkerMain(), pgoutput_startup(), ri_InitHashTables(), SetupApplyOrSyncWorker(), and superuser_arg().

◆ CallSyscacheCallbacks()

void CallSyscacheCallbacks ( int  cacheid,
uint32  hashvalue 
)

Definition at line 1765 of file inval.c.

1766 {
1767  int i;
1768 
1769  if (cacheid < 0 || cacheid >= SysCacheSize)
1770  elog(ERROR, "invalid cache ID: %d", cacheid);
1771 
1772  i = syscache_callback_links[cacheid] - 1;
1773  while (i >= 0)
1774  {
1775  struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
1776 
1777  Assert(ccitem->id == cacheid);
1778  ccitem->function(ccitem->arg, cacheid, hashvalue);
1779  i = ccitem->link - 1;
1780  }
1781 }

References SYSCACHECALLBACK::arg, Assert, elog, ERROR, SYSCACHECALLBACK::function, i, SYSCACHECALLBACK::id, SYSCACHECALLBACK::link, syscache_callback_links, and syscache_callback_list.

Referenced by CatalogCacheFlushCatalog(), and LocalExecuteInvalidationMessage().

◆ CommandEndInvalidationMessages()

void CommandEndInvalidationMessages ( void  )

Definition at line 1334 of file inval.c.

1335 {
1336  /*
1337  * You might think this shouldn't be called outside any transaction, but
1338  * bootstrap does it, and also ABORT issued when not in a transaction. So
1339  * just quietly return if no state to work on.
1340  */
1341  if (transInvalInfo == NULL)
1342  return;
1343 
1346 
1347  /* WAL Log per-command invalidation messages for wal_level=logical */
1348  if (XLogLogicalInfoActive())
1350 
1353 }
void LogLogicalInvalidations(void)
Definition: inval.c:1792
#define XLogLogicalInfoActive()
Definition: xlog.h:126

References AppendInvalidationMessages(), InvalidationInfo::CurrentCmdInvalidMsgs, TransInvalidationInfo::ii, LocalExecuteInvalidationMessage(), LogLogicalInvalidations(), TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), transInvalInfo, and XLogLogicalInfoActive.

Referenced by AtCCI_LocalCache(), and AtEOSubXact_Inval().

◆ ForgetInplace_Inval()

void ForgetInplace_Inval ( void  )

Definition at line 1211 of file inval.c.

1212 {
1213  inplaceInvalInfo = NULL;
1214 }

References inplaceInvalInfo.

Referenced by heap_inplace_lock(), and heap_inplace_unlock().

◆ InvalidateSystemCaches()

◆ InvalidateSystemCachesExtended()

void InvalidateSystemCachesExtended ( bool  debug_discard)

Definition at line 731 of file inval.c.

732 {
733  int i;
734 
737  RelationCacheInvalidate(debug_discard); /* gets smgr and relmap too */
738 
739  for (i = 0; i < syscache_callback_count; i++)
740  {
741  struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
742 
743  ccitem->function(ccitem->arg, ccitem->id, 0);
744  }
745 
746  for (i = 0; i < relcache_callback_count; i++)
747  {
748  struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
749 
750  ccitem->function(ccitem->arg, InvalidOid);
751  }
752 }
void ResetCatalogCaches(void)
Definition: catcache.c:754
void RelationCacheInvalidate(bool debug_discard)
Definition: relcache.c:2959
void InvalidateCatalogSnapshot(void)
Definition: snapmgr.c:422

References SYSCACHECALLBACK::arg, RELCACHECALLBACK::arg, SYSCACHECALLBACK::function, RELCACHECALLBACK::function, i, SYSCACHECALLBACK::id, InvalidateCatalogSnapshot(), InvalidOid, RelationCacheInvalidate(), relcache_callback_count, relcache_callback_list, ResetCatalogCaches(), syscache_callback_count, and syscache_callback_list.

Referenced by AcceptInvalidationMessages(), and InvalidateSystemCaches().

◆ LogLogicalInvalidations()

void LogLogicalInvalidations ( void  )

Definition at line 1792 of file inval.c.

1793 {
1794  xl_xact_invals xlrec;
1795  InvalidationMsgsGroup *group;
1796  int nmsgs;
1797 
1798  /* Quick exit if we haven't done anything with invalidation messages. */
1799  if (transInvalInfo == NULL)
1800  return;
1801 
1803  nmsgs = NumMessagesInGroup(group);
1804 
1805  if (nmsgs > 0)
1806  {
1807  /* prepare record */
1808  memset(&xlrec, 0, MinSizeOfXactInvals);
1809  xlrec.nmsgs = nmsgs;
1810 
1811  /* perform insertion */
1812  XLogBeginInsert();
1813  XLogRegisterData((char *) (&xlrec), MinSizeOfXactInvals);
1815  XLogRegisterData((char *) msgs,
1816  n * sizeof(SharedInvalidationMessage)));
1818  XLogRegisterData((char *) msgs,
1819  n * sizeof(SharedInvalidationMessage)));
1820  XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
1821  }
1822 }
#define NumMessagesInGroup(group)
Definition: inval.c:205
#define CatCacheMsgs
Definition: inval.c:169
#define ProcessMessageSubGroupMulti(group, subgroup, codeFragment)
Definition: inval.c:390
#define RelCacheMsgs
Definition: inval.c:170
int nmsgs
Definition: xact.h:304
#define MinSizeOfXactInvals
Definition: xact.h:307
#define XLOG_XACT_INVALIDATIONS
Definition: xact.h:175
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const char *data, uint32 len)
Definition: xloginsert.c:364
void XLogBeginInsert(void)
Definition: xloginsert.c:149

References CatCacheMsgs, InvalidationInfo::CurrentCmdInvalidMsgs, TransInvalidationInfo::ii, MinSizeOfXactInvals, xl_xact_invals::nmsgs, NumMessagesInGroup, ProcessMessageSubGroupMulti, RelCacheMsgs, transInvalInfo, XLOG_XACT_INVALIDATIONS, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by CommandEndInvalidationMessages(), and RecordTransactionCommit().

◆ PostPrepare_Inval()

void PostPrepare_Inval ( void  )

Definition at line 920 of file inval.c.

921 {
922  AtEOXact_Inval(false);
923 }
void AtEOXact_Inval(bool isCommit)
Definition: inval.c:1126

References AtEOXact_Inval().

Referenced by PrepareTransaction().

◆ PreInplace_Inval()

Variable Documentation

◆ debug_discard_caches

PGDLLIMPORT int debug_discard_caches
extern

Definition at line 258 of file inval.c.

Referenced by AcceptInvalidationMessages(), LookupOpclassInfo(), and RelationBuildDesc().