inval.h File Reference

#include "access/htup.h"
#include "catalog/syscache_ids.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.

Macros
#define	MIN_DEBUG_DISCARD_CACHES   0
#define	DEFAULT_DEBUG_DISCARD_CACHES   0
#define	MAX_DEBUG_DISCARD_CACHES   0

Typedefs
typedef void(*	SyscacheCallbackFunction) (Datum arg, SysCacheIdentifier cacheid, uint32 hashvalue)
typedef void(*	RelcacheCallbackFunction) (Datum arg, Oid relid)
typedef void(*	RelSyncCallbackFunction) (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 key_equivalent_tuple)
void	CacheInvalidateCatalog (Oid catalogId)
void	CacheInvalidateRelcache (Relation relation)
void	CacheInvalidateRelcacheAll (void)
void	CacheInvalidateRelcacheByTuple (HeapTuple classTuple)
void	CacheInvalidateRelcacheByRelid (Oid relid)
void	CacheInvalidateRelSync (Oid relid)
void	CacheInvalidateRelSyncAll (void)
void	CacheInvalidateSmgr (RelFileLocatorBackend rlocator)
void	CacheInvalidateRelmap (Oid databaseId)
void	CacheRegisterSyscacheCallback (SysCacheIdentifier cacheid, SyscacheCallbackFunction func, Datum arg)
void	CacheRegisterRelcacheCallback (RelcacheCallbackFunction func, Datum arg)
void	CacheRegisterRelSyncCallback (RelSyncCallbackFunction func, Datum arg)
void	CallSyscacheCallbacks (SysCacheIdentifier cacheid, uint32 hashvalue)
void	CallRelSyncCallbacks (Oid relid)
void	InvalidateSystemCaches (void)
void	InvalidateSystemCachesExtended (bool debug_discard)
void	LogLogicalInvalidations (void)

Variables
PGDLLIMPORT int	debug_discard_caches

Macro Definition Documentation

DEFAULT_DEBUG_DISCARD_CACHES

#define DEFAULT_DEBUG_DISCARD_CACHES   0

Definition at line 37 of file inval.h.

MAX_DEBUG_DISCARD_CACHES

#define MAX_DEBUG_DISCARD_CACHES   0

Definition at line 38 of file inval.h.

MIN_DEBUG_DISCARD_CACHES

#define MIN_DEBUG_DISCARD_CACHES   0

Definition at line 24 of file inval.h.

Typedef Documentation

RelcacheCallbackFunction

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

Definition at line 44 of file inval.h.

RelSyncCallbackFunction

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

Definition at line 45 of file inval.h.

SyscacheCallbackFunction

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

Definition at line 42 of file inval.h.

Function Documentation

AcceptInvalidationMessages()

void AcceptInvalidationMessages ( void  )

extern

Definition at line 930 of file inval.c.

{
#ifdef USE_ASSERT_CHECKING
    /* message handlers shall access catalogs only during transactions */
    if (IsTransactionState())
        AssertCouldGetRelation();
#endif
 
    ReceiveSharedInvalidMessages(LocalExecuteInvalidationMessage,
                                 InvalidateSystemCaches);
 
    /*----------
     * Test code to force cache flushes anytime a flush could happen.
     *
     * This helps detect intermittent faults caused by code that reads a cache
     * entry and then performs an action that could invalidate the entry, but
     * rarely actually does so.  This can spot issues that would otherwise
     * only arise with badly timed concurrent DDL, for example.
     *
     * The default debug_discard_caches = 0 does no forced cache flushes.
     *
     * If used with CLOBBER_FREED_MEMORY,
     * debug_discard_caches = 1 (formerly known as CLOBBER_CACHE_ALWAYS)
     * provides a fairly thorough test that the system contains no cache-flush
     * hazards.  However, it also makes the system unbelievably slow --- the
     * regression tests take about 100 times longer than normal.
     *
     * If you're a glutton for punishment, try
     * debug_discard_caches = 3 (formerly known as CLOBBER_CACHE_RECURSIVELY).
     * This slows things by at least a factor of 10000, so I wouldn't suggest
     * trying to run the entire regression tests that way.  It's useful to try
     * a few simple tests, to make sure that cache reload isn't subject to
     * internal cache-flush hazards, but after you've done a few thousand
     * recursive reloads it's unlikely you'll learn more.
     *----------
     */
#ifdef DISCARD_CACHES_ENABLED
    {
        static int  recursion_depth = 0;
 
        if (recursion_depth < debug_discard_caches)
        {
            recursion_depth++;
            InvalidateSystemCachesExtended(true);
            recursion_depth--;
        }
    }
#endif
}

