#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_type.h"
#include "commands/trigger.h"
#include "tcop/cmdtag.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/evtcache.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for evtcache.c:

Data Structures
struct	EventTriggerCacheEntry

Enumerations
enum	EventTriggerCacheStateType { ETCS_NEEDS_REBUILD , ETCS_REBUILD_STARTED , ETCS_VALID }

Functions
static void	BuildEventTriggerCache (void)

static void	InvalidateEventCacheCallback (Datum arg, int cacheid, uint32 hashvalue)

static Bitmapset *	DecodeTextArrayToBitmapset (Datum array)

List *	EventCacheLookup (EventTriggerEvent event)

Variables
static HTAB *	EventTriggerCache

static MemoryContext	EventTriggerCacheContext

static EventTriggerCacheStateType	EventTriggerCacheState = ETCS_NEEDS_REBUILD

Enumeration Type Documentation

◆ EventTriggerCacheStateType

enum EventTriggerCacheStateType

Enumerator
ETCS_NEEDS_REBUILD
ETCS_REBUILD_STARTED
ETCS_VALID

Definition at line 34 of file evtcache.c.

 {
     ETCS_NEEDS_REBUILD,
     ETCS_REBUILD_STARTED,
     ETCS_VALID,
 } EventTriggerCacheStateType;

Function Documentation

◆ BuildEventTriggerCache()

static void BuildEventTriggerCache ( void )

static

Definition at line 78 of file evtcache.c.

 {
     HASHCTL     ctl;
     HTAB       *cache;
     MemoryContext oldcontext;
     Relation    rel;
     Relation    irel;
     SysScanDesc scan;
  
     if (EventTriggerCacheContext != NULL)
     {
         /*
          * Free up any memory already allocated in EventTriggerCacheContext.
          * This can happen either because a previous rebuild failed, or
          * because an invalidation happened before the rebuild was complete.
          */
         MemoryContextReset(EventTriggerCacheContext);
     }
     else
     {
         /*
          * This is our first time attempting to build the cache, so we need to
          * set up the memory context and register a syscache callback to
          * capture future invalidation events.
          */
         if (CacheMemoryContext == NULL)
             CreateCacheMemoryContext();
         EventTriggerCacheContext =
             AllocSetContextCreate(CacheMemoryContext,
                                   "EventTriggerCache",
                                   ALLOCSET_DEFAULT_SIZES);
         CacheRegisterSyscacheCallback(EVENTTRIGGEROID,
                                       InvalidateEventCacheCallback,
                                       (Datum) 0);
     }
  
     /* Switch to correct memory context. */
     oldcontext = MemoryContextSwitchTo(EventTriggerCacheContext);
  
     /* Prevent the memory context from being nuked while we're rebuilding. */
     EventTriggerCacheState = ETCS_REBUILD_STARTED;
  
     /* Create new hash table. */
     ctl.keysize = sizeof(EventTriggerEvent);
     ctl.entrysize = sizeof(EventTriggerCacheEntry);
     ctl.hcxt = EventTriggerCacheContext;
     cache = hash_create("EventTriggerCacheHash", 32, &ctl,
                         HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
  
     /*
      * Prepare to scan pg_event_trigger in name order.
      */
     rel = relation_open(EventTriggerRelationId, AccessShareLock);
     irel = index_open(EventTriggerNameIndexId, AccessShareLock);
     scan = systable_beginscan_ordered(rel, irel, NULL, 0, NULL);
  
     /*
      * Build a cache item for each pg_event_trigger tuple, and append each one
      * to the appropriate cache entry.
      */
     for (;;)
     {
         HeapTuple   tup;
         Form_pg_event_trigger form;
         char       *evtevent;
         EventTriggerEvent event;
         EventTriggerCacheItem *item;
         Datum       evttags;
         bool        evttags_isnull;
         EventTriggerCacheEntry *entry;
         bool        found;
  
         /* Get next tuple. */
         tup = systable_getnext_ordered(scan, ForwardScanDirection);
         if (!HeapTupleIsValid(tup))
             break;
  
         /* Skip trigger if disabled. */
         form = (Form_pg_event_trigger) GETSTRUCT(tup);
         if (form->evtenabled == TRIGGER_DISABLED)
             continue;
  
         /* Decode event name. */
         evtevent = NameStr(form->evtevent);
         if (strcmp(evtevent, "ddl_command_start") == 0)
             event = EVT_DDLCommandStart;
         else if (strcmp(evtevent, "ddl_command_end") == 0)
             event = EVT_DDLCommandEnd;
         else if (strcmp(evtevent, "sql_drop") == 0)
             event = EVT_SQLDrop;
         else if (strcmp(evtevent, "table_rewrite") == 0)
             event = EVT_TableRewrite;
         else if (strcmp(evtevent, "login") == 0)
             event = EVT_Login;
         else
             continue;
  
         /* Allocate new cache item. */
         item = palloc0(sizeof(EventTriggerCacheItem));
         item->fnoid = form->evtfoid;
         item->enabled = form->evtenabled;
  
         /* Decode and sort tags array. */
         evttags = heap_getattr(tup, Anum_pg_event_trigger_evttags,
                                RelationGetDescr(rel), &evttags_isnull);
         if (!evttags_isnull)
             item->tagset = DecodeTextArrayToBitmapset(evttags);
  
         /* Add to cache entry. */
         entry = hash_search(cache, &event, HASH_ENTER, &found);
         if (found)
             entry->triggerlist = lappend(entry->triggerlist, item);
         else
             entry->triggerlist = list_make1(item);
     }
  
     /* Done with pg_event_trigger scan. */
     systable_endscan_ordered(scan);
     index_close(irel, AccessShareLock);
     relation_close(rel, AccessShareLock);
  
     /* Restore previous memory context. */
     MemoryContextSwitchTo(oldcontext);
  
     /* Install new cache. */
     EventTriggerCache = cache;
  
     /*
      * If the cache has been invalidated since we entered this routine, we
      * still use and return the cache we just finished constructing, to avoid
      * infinite loops, but we leave the cache marked stale so that we'll
      * rebuild it again on next access.  Otherwise, we mark the cache valid.
      */
     if (EventTriggerCacheState == ETCS_REBUILD_STARTED)
         EventTriggerCacheState = ETCS_VALID;
 }

References AccessShareLock, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CacheMemoryContext, CacheRegisterSyscacheCallback(), CreateCacheMemoryContext(), DecodeTextArrayToBitmapset(), EventTriggerCacheItem::enabled, HASHCTL::entrysize, ETCS_REBUILD_STARTED, ETCS_VALID, EventTriggerCache, EventTriggerCacheContext, EventTriggerCacheState, EVENTTRIGGEROID, EVT_DDLCommandEnd, EVT_DDLCommandStart, EVT_Login, EVT_SQLDrop, EVT_TableRewrite, EventTriggerCacheItem::fnoid, ForwardScanDirection, GETSTRUCT, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HASHCTL::hcxt, heap_getattr(), HeapTupleIsValid, index_close(), index_open(), InvalidateEventCacheCallback(), HASHCTL::keysize, lappend(), list_make1, MemoryContextReset(), MemoryContextSwitchTo(), NameStr, palloc0(), relation_close(), relation_open(), RelationGetDescr, systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), EventTriggerCacheItem::tagset, TRIGGER_DISABLED, and EventTriggerCacheEntry::triggerlist.

