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