References AssertCouldGetRelation(), debug_discard_caches, InvalidateSystemCaches(), InvalidateSystemCachesExtended(), IsTransactionState(), 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 )

extern

Definition at line 1307 of file inval.c.

{
    int         my_level;
    TransInvalidationInfo *myInfo;
 
    /*
     * Successful inplace update must clear this, but we clear it on abort.
     * Inplace updates allocate this in CurrentMemoryContext, which has
     * lifespan <= subtransaction lifespan.  Hence, don't free it explicitly.
     */
    if (isCommit)
        Assert(inplaceInvalInfo == NULL);
    else
        inplaceInvalInfo = NULL;
 
    /* Quick exit if no transactional messages. */
    myInfo = transInvalInfo;
    if (myInfo == NULL)
        return;
 
    /* Also bail out quickly if messages are not for this level. */
    my_level = GetCurrentTransactionNestLevel();
    if (myInfo->my_level != my_level)
    {
        Assert(myInfo->my_level < my_level);
        return;
    }
 
    if (isCommit)
    {
        /* If CurrentCmdInvalidMsgs still has anything, fix it */
        CommandEndInvalidationMessages();
 
        /*
         * We create invalidation stack entries lazily, so the parent might
         * not have one.  Instead of creating one, moving all the data over,
         * and then freeing our own, we can just adjust the level of our own
         * entry.
         */
        if (myInfo->parent == NULL || myInfo->parent->my_level < my_level - 1)
        {
            myInfo->my_level--;
            return;
        }
 
        /*
         * Pass up my inval messages to parent.  Notice that we stick them in
         * PriorCmdInvalidMsgs, not CurrentCmdInvalidMsgs, since they've
         * already been locally processed.  (This would trigger the Assert in
         * AppendInvalidationMessageSubGroup if the parent's
         * CurrentCmdInvalidMsgs isn't empty; but we already checked that in
         * PrepareInvalidationState.)
         */
        AppendInvalidationMessages(&myInfo->parent->PriorCmdInvalidMsgs,
                                   &myInfo->PriorCmdInvalidMsgs);
 
        /* Must readjust parent's CurrentCmdInvalidMsgs indexes now */
        SetGroupToFollow(&myInfo->parent->ii.CurrentCmdInvalidMsgs,
                         &myInfo->parent->PriorCmdInvalidMsgs);
 
        /* Pending relcache inval becomes parent's problem too */
        if (myInfo->ii.RelcacheInitFileInval)
            myInfo->parent->ii.RelcacheInitFileInval = true;
 
        /* Pop the transaction state stack */
        transInvalInfo = myInfo->parent;
 
        /* Need not free anything else explicitly */
        pfree(myInfo);
    }
    else
    {
        ProcessInvalidationMessages(&myInfo->PriorCmdInvalidMsgs,
                                    LocalExecuteInvalidationMessage);
 
        /* Pop the transaction state stack */
        transInvalInfo = myInfo->parent;
 
        /* Need not free anything else explicitly */
        pfree(myInfo);
    }
}

References AppendInvalidationMessages(), Assert, CommandEndInvalidationMessages(), fb(), GetCurrentTransactionNestLevel(), inplaceInvalInfo, LocalExecuteInvalidationMessage(), TransInvalidationInfo::parent, pfree(), ProcessInvalidationMessages(), SetGroupToFollow, and transInvalInfo.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_Inval()

void AtEOXact_Inval ( bool  isCommit )

extern

Definition at line 1196 of file inval.c.

