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	AtEOSubXact_Inval (bool isCommit)
void	PostPrepare_Inval (void)
void	CommandEndInvalidationMessages (void)
void	CacheInvalidateHeapTuple (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 806 of file inval.c.

{
    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 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(), InitializeSessionUserId(), LockDatabaseObject(), LockRelation(), LockRelationId(), LockRelationOid(), LockSharedObject(), LogicalRepApplyLoop(), pgstat_init_function_usage(), ProcessCatchupInterrupt(), RangeVarGetRelidExtended(), relation_openrv(), relation_openrv_extended(), RelationBuildPartitionDesc(), RemoveRelations(), and write_relcache_init_file().

AtEOSubXact_Inval()

void AtEOSubXact_Inval

(

bool

isCommit

)

Definition at line 1082 of file inval.c.

{
    int         my_level;
    TransInvalidationInfo *myInfo = transInvalInfo;
 
    /* Quick exit if no messages. */
    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->CurrentCmdInvalidMsgs,
                         &myInfo->parent->PriorCmdInvalidMsgs);
 
        /* Pending relcache inval becomes parent's problem too */
        if (myInfo->RelcacheInitFileInval)
            myInfo->parent->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(), TransInvalidationInfo::CurrentCmdInvalidMsgs, GetCurrentTransactionNestLevel(), LocalExecuteInvalidationMessage(), TransInvalidationInfo::my_level, TransInvalidationInfo::parent, pfree(), TransInvalidationInfo::PriorCmdInvalidMsgs, ProcessInvalidationMessages(), TransInvalidationInfo::RelcacheInitFileInval, SetGroupToFollow, and transInvalInfo.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_Inval()

void AtEOXact_Inval

(

bool

isCommit

)

Definition at line 1025 of file inval.c.

{
    /* Quick exit if no messages */
    if (transInvalInfo == NULL)
        return;
 
    /* Must be at top of stack */
    Assert(transInvalInfo->my_level == 1 && transInvalInfo->parent == 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->RelcacheInitFileInval)
            RelationCacheInitFilePreInvalidate();
 
        AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                   &transInvalInfo->CurrentCmdInvalidMsgs);
 
        ProcessInvalidationMessagesMulti(&transInvalInfo->PriorCmdInvalidMsgs,
                                         SendSharedInvalidMessages);
 
        if (transInvalInfo->RelcacheInitFileInval)
            RelationCacheInitFilePostInvalidate();
    }
    else
    {
        ProcessInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                                    LocalExecuteInvalidationMessage);
    }
 
    /* Need not free anything explicitly */
    transInvalInfo = NULL;
}

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

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

CacheInvalidateCatalog()

void CacheInvalidateCatalog

(

Oid

catalogId

)

Definition at line 1336 of file inval.c.

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

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

Referenced by finish_heap_swap().

CacheInvalidateHeapTuple()

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

Definition at line 1204 of file inval.c.

{
    Oid         tupleRelId;
    Oid         databaseId;
    Oid         relationId;
 
    /* Do nothing during bootstrap */
    if (IsBootstrapProcessingMode())
        return;
 
    /*
     * We only need to worry about invalidation for tuples that are in system
     * catalogs; user-relation tuples are never in catcaches and can't affect
     * the relcache either.
     */
    if (!IsCatalogRelation(relation))
        return;
 
    /*
     * IsCatalogRelation() will return true for TOAST tables of system
     * catalogs, but we don't care about those, either.
     */
    if (IsToastRelation(relation))
        return;
 
    /*
     * If we're not prepared to queue invalidation messages for this
     * subtransaction level, get ready now.
     */
    PrepareInvalidationState();
 
    /*
     * First let the catcache do its thing
     */
    tupleRelId = RelationGetRelid(relation);
    if (RelationInvalidatesSnapshotsOnly(tupleRelId))
    {
        databaseId = IsSharedRelation(tupleRelId) ? InvalidOid : MyDatabaseId;
        RegisterSnapshotInvalidation(databaseId, tupleRelId);
    }
    else
        PrepareToInvalidateCacheTuple(relation, tuple, newtuple,
                                      RegisterCatcacheInvalidation);
 
    /*
     * Now, is this tuple one of the primary definers of a relcache entry? See
     * comments in file header for deeper explanation.
     *
     * Note we ignore newtuple here; we assume an update cannot move a tuple
     * from being part of one relcache entry to being part of another.
     */
    if (tupleRelId == RelationRelationId)
    {
        Form_pg_class classtup = (Form_pg_class) GETSTRUCT(tuple);
 
        relationId = classtup->oid;
        if (classtup->relisshared)
            databaseId = InvalidOid;
        else
            databaseId = MyDatabaseId;
    }
    else if (tupleRelId == AttributeRelationId)
    {
        Form_pg_attribute atttup = (Form_pg_attribute) GETSTRUCT(tuple);
 
        relationId = atttup->attrelid;
 
        /*
         * KLUGE ALERT: we always send the relcache event with MyDatabaseId,
         * even if the rel in question is shared (which we can't easily tell).
         * This essentially means that only backends in this same database
         * will react to the relcache flush request.  This is in fact
         * appropriate, since only those backends could see our pg_attribute
         * change anyway.  It looks a bit ugly though.  (In practice, shared
         * relations can't have schema changes after bootstrap, so we should
         * never come here for a shared rel anyway.)
         */
        databaseId = MyDatabaseId;
    }
    else if (tupleRelId == IndexRelationId)
    {
        Form_pg_index indextup = (Form_pg_index) GETSTRUCT(tuple);
 
        /*
         * When a pg_index row is updated, we should send out a relcache inval
         * for the index relation.  As above, we don't know the shared status
         * of the index, but in practice it doesn't matter since indexes of
         * shared catalogs can't have such updates.
         */
        relationId = indextup->indexrelid;
        databaseId = MyDatabaseId;
    }
    else if (tupleRelId == ConstraintRelationId)
    {
        Form_pg_constraint constrtup = (Form_pg_constraint) GETSTRUCT(tuple);
 
        /*
         * Foreign keys are part of relcache entries, too, so send out an
         * inval for the table that the FK applies to.
         */
        if (constrtup->contype == CONSTRAINT_FOREIGN &&
            OidIsValid(constrtup->conrelid))
        {
            relationId = constrtup->conrelid;
            databaseId = MyDatabaseId;
        }
        else
            return;
    }
    else
        return;
 
    /*
     * Yes.  We need to register a relcache invalidation event.
     */
    RegisterRelcacheInvalidation(databaseId, relationId);
}

