LCOV - code coverage report
Current view: top level - src/backend/utils/cache - evtcache.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 71 74 95.9 %
Date: 2021-01-26 03:06:49 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * evtcache.c
       4             :  *    Special-purpose cache for event trigger data.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/cache/evtcache.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "access/genam.h"
      17             : #include "access/htup_details.h"
      18             : #include "access/relation.h"
      19             : #include "catalog/pg_event_trigger.h"
      20             : #include "catalog/pg_type.h"
      21             : #include "commands/trigger.h"
      22             : #include "tcop/cmdtag.h"
      23             : #include "utils/array.h"
      24             : #include "utils/builtins.h"
      25             : #include "utils/catcache.h"
      26             : #include "utils/evtcache.h"
      27             : #include "utils/hsearch.h"
      28             : #include "utils/inval.h"
      29             : #include "utils/memutils.h"
      30             : #include "utils/rel.h"
      31             : #include "utils/snapmgr.h"
      32             : #include "utils/syscache.h"
      33             : 
      34             : typedef enum
      35             : {
      36             :     ETCS_NEEDS_REBUILD,
      37             :     ETCS_REBUILD_STARTED,
      38             :     ETCS_VALID
      39             : } EventTriggerCacheStateType;
      40             : 
      41             : typedef struct
      42             : {
      43             :     EventTriggerEvent event;
      44             :     List       *triggerlist;
      45             : } EventTriggerCacheEntry;
      46             : 
      47             : static HTAB *EventTriggerCache;
      48             : static MemoryContext EventTriggerCacheContext;
      49             : static EventTriggerCacheStateType EventTriggerCacheState = ETCS_NEEDS_REBUILD;
      50             : 
      51             : static void BuildEventTriggerCache(void);
      52             : static void InvalidateEventCacheCallback(Datum arg,
      53             :                                          int cacheid, uint32 hashvalue);
      54             : static Bitmapset *DecodeTextArrayToBitmapset(Datum array);
      55             : 
      56             : /*
      57             :  * Search the event cache by trigger event.
      58             :  *
      59             :  * Note that the caller had better copy any data it wants to keep around
      60             :  * across any operation that might touch a system catalog into some other
      61             :  * memory context, since a cache reset could blow the return value away.
      62             :  */
      63             : List *
      64      971936 : EventCacheLookup(EventTriggerEvent event)
      65             : {
      66             :     EventTriggerCacheEntry *entry;
      67             : 
      68      971936 :     if (EventTriggerCacheState != ETCS_VALID)
      69        3576 :         BuildEventTriggerCache();
      70      971936 :     entry = hash_search(EventTriggerCache, &event, HASH_FIND, NULL);
      71      971936 :     return entry != NULL ? entry->triggerlist : NIL;
      72             : }
      73             : 
      74             : /*
      75             :  * Rebuild the event trigger cache.
      76             :  */
      77             : static void
      78        3576 : BuildEventTriggerCache(void)
      79             : {
      80             :     HASHCTL     ctl;
      81             :     HTAB       *cache;
      82             :     MemoryContext oldcontext;
      83             :     Relation    rel;
      84             :     Relation    irel;
      85             :     SysScanDesc scan;
      86             : 
      87        3576 :     if (EventTriggerCacheContext != NULL)
      88             :     {
      89             :         /*
      90             :          * Free up any memory already allocated in EventTriggerCacheContext.
      91             :          * This can happen either because a previous rebuild failed, or
      92             :          * because an invalidation happened before the rebuild was complete.
      93             :          */
      94         478 :         MemoryContextResetAndDeleteChildren(EventTriggerCacheContext);
      95             :     }
      96             :     else
      97             :     {
      98             :         /*
      99             :          * This is our first time attempting to build the cache, so we need to
     100             :          * set up the memory context and register a syscache callback to
     101             :          * capture future invalidation events.
     102             :          */
     103        3098 :         if (CacheMemoryContext == NULL)
     104           0 :             CreateCacheMemoryContext();
     105        3098 :         EventTriggerCacheContext =
     106        3098 :             AllocSetContextCreate(CacheMemoryContext,
     107             :                                   "EventTriggerCache",
     108             :                                   ALLOCSET_DEFAULT_SIZES);
     109        3098 :         CacheRegisterSyscacheCallback(EVENTTRIGGEROID,
     110             :                                       InvalidateEventCacheCallback,
     111             :                                       (Datum) 0);
     112             :     }
     113             : 
     114             :     /* Switch to correct memory context. */
     115        3576 :     oldcontext = MemoryContextSwitchTo(EventTriggerCacheContext);
     116             : 
     117             :     /* Prevent the memory context from being nuked while we're rebuilding. */
     118        3576 :     EventTriggerCacheState = ETCS_REBUILD_STARTED;
     119             : 
     120             :     /* Create new hash table. */
     121        3576 :     ctl.keysize = sizeof(EventTriggerEvent);
     122        3576 :     ctl.entrysize = sizeof(EventTriggerCacheEntry);
     123        3576 :     ctl.hcxt = EventTriggerCacheContext;
     124        3576 :     cache = hash_create("Event Trigger Cache", 32, &ctl,
     125             :                         HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
     126             : 
     127             :     /*
     128             :      * Prepare to scan pg_event_trigger in name order.
     129             :      */
     130        3576 :     rel = relation_open(EventTriggerRelationId, AccessShareLock);
     131        3576 :     irel = index_open(EventTriggerNameIndexId, AccessShareLock);
     132        3576 :     scan = systable_beginscan_ordered(rel, irel, NULL, 0, NULL);
     133             : 
     134             :     /*
     135             :      * Build a cache item for each pg_event_trigger tuple, and append each one
     136             :      * to the appropriate cache entry.
     137             :      */
     138             :     for (;;)
     139         204 :     {
     140             :         HeapTuple   tup;
     141             :         Form_pg_event_trigger form;
     142             :         char       *evtevent;
     143             :         EventTriggerEvent event;
     144             :         EventTriggerCacheItem *item;
     145             :         Datum       evttags;
     146             :         bool        evttags_isnull;
     147             :         EventTriggerCacheEntry *entry;
     148             :         bool        found;
     149             : 
     150             :         /* Get next tuple. */
     151        3780 :         tup = systable_getnext_ordered(scan, ForwardScanDirection);
     152        3780 :         if (!HeapTupleIsValid(tup))
     153        3576 :             break;
     154             : 
     155             :         /* Skip trigger if disabled. */
     156         204 :         form = (Form_pg_event_trigger) GETSTRUCT(tup);
     157         204 :         if (form->evtenabled == TRIGGER_DISABLED)
     158          20 :             continue;
     159             : 
     160             :         /* Decode event name. */
     161         184 :         evtevent = NameStr(form->evtevent);
     162         184 :         if (strcmp(evtevent, "ddl_command_start") == 0)
     163          48 :             event = EVT_DDLCommandStart;
     164         136 :         else if (strcmp(evtevent, "ddl_command_end") == 0)
     165          90 :             event = EVT_DDLCommandEnd;
     166          46 :         else if (strcmp(evtevent, "sql_drop") == 0)
     167          34 :             event = EVT_SQLDrop;
     168          12 :         else if (strcmp(evtevent, "table_rewrite") == 0)
     169          12 :             event = EVT_TableRewrite;
     170             :         else
     171           0 :             continue;
     172             : 
     173             :         /* Allocate new cache item. */
     174         184 :         item = palloc0(sizeof(EventTriggerCacheItem));
     175         184 :         item->fnoid = form->evtfoid;
     176         184 :         item->enabled = form->evtenabled;
     177             : 
     178             :         /* Decode and sort tags array. */
     179         184 :         evttags = heap_getattr(tup, Anum_pg_event_trigger_evttags,
     180             :                                RelationGetDescr(rel), &evttags_isnull);
     181         184 :         if (!evttags_isnull)
     182          52 :             item->tagset = DecodeTextArrayToBitmapset(evttags);
     183             : 
     184             :         /* Add to cache entry. */
     185         184 :         entry = hash_search(cache, &event, HASH_ENTER, &found);
     186         184 :         if (found)
     187          16 :             entry->triggerlist = lappend(entry->triggerlist, item);
     188             :         else
     189         168 :             entry->triggerlist = list_make1(item);
     190             :     }
     191             : 
     192             :     /* Done with pg_event_trigger scan. */
     193        3576 :     systable_endscan_ordered(scan);
     194        3576 :     index_close(irel, AccessShareLock);
     195        3576 :     relation_close(rel, AccessShareLock);
     196             : 
     197             :     /* Restore previous memory context. */
     198        3576 :     MemoryContextSwitchTo(oldcontext);
     199             : 
     200             :     /* Install new cache. */
     201        3576 :     EventTriggerCache = cache;
     202             : 
     203             :     /*
     204             :      * If the cache has been invalidated since we entered this routine, we
     205             :      * still use and return the cache we just finished constructing, to avoid
     206             :      * infinite loops, but we leave the cache marked stale so that we'll
     207             :      * rebuild it again on next access.  Otherwise, we mark the cache valid.
     208             :      */
     209        3576 :     if (EventTriggerCacheState == ETCS_REBUILD_STARTED)
     210        3576 :         EventTriggerCacheState = ETCS_VALID;
     211        3576 : }
     212             : 
     213             : /*
     214             :  * Decode text[] to a Bitmapset of CommandTags.
     215             :  *
     216             :  * We could avoid a bit of overhead here if we were willing to duplicate some
     217             :  * of the logic from deconstruct_array, but it doesn't seem worth the code
     218             :  * complexity.
     219             :  */
     220             : static Bitmapset *
     221          52 : DecodeTextArrayToBitmapset(Datum array)
     222             : {
     223          52 :     ArrayType  *arr = DatumGetArrayTypeP(array);
     224             :     Datum      *elems;
     225             :     Bitmapset  *bms;
     226             :     int         i;
     227             :     int         nelems;
     228             : 
     229          52 :     if (ARR_NDIM(arr) != 1 || ARR_HASNULL(arr) || ARR_ELEMTYPE(arr) != TEXTOID)
     230           0 :         elog(ERROR, "expected 1-D text array");
     231          52 :     deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
     232             :                       &elems, NULL, &nelems);
     233             : 
     234         172 :     for (bms = NULL, i = 0; i < nelems; ++i)
     235             :     {
     236         120 :         char       *str = TextDatumGetCString(elems[i]);
     237             : 
     238         120 :         bms = bms_add_member(bms, GetCommandTagEnum(str));
     239         120 :         pfree(str);
     240             :     }
     241             : 
     242          52 :     pfree(elems);
     243             : 
     244          52 :     return bms;
     245             : }
     246             : 
     247             : /*
     248             :  * Flush all cache entries when pg_event_trigger is updated.
     249             :  *
     250             :  * This should be rare enough that we don't need to be very granular about
     251             :  * it, so we just blow away everything, which also avoids the possibility of
     252             :  * memory leaks.
     253             :  */
     254             : static void
     255        1110 : InvalidateEventCacheCallback(Datum arg, int cacheid, uint32 hashvalue)
     256             : {
     257             :     /*
     258             :      * If the cache isn't valid, then there might be a rebuild in progress, so
     259             :      * we can't immediately blow it away.  But it's advantageous to do this
     260             :      * when possible, so as to immediately free memory.
     261             :      */
     262        1110 :     if (EventTriggerCacheState == ETCS_VALID)
     263             :     {
     264         516 :         MemoryContextResetAndDeleteChildren(EventTriggerCacheContext);
     265         516 :         EventTriggerCache = NULL;
     266             :     }
     267             : 
     268             :     /* Mark cache for rebuild. */
     269        1110 :     EventTriggerCacheState = ETCS_NEEDS_REBUILD;
     270        1110 : }

Generated by: LCOV version 1.13