{
    inplaceInvalInfo = NULL;
 
    /* Quick exit if no transactional messages */
    if (transInvalInfo == NULL)
        return;
 
    /* Must be at top of stack */
    Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == NULL);
 
    INJECTION_POINT("transaction-end-process-inval", NULL);
 
    if (isCommit)
    {
        /*
         * Relcache init file invalidation requires processing both before and
         * after we send the SI messages.  However, we need not do anything
         * unless we committed.
         */
        if (transInvalInfo->ii.RelcacheInitFileInval)
            RelationCacheInitFilePreInvalidate();
 
        AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                   &transInvalInfo->ii.CurrentCmdInvalidMsgs);
 
        ProcessInvalidationMessagesMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                         SendSharedInvalidMessages);
 
        if (transInvalInfo->ii.RelcacheInitFileInval)
            RelationCacheInitFilePostInvalidate();
    }
    else
    {
        ProcessInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                    LocalExecuteInvalidationMessage);
    }
 
    /* Need not free anything explicitly */
    transInvalInfo = NULL;
}

References AppendInvalidationMessages(), Assert, InvalidationInfo::CurrentCmdInvalidMsgs, fb(), TransInvalidationInfo::ii, INJECTION_POINT, 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()

void AtInplace_Inval ( void  )

extern

Definition at line 1260 of file inval.c.

{
    Assert(CritSectionCount > 0);
 
    if (inplaceInvalInfo == NULL)
        return;
 
    ProcessInvalidationMessagesMulti(&inplaceInvalInfo->CurrentCmdInvalidMsgs,
                                     SendSharedInvalidMessages);
 
    if (inplaceInvalInfo->RelcacheInitFileInval)
        RelationCacheInitFilePostInvalidate();
 
    inplaceInvalInfo = NULL;
}

References Assert, CritSectionCount, InvalidationInfo::CurrentCmdInvalidMsgs, fb(), inplaceInvalInfo, ProcessInvalidationMessagesMulti(), RelationCacheInitFilePostInvalidate(), InvalidationInfo::RelcacheInitFileInval, and SendSharedInvalidMessages().

Referenced by heap_inplace_update_and_unlock().

CacheInvalidateCatalog()

void CacheInvalidateCatalog ( Oid  catalogId )

extern

Definition at line 1609 of file inval.c.

{
    Oid         databaseId;
 
    if (IsSharedRelation(catalogId))
        databaseId = InvalidOid;
    else
        databaseId = MyDatabaseId;
 
    RegisterCatalogInvalidation(PrepareInvalidationState(),
                                databaseId, catalogId);
}

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

Referenced by finish_heap_swap().

CacheInvalidateHeapTuple()

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

extern

Definition at line 1568 of file inval.c.

{
    CacheInvalidateHeapTupleCommon(relation, tuple, newtuple,
                                   PrepareInvalidationState);
}

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  key_equivalent_tuple  )

extern

Definition at line 1590 of file inval.c.

{
    CacheInvalidateHeapTupleCommon(relation, key_equivalent_tuple, NULL,
                                   PrepareInplaceInvalidationState);
}

References CacheInvalidateHeapTupleCommon(), fb(), and PrepareInplaceInvalidationState().

Referenced by heap_inplace_lock().

CacheInvalidateRelcache()

void CacheInvalidateRelcache ( Relation  relation )

extern

Definition at line 1632 of file inval.c.

{
    Oid         databaseId;
    Oid         relationId;
 
    relationId = RelationGetRelid(relation);
    if (relation->rd_rel->relisshared)
        databaseId = InvalidOid;
    else
        databaseId = MyDatabaseId;
 
    RegisterRelcacheInvalidation(PrepareInvalidationState(),
                                 databaseId, relationId);
}

References fb(), InvalidOid, MyDatabaseId, PrepareInvalidationState(), RelationData::rd_rel, RegisterRelcacheInvalidation(), and RelationGetRelid.

Referenced by AlterPolicy(), ATExecDetachPartition(), ATExecGenericOptions(), CreatePolicy(), CreateStatistics(), DetachPartitionFinalize(), EnableDisableRule(), EnableDisableTrigger(), index_concurrently_set_dead(), index_constraint_create(), index_create(), index_drop(), QueueCheckConstraintValidation(), QueueNNConstraintValidation(), reindex_index(), relation_mark_replica_identity(), RelationSetNewRelfilenumber(), RemovePolicyById(), RemoveRewriteRuleById(), RemoveTriggerById(), rename_constraint_internal(), rename_policy(), RenameRewriteRule(), renametrig_internal(), set_attnotnull(), SetRelationNumChecks(), StorePartitionBound(), and StorePartitionKey().

CacheInvalidateRelcacheAll()

void CacheInvalidateRelcacheAll ( void  )