References GETSTRUCT, InvalidOid, IsBootstrapProcessingMode, IsCatalogRelation(), IsSharedRelation(), IsToastRelation(), MyDatabaseId, OidIsValid, PrepareInvalidationState(), PrepareToInvalidateCacheTuple(), RegisterCatcacheInvalidation(), RegisterRelcacheInvalidation(), RegisterSnapshotInvalidation(), RelationGetRelid, and RelationInvalidatesSnapshotsOnly().

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

CacheInvalidateRelcache()

void CacheInvalidateRelcache

(

Relation

relation

)

Definition at line 1360 of file inval.c.

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

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

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

CacheInvalidateRelcacheAll()

void CacheInvalidateRelcacheAll

(

void

)

Definition at line 1384 of file inval.c.

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

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

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

CacheInvalidateRelcacheByRelid()

void CacheInvalidateRelcacheByRelid

(

Oid

relid

)

Definition at line 1419 of file inval.c.

{
    HeapTuple   tup;
 
    PrepareInvalidationState();
 
    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, HeapTupleIsValid, ObjectIdGetDatum(), PrepareInvalidationState(), 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 1396 of file inval.c.

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

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

CacheInvalidateSmgr()

void CacheInvalidateSmgr

(

RelFileLocatorBackend

rlocator

)

Definition at line 1459 of file inval.c.

{
    SharedInvalidationMessage msg;
 
    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, 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 1558 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().

CacheRegisterSyscacheCallback()

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

Definition at line 1516 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, 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 1577 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 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 1170 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->CurrentCmdInvalidMsgs,
                                LocalExecuteInvalidationMessage);
 
    /* WAL Log per-command invalidation messages for wal_level=logical */
    if (XLogLogicalInfoActive())
        LogLogicalInvalidations();
 
    AppendInvalidationMessages(&transInvalInfo->PriorCmdInvalidMsgs,
                               &transInvalInfo->CurrentCmdInvalidMsgs);
}

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

Referenced by AtCCI_LocalCache(), and AtEOSubXact_Inval().

InvalidateSystemCaches()

void InvalidateSystemCaches

(

void

)

Definition at line 792 of file inval.c.

{
    InvalidateSystemCachesExtended(false);
}

References InvalidateSystemCachesExtended().

Referenced by AcceptInvalidationMessages(), LogicalReplicationSlotHasPendingWal(), LogicalSlotAdvanceAndCheckSnapState(), ParallelWorkerMain(), and pg_logical_slot_get_changes_guts().

InvalidateSystemCachesExtended()

void InvalidateSystemCachesExtended

(

bool

debug_discard

)

Definition at line 674 of file inval.c.

{
    int         i;
 
    InvalidateCatalogSnapshot();
    ResetCatalogCaches();
    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);
    }
}

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 1604 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->CurrentCmdInvalidMsgs;
    nmsgs = NumMessagesInGroup(group);
 
    if (nmsgs > 0)
    {
        /* prepare record */
        memset(&xlrec, 0, MinSizeOfXactInvals);
        xlrec.nmsgs = nmsgs;
 
        /* perform insertion */
        XLogBeginInsert();
        XLogRegisterData((char *) (&xlrec), MinSizeOfXactInvals);
        ProcessMessageSubGroupMulti(group, CatCacheMsgs,
                                    XLogRegisterData((char *) msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        ProcessMessageSubGroupMulti(group, RelCacheMsgs,
                                    XLogRegisterData((char *) msgs,
                                                     n * sizeof(SharedInvalidationMessage)));
        XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
    }
}

References CatCacheMsgs, TransInvalidationInfo::CurrentCmdInvalidMsgs, 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 863 of file inval.c.

{
    AtEOXact_Inval(false);
}

References AtEOXact_Inval().

Referenced by PrepareTransaction().

Variable Documentation

debug_discard_caches

PGDLLIMPORT int debug_discard_caches

extern

Definition at line 240 of file inval.c.

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