Referenced by EventCacheLookup().

◆ DecodeTextArrayToBitmapset()

static Bitmapset * DecodeTextArrayToBitmapset ( Datum array )

static

Definition at line 223 of file evtcache.c.

 {
     ArrayType  *arr = DatumGetArrayTypeP(array);
     Datum      *elems;
     Bitmapset  *bms;
     int         i;
     int         nelems;
  
     if (ARR_NDIM(arr) != 1 || ARR_HASNULL(arr) || ARR_ELEMTYPE(arr) != TEXTOID)
         elog(ERROR, "expected 1-D text array");
     deconstruct_array_builtin(arr, TEXTOID, &elems, NULL, &nelems);
  
     for (bms = NULL, i = 0; i < nelems; ++i)
     {
         char       *str = TextDatumGetCString(elems[i]);
  
         bms = bms_add_member(bms, GetCommandTagEnum(str));
         pfree(str);
     }
  
     pfree(elems);
  
     return bms;
 }

References ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, bms_add_member(), DatumGetArrayTypeP, deconstruct_array_builtin(), elog(), ERROR, GetCommandTagEnum(), i, pfree(), generate_unaccent_rules::str, and TextDatumGetCString.

Referenced by BuildEventTriggerCache().

◆ EventCacheLookup()

List* EventCacheLookup ( EventTriggerEvent event )

Definition at line 64 of file evtcache.c.

 {
     EventTriggerCacheEntry *entry;
  
     if (EventTriggerCacheState != ETCS_VALID)
         BuildEventTriggerCache();
     entry = hash_search(EventTriggerCache, &event, HASH_FIND, NULL);
     return entry != NULL ? entry->triggerlist : NIL;
 }

References BuildEventTriggerCache(), ETCS_VALID, EventTriggerCache, EventTriggerCacheState, HASH_FIND, hash_search(), NIL, and EventTriggerCacheEntry::triggerlist.

Referenced by EventTriggerCommonSetup(), and trackDroppedObjectsNeeded().

◆ InvalidateEventCacheCallback()

static void InvalidateEventCacheCallback	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

static

Definition at line 256 of file evtcache.c.

 {
     /*
      * If the cache isn't valid, then there might be a rebuild in progress, so
      * we can't immediately blow it away.  But it's advantageous to do this
      * when possible, so as to immediately free memory.
      */
     if (EventTriggerCacheState == ETCS_VALID)
     {
         MemoryContextReset(EventTriggerCacheContext);
         EventTriggerCache = NULL;
     }
  
     /* Mark cache for rebuild. */
     EventTriggerCacheState = ETCS_NEEDS_REBUILD;
 }