extern

Definition at line 1655 of file inval.c.

{
    RegisterRelcacheInvalidation(PrepareInvalidationState(),
                                 InvalidOid, InvalidOid);
}

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

Referenced by AlterPublicationAllFlags(), AlterPublicationOptions(), CreatePublication(), InvalidatePublicationRels(), and RemovePublicationById().

CacheInvalidateRelcacheByRelid()

void CacheInvalidateRelcacheByRelid ( Oid  relid )

extern

Definition at line 1688 of file inval.c.

{
    HeapTuple   tup;
 
    tup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    CacheInvalidateRelcacheByTuple(tup);
    ReleaseSysCache(tup);
}

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

Referenced by AlterConstrUpdateConstraintEntry(), AlterPropGraph(), ATExecAlterConstraintInternal(), ATExecAttachPartition(), DefineIndex(), DetachPartitionFinalize(), heap_drop_with_catalog(), InvalidatePublicationRels(), ReindexRelationConcurrently(), RemoveStatisticsById(), and StorePartitionBound().

CacheInvalidateRelcacheByTuple()

void CacheInvalidateRelcacheByTuple ( HeapTuple  classTuple )

extern

Definition at line 1666 of file inval.c.

{
    Form_pg_class classtup = (Form_pg_class) GETSTRUCT(classTuple);
    Oid         databaseId;
    Oid         relationId;
 
    relationId = classtup->oid;
    if (classtup->relisshared)
        databaseId = InvalidOid;
    else
        databaseId = MyDatabaseId;
    RegisterRelcacheInvalidation(PrepareInvalidationState(),
                                 databaseId, relationId);
}

References fb(), 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 )

extern

Definition at line 1786 of file inval.c.

{
    SharedInvalidationMessage msg;
 
    msg.rm.id = SHAREDINVALRELMAP_ID;
    msg.rm.dbId = databaseId;
    /* check AddCatcacheInvalidationMessage() for an explanation */
    VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
    SendSharedInvalidMessages(&msg, 1);
}

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

Referenced by write_relmap_file().

CacheInvalidateRelSync()

void CacheInvalidateRelSync ( Oid  relid )

extern

Definition at line 1709 of file inval.c.

{
    RegisterRelsyncInvalidation(PrepareInvalidationState(),
                                MyDatabaseId, relid);
}

References MyDatabaseId, PrepareInvalidationState(), and RegisterRelsyncInvalidation().

Referenced by CacheInvalidateRelSyncAll(), and InvalidatePubRelSyncCache().

CacheInvalidateRelSyncAll()

void CacheInvalidateRelSyncAll ( void  )

extern

Definition at line 1721 of file inval.c.

{
    CacheInvalidateRelSync(InvalidOid);
}

References CacheInvalidateRelSync(), and InvalidOid.

Referenced by InvalidatePubRelSyncCache().

CacheInvalidateSmgr()

void CacheInvalidateSmgr ( RelFileLocatorBackend  rlocator )

extern

Definition at line 1752 of file inval.c.

{
    SharedInvalidationMessage msg;
 
    /* verify optimization stated above stays valid */
    StaticAssertDecl(MAX_BACKENDS_BITS <= 23,
                     "MAX_BACKENDS_BITS is too big for inval.c");
 
    msg.sm.id = SHAREDINVALSMGR_ID;
    msg.sm.backend_hi = rlocator.backend >> 16;
    msg.sm.backend_lo = rlocator.backend & 0xffff;
    msg.sm.rlocator = rlocator.locator;
    /* check AddCatcacheInvalidationMessage() for an explanation */
    VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg));
 
    SendSharedInvalidMessages(&msg, 1);
}

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

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

CacheRegisterRelcacheCallback()

void CacheRegisterRelcacheCallback ( RelcacheCallbackFunction  func, Datum  arg  )

extern

Definition at line 1855 of file inval.c.

{
    if (relcache_callback_count >= MAX_RELCACHE_CALLBACKS)
        elog(FATAL, "out of relcache_callback_list slots");
 
    relcache_callback_list[relcache_callback_count].function = func;
    relcache_callback_list[relcache_callback_count].arg = arg;
 
    ++relcache_callback_count;
}

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().

CacheRegisterRelSyncCallback()

void CacheRegisterRelSyncCallback ( RelSyncCallbackFunction  func, Datum  arg  )

extern

Definition at line 1876 of file inval.c.

{
    if (relsync_callback_count >= MAX_RELSYNC_CALLBACKS)
        elog(FATAL, "out of relsync_callback_list slots");
 
    relsync_callback_list[relsync_callback_count].function = func;
    relsync_callback_list[relsync_callback_count].arg = arg;
 
    ++relsync_callback_count;
}

References RELSYNCCALLBACK::arg, arg, elog, FATAL, RELSYNCCALLBACK::function, MAX_RELSYNC_CALLBACKS, relsync_callback_count, and relsync_callback_list.

Referenced by pgoutput_startup().

CacheRegisterSyscacheCallback()

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

extern

Definition at line 1813 of file inval.c.

{
    if (cacheid < 0 || cacheid >= SysCacheSize)
        elog(FATAL, "invalid cache ID: %d", cacheid);
    if (syscache_callback_count >= MAX_SYSCACHE_CALLBACKS)
        elog(FATAL, "out of syscache_callback_list slots");
 
    if (syscache_callback_links[cacheid] == 0)
    {
        /* first callback for this cache */
        syscache_callback_links[cacheid] = syscache_callback_count + 1;
    }
    else
    {
        /* add to end of chain, so that older callbacks are called first */
        int         i = syscache_callback_links[cacheid] - 1;
 
        while (syscache_callback_list[i].link > 0)
            i = syscache_callback_list[i].link - 1;
        syscache_callback_list[i].link = syscache_callback_count + 1;
    }
 
    syscache_callback_list[syscache_callback_count].id = cacheid;
    syscache_callback_list[syscache_callback_count].link = 0;
    syscache_callback_list[syscache_callback_count].function = func;
    syscache_callback_list[syscache_callback_count].arg = arg;
 
    ++syscache_callback_count;
}

References SYSCACHECALLBACK::arg, arg, elog, FATAL, fb(), 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(), get_function_sibling_type(), 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().

CallRelSyncCallbacks()

void CallRelSyncCallbacks ( Oid  relid )

extern

Definition at line 1917 of file inval.c.

{
    for (int i = 0; i < relsync_callback_count; i++)
    {
        struct RELSYNCCALLBACK *ccitem = relsync_callback_list + i;
 
        ccitem->function(ccitem->arg, relid);
    }
}

References fb(), RELSYNCCALLBACK::function, i, relsync_callback_count, and relsync_callback_list.

Referenced by LocalExecuteInvalidationMessage().

CallSyscacheCallbacks()

void CallSyscacheCallbacks ( SysCacheIdentifier  cacheid, uint32  hashvalue  )

extern

Definition at line 1895 of file inval.c.

{
    int         i;
 
    if (cacheid < 0 || cacheid >= SysCacheSize)
        elog(ERROR, "invalid cache ID: %d", cacheid);
 
    i = syscache_callback_links[cacheid] - 1;
    while (i >= 0)
    {
        struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
 
        Assert(ccitem->id == cacheid);
        ccitem->function(ccitem->arg, cacheid, hashvalue);
        i = ccitem->link - 1;
    }
}

References Assert, elog, ERROR, fb(), i, syscache_callback_links, and syscache_callback_list.

Referenced by CatalogCacheFlushCatalog(), and LocalExecuteInvalidationMessage().

CommandEndInvalidationMessages()

void CommandEndInvalidationMessages ( void  )

extern

Definition at line 1406 of file inval.c.

{
    /*
     * You might think this shouldn't be called outside any transaction, but
     * bootstrap does it, and also ABORT issued when not in a transaction. So
     * just quietly return if no state to work on.
     */
    if (transInvalInfo == NULL)
        return;
 
    ProcessInvalidationMessages(&transInvalInfo->ii.CurrentCmdInvalidMsgs,
                                LocalExecuteInvalidationMessage);
 
    /* WAL Log per-command invalidation messages for logical decoding */
    if (XLogLogicalInfoActive())
        LogLogicalInvalidations();
 
    AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                               &transInvalInfo->ii.CurrentCmdInvalidMsgs);
}

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

Referenced by AtCCI_LocalCache(), and AtEOSubXact_Inval().

ForgetInplace_Inval()

void ForgetInplace_Inval ( void  )

extern

Definition at line 1283 of file inval.c.

{
    inplaceInvalInfo = NULL;
}

References fb(), and inplaceInvalInfo.

Referenced by heap_inplace_lock(), and heap_inplace_unlock().

InvalidateSystemCaches()

void InvalidateSystemCaches ( void  )

extern

Definition at line 916 of file inval.c.

{
    InvalidateSystemCachesExtended(false);
}

References InvalidateSystemCachesExtended().

Referenced by AcceptInvalidationMessages(), LogicalReplicationSlotCheckPendingWal(), LogicalSlotAdvanceAndCheckSnapState(), ParallelWorkerMain(), pg_logical_slot_get_changes_guts(), and ReorderBufferProcessTXN().

InvalidateSystemCachesExtended()

void InvalidateSystemCachesExtended ( bool  debug_discard )

extern

Definition at line 785 of file inval.c.

{
    int         i;
 
    InvalidateCatalogSnapshot();
    ResetCatalogCachesExt(debug_discard);
    RelationCacheInvalidate(debug_discard); /* gets smgr and relmap too */
 
    for (i = 0; i < syscache_callback_count; i++)
    {
        struct SYSCACHECALLBACK *ccitem = syscache_callback_list + i;
 
        ccitem->function(ccitem->arg, ccitem->id, 0);
    }
 
    for (i = 0; i < relcache_callback_count; i++)
    {
        struct RELCACHECALLBACK *ccitem = relcache_callback_list + i;
 
        ccitem->function(ccitem->arg, InvalidOid);
    }
 
    for (i = 0; i < relsync_callback_count; i++)
    {
        struct RELSYNCCALLBACK *ccitem = relsync_callback_list + i;
 
        ccitem->function(ccitem->arg, InvalidOid);
    }
}

References fb(), SYSCACHECALLBACK::function, RELCACHECALLBACK::function, RELSYNCCALLBACK::function, i, InvalidateCatalogSnapshot(), InvalidOid, RelationCacheInvalidate(), relcache_callback_count, relcache_callback_list, relsync_callback_count, relsync_callback_list, ResetCatalogCachesExt(), syscache_callback_count, and syscache_callback_list.

Referenced by AcceptInvalidationMessages(), and InvalidateSystemCaches().

LogLogicalInvalidations()

void LogLogicalInvalidations ( void  )

extern

Definition at line 1936 of file inval.c.

{
    xl_xact_invals xlrec;
    InvalidationMsgsGroup *group;
    int         nmsgs;
 
    /* Quick exit if we haven't done anything with invalidation messages. */
    if (transInvalInfo == NULL)
        return;
 
    group = &transInvalInfo->ii.CurrentCmdInvalidMsgs;
    nmsgs = NumMessagesInGroup(group);
 
    if (nmsgs > 0)
    {
        /* prepare record */
        memset(&xlrec, 0, MinSizeOfXactInvals);
        xlrec.nmsgs = nmsgs;
 
        /* perform insertion */
        XLogBeginInsert();
        XLogRegisterData(&xlrec, MinSizeOfXactInvals);
        ProcessMessageSubGroupMulti(group, CatCacheMsgs,
                                    XLogRegisterData(msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        ProcessMessageSubGroupMulti(group, RelCacheMsgs,
                                    XLogRegisterData(msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
    }
}

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

Referenced by CommandEndInvalidationMessages(), and RecordTransactionCommit().

PostPrepare_Inval()

void PostPrepare_Inval ( void  )

extern

Definition at line 993 of file inval.c.

{
    AtEOXact_Inval(false);
}

References AtEOXact_Inval().

Referenced by PrepareTransaction().

PreInplace_Inval()

void PreInplace_Inval ( void  )

extern

Definition at line 1247 of file inval.c.

{
    Assert(CritSectionCount == 0);
 
    if (inplaceInvalInfo && inplaceInvalInfo->RelcacheInitFileInval)
        RelationCacheInitFilePreInvalidate();
}

References Assert, CritSectionCount, inplaceInvalInfo, RelationCacheInitFilePreInvalidate(), and InvalidationInfo::RelcacheInitFileInval.

Referenced by heap_inplace_update_and_unlock().

Variable Documentation

debug_discard_caches

PGDLLIMPORT int debug_discard_caches

extern

Definition at line 260 of file inval.c.

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