Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * catcache.c
4 : * System catalog cache for tuples matching a key.
5 : *
6 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/utils/cache/catcache.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include "access/genam.h"
18 : #include "access/heaptoast.h"
19 : #include "access/relscan.h"
20 : #include "access/table.h"
21 : #include "access/xact.h"
22 : #include "catalog/catalog.h"
23 : #include "catalog/pg_collation.h"
24 : #include "catalog/pg_type.h"
25 : #include "common/hashfn.h"
26 : #include "common/pg_prng.h"
27 : #include "miscadmin.h"
28 : #include "port/pg_bitutils.h"
29 : #ifdef CATCACHE_STATS
30 : #include "storage/ipc.h" /* for on_proc_exit */
31 : #endif
32 : #include "storage/lmgr.h"
33 : #include "utils/builtins.h"
34 : #include "utils/catcache.h"
35 : #include "utils/datum.h"
36 : #include "utils/fmgroids.h"
37 : #include "utils/injection_point.h"
38 : #include "utils/inval.h"
39 : #include "utils/memutils.h"
40 : #include "utils/rel.h"
41 : #include "utils/resowner.h"
42 : #include "utils/syscache.h"
43 :
44 : /*
45 : * If a catcache invalidation is processed while we are in the middle of
46 : * creating a catcache entry (or list), it might apply to the entry we're
47 : * creating, making it invalid before it's been inserted to the catcache. To
48 : * catch such cases, we have a stack of "create-in-progress" entries. Cache
49 : * invalidation marks any matching entries in the stack as dead, in addition
50 : * to the actual CatCTup and CatCList entries.
51 : */
52 : typedef struct CatCInProgress
53 : {
54 : CatCache *cache; /* cache that the entry belongs to */
55 : uint32 hash_value; /* hash of the entry; ignored for lists */
56 : bool list; /* is it a list entry? */
57 : bool dead; /* set when the entry is invalidated */
58 : struct CatCInProgress *next;
59 : } CatCInProgress;
60 :
61 : static CatCInProgress *catcache_in_progress_stack = NULL;
62 :
63 : /* #define CACHEDEBUG */ /* turns DEBUG elogs on */
64 :
65 : /*
66 : * Given a hash value and the size of the hash table, find the bucket
67 : * in which the hash value belongs. Since the hash table must contain
68 : * a power-of-2 number of elements, this is a simple bitmask.
69 : */
70 : #define HASH_INDEX(h, sz) ((Index) ((h) & ((sz) - 1)))
71 :
72 :
73 : /*
74 : * variables, macros and other stuff
75 : */
76 :
77 : #ifdef CACHEDEBUG
78 : #define CACHE_elog(...) elog(__VA_ARGS__)
79 : #else
80 : #define CACHE_elog(...)
81 : #endif
82 :
83 : /* Cache management header --- pointer is NULL until created */
84 : static CatCacheHeader *CacheHdr = NULL;
85 :
86 : static inline HeapTuple SearchCatCacheInternal(CatCache *cache,
87 : int nkeys,
88 : Datum v1, Datum v2,
89 : Datum v3, Datum v4);
90 :
91 : static pg_noinline HeapTuple SearchCatCacheMiss(CatCache *cache,
92 : int nkeys,
93 : uint32 hashValue,
94 : Index hashIndex,
95 : Datum v1, Datum v2,
96 : Datum v3, Datum v4);
97 :
98 : static uint32 CatalogCacheComputeHashValue(CatCache *cache, int nkeys,
99 : Datum v1, Datum v2, Datum v3, Datum v4);
100 : static uint32 CatalogCacheComputeTupleHashValue(CatCache *cache, int nkeys,
101 : HeapTuple tuple);
102 : static inline bool CatalogCacheCompareTuple(const CatCache *cache, int nkeys,
103 : const Datum *cachekeys,
104 : const Datum *searchkeys);
105 :
106 : #ifdef CATCACHE_STATS
107 : static void CatCachePrintStats(int code, Datum arg);
108 : #endif
109 : static void CatCacheRemoveCTup(CatCache *cache, CatCTup *ct);
110 : static void CatCacheRemoveCList(CatCache *cache, CatCList *cl);
111 : static void RehashCatCache(CatCache *cp);
112 : static void RehashCatCacheLists(CatCache *cp);
113 : static void CatalogCacheInitializeCache(CatCache *cache);
114 : static CatCTup *CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp,
115 : Datum *arguments,
116 : uint32 hashValue, Index hashIndex);
117 :
118 : static void ReleaseCatCacheWithOwner(HeapTuple tuple, ResourceOwner resowner);
119 : static void ReleaseCatCacheListWithOwner(CatCList *list, ResourceOwner resowner);
120 : static void CatCacheFreeKeys(TupleDesc tupdesc, int nkeys, const int *attnos,
121 : const Datum *keys);
122 : static void CatCacheCopyKeys(TupleDesc tupdesc, int nkeys, const int *attnos,
123 : const Datum *srckeys, Datum *dstkeys);
124 :
125 :
126 : /*
127 : * internal support functions
128 : */
129 :
130 : /* ResourceOwner callbacks to hold catcache references */
131 :
132 : static void ResOwnerReleaseCatCache(Datum res);
133 : static char *ResOwnerPrintCatCache(Datum res);
134 : static void ResOwnerReleaseCatCacheList(Datum res);
135 : static char *ResOwnerPrintCatCacheList(Datum res);
136 :
137 : static const ResourceOwnerDesc catcache_resowner_desc =
138 : {
139 : /* catcache references */
140 : .name = "catcache reference",
141 : .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
142 : .release_priority = RELEASE_PRIO_CATCACHE_REFS,
143 : .ReleaseResource = ResOwnerReleaseCatCache,
144 : .DebugPrint = ResOwnerPrintCatCache
145 : };
146 :
147 : static const ResourceOwnerDesc catlistref_resowner_desc =
148 : {
149 : /* catcache-list pins */
150 : .name = "catcache list reference",
151 : .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
152 : .release_priority = RELEASE_PRIO_CATCACHE_LIST_REFS,
153 : .ReleaseResource = ResOwnerReleaseCatCacheList,
154 : .DebugPrint = ResOwnerPrintCatCacheList
155 : };
156 :
157 : /* Convenience wrappers over ResourceOwnerRemember/Forget */
158 : static inline void
159 62540684 : ResourceOwnerRememberCatCacheRef(ResourceOwner owner, HeapTuple tuple)
160 : {
161 62540684 : ResourceOwnerRemember(owner, PointerGetDatum(tuple), &catcache_resowner_desc);
162 62540684 : }
163 : static inline void
164 62533003 : ResourceOwnerForgetCatCacheRef(ResourceOwner owner, HeapTuple tuple)
165 : {
166 62533003 : ResourceOwnerForget(owner, PointerGetDatum(tuple), &catcache_resowner_desc);
167 62533003 : }
168 : static inline void
169 3015943 : ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list)
170 : {
171 3015943 : ResourceOwnerRemember(owner, PointerGetDatum(list), &catlistref_resowner_desc);
172 3015943 : }
173 : static inline void
174 3015919 : ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, CatCList *list)
175 : {
176 3015919 : ResourceOwnerForget(owner, PointerGetDatum(list), &catlistref_resowner_desc);
177 3015919 : }
178 :
179 :
180 : /*
181 : * Hash and equality functions for system types that are used as cache key
182 : * fields. In some cases, we just call the regular SQL-callable functions for
183 : * the appropriate data type, but that tends to be a little slow, and the
184 : * speed of these functions is performance-critical. Therefore, for data
185 : * types that frequently occur as catcache keys, we hard-code the logic here.
186 : * Avoiding the overhead of DirectFunctionCallN(...) is a substantial win, and
187 : * in certain cases (like int4) we can adopt a faster hash algorithm as well.
188 : */
189 :
190 : static bool
191 4746995 : chareqfast(Datum a, Datum b)
192 : {
193 4746995 : return DatumGetChar(a) == DatumGetChar(b);
194 : }
195 :
196 : static uint32
197 5253875 : charhashfast(Datum datum)
198 : {
199 5253875 : return murmurhash32((int32) DatumGetChar(datum));
200 : }
201 :
202 : static bool
203 2529326 : nameeqfast(Datum a, Datum b)
204 : {
205 2529326 : char *ca = NameStr(*DatumGetName(a));
206 2529326 : char *cb = NameStr(*DatumGetName(b));
207 :
208 : /*
209 : * Catalogs only use deterministic collations, so ignore column collation
210 : * and use fast path.
211 : */
212 2529326 : return strncmp(ca, cb, NAMEDATALEN) == 0;
213 : }
214 :
215 : static uint32
216 5754607 : namehashfast(Datum datum)
217 : {
218 5754607 : char *key = NameStr(*DatumGetName(datum));
219 :
220 : /*
221 : * Catalogs only use deterministic collations, so ignore column collation
222 : * and use fast path.
223 : */
224 5754607 : return hash_bytes((unsigned char *) key, strlen(key));
225 : }
226 :
227 : static bool
228 7650496 : int2eqfast(Datum a, Datum b)
229 : {
230 7650496 : return DatumGetInt16(a) == DatumGetInt16(b);
231 : }
232 :
233 : static uint32
234 10135581 : int2hashfast(Datum datum)
235 : {
236 10135581 : return murmurhash32((int32) DatumGetInt16(datum));
237 : }
238 :
239 : static bool
240 74628023 : int4eqfast(Datum a, Datum b)
241 : {
242 74628023 : return DatumGetInt32(a) == DatumGetInt32(b);
243 : }
244 :
245 : static uint32
246 86091785 : int4hashfast(Datum datum)
247 : {
248 86091785 : return murmurhash32((int32) DatumGetInt32(datum));
249 : }
250 :
251 : static bool
252 90 : texteqfast(Datum a, Datum b)
253 : {
254 : /*
255 : * Catalogs only use deterministic collations, so ignore column collation
256 : * and use "C" locale for efficiency.
257 : */
258 90 : return DatumGetBool(DirectFunctionCall2Coll(texteq, C_COLLATION_OID, a, b));
259 : }
260 :
261 : static uint32
262 2165 : texthashfast(Datum datum)
263 : {
264 : /*
265 : * Catalogs only use deterministic collations, so ignore column collation
266 : * and use "C" locale for efficiency.
267 : */
268 2165 : return DatumGetInt32(DirectFunctionCall1Coll(hashtext, C_COLLATION_OID, datum));
269 : }
270 :
271 : static bool
272 1789 : oidvectoreqfast(Datum a, Datum b)
273 : {
274 1789 : return DatumGetBool(DirectFunctionCall2(oidvectoreq, a, b));
275 : }
276 :
277 : static uint32
278 238086 : oidvectorhashfast(Datum datum)
279 : {
280 238086 : return DatumGetInt32(DirectFunctionCall1(hashoidvector, datum));
281 : }
282 :
283 : /* Lookup support functions for a type. */
284 : static void
285 725120 : GetCCHashEqFuncs(Oid keytype, CCHashFN *hashfunc, RegProcedure *eqfunc, CCFastEqualFN *fasteqfunc)
286 : {
287 725120 : switch (keytype)
288 : {
289 9121 : case BOOLOID:
290 9121 : *hashfunc = charhashfast;
291 9121 : *fasteqfunc = chareqfast;
292 9121 : *eqfunc = F_BOOLEQ;
293 9121 : break;
294 12103 : case CHAROID:
295 12103 : *hashfunc = charhashfast;
296 12103 : *fasteqfunc = chareqfast;
297 12103 : *eqfunc = F_CHAREQ;
298 12103 : break;
299 136716 : case NAMEOID:
300 136716 : *hashfunc = namehashfast;
301 136716 : *fasteqfunc = nameeqfast;
302 136716 : *eqfunc = F_NAMEEQ;
303 136716 : break;
304 39866 : case INT2OID:
305 39866 : *hashfunc = int2hashfast;
306 39866 : *fasteqfunc = int2eqfast;
307 39866 : *eqfunc = F_INT2EQ;
308 39866 : break;
309 10660 : case INT4OID:
310 10660 : *hashfunc = int4hashfast;
311 10660 : *fasteqfunc = int4eqfast;
312 10660 : *eqfunc = F_INT4EQ;
313 10660 : break;
314 4757 : case TEXTOID:
315 4757 : *hashfunc = texthashfast;
316 4757 : *fasteqfunc = texteqfast;
317 4757 : *eqfunc = F_TEXTEQ;
318 4757 : break;
319 502196 : case OIDOID:
320 : case REGPROCOID:
321 : case REGPROCEDUREOID:
322 : case REGOPEROID:
323 : case REGOPERATOROID:
324 : case REGCLASSOID:
325 : case REGTYPEOID:
326 : case REGCOLLATIONOID:
327 : case REGCONFIGOID:
328 : case REGDICTIONARYOID:
329 : case REGROLEOID:
330 : case REGNAMESPACEOID:
331 : case REGDATABASEOID:
332 502196 : *hashfunc = int4hashfast;
333 502196 : *fasteqfunc = int4eqfast;
334 502196 : *eqfunc = F_OIDEQ;
335 502196 : break;
336 9701 : case OIDVECTOROID:
337 9701 : *hashfunc = oidvectorhashfast;
338 9701 : *fasteqfunc = oidvectoreqfast;
339 9701 : *eqfunc = F_OIDVECTOREQ;
340 9701 : break;
341 0 : default:
342 0 : elog(FATAL, "type %u not supported as catcache key", keytype);
343 : *hashfunc = NULL; /* keep compiler quiet */
344 :
345 : *eqfunc = InvalidOid;
346 : break;
347 : }
348 725120 : }
349 :
350 : /*
351 : * CatalogCacheComputeHashValue
352 : *
353 : * Compute the hash value associated with a given set of lookup keys
354 : */
355 : static uint32
356 75493856 : CatalogCacheComputeHashValue(CatCache *cache, int nkeys,
357 : Datum v1, Datum v2, Datum v3, Datum v4)
358 : {
359 75493856 : uint32 hashValue = 0;
360 : uint32 oneHash;
361 75493856 : CCHashFN *cc_hashfunc = cache->cc_hashfunc;
362 :
363 : CACHE_elog(DEBUG2, "CatalogCacheComputeHashValue %s %d %p",
364 : cache->cc_relname, nkeys, cache);
365 :
366 75493856 : switch (nkeys)
367 : {
368 3814969 : case 4:
369 3814969 : oneHash = (cc_hashfunc[3]) (v4);
370 3814969 : hashValue ^= pg_rotate_left32(oneHash, 24);
371 : pg_fallthrough;
372 9581998 : case 3:
373 9581998 : oneHash = (cc_hashfunc[2]) (v3);
374 9581998 : hashValue ^= pg_rotate_left32(oneHash, 16);
375 : pg_fallthrough;
376 18585276 : case 2:
377 18585276 : oneHash = (cc_hashfunc[1]) (v2);
378 18585276 : hashValue ^= pg_rotate_left32(oneHash, 8);
379 : pg_fallthrough;
380 75493856 : case 1:
381 75493856 : oneHash = (cc_hashfunc[0]) (v1);
382 75493856 : hashValue ^= oneHash;
383 75493856 : break;
384 0 : default:
385 0 : elog(FATAL, "wrong number of hash keys: %d", nkeys);
386 : break;
387 : }
388 :
389 75493856 : return hashValue;
390 : }
391 :
392 : /*
393 : * CatalogCacheComputeTupleHashValue
394 : *
395 : * Compute the hash value associated with a given tuple to be cached
396 : */
397 : static uint32
398 4621050 : CatalogCacheComputeTupleHashValue(CatCache *cache, int nkeys, HeapTuple tuple)
399 : {
400 4621050 : Datum v1 = 0,
401 4621050 : v2 = 0,
402 4621050 : v3 = 0,
403 4621050 : v4 = 0;
404 4621050 : bool isNull = false;
405 4621050 : int *cc_keyno = cache->cc_keyno;
406 4621050 : TupleDesc cc_tupdesc = cache->cc_tupdesc;
407 :
408 : /* Now extract key fields from tuple, insert into scankey */
409 4621050 : switch (nkeys)
410 : {
411 303351 : case 4:
412 303351 : v4 = fastgetattr(tuple,
413 303351 : cc_keyno[3],
414 : cc_tupdesc,
415 : &isNull);
416 : Assert(!isNull);
417 : pg_fallthrough;
418 817875 : case 3:
419 817875 : v3 = fastgetattr(tuple,
420 817875 : cc_keyno[2],
421 : cc_tupdesc,
422 : &isNull);
423 : Assert(!isNull);
424 : pg_fallthrough;
425 3411583 : case 2:
426 3411583 : v2 = fastgetattr(tuple,
427 3411583 : cc_keyno[1],
428 : cc_tupdesc,
429 : &isNull);
430 : Assert(!isNull);
431 : pg_fallthrough;
432 4621050 : case 1:
433 4621050 : v1 = fastgetattr(tuple,
434 : cc_keyno[0],
435 : cc_tupdesc,
436 : &isNull);
437 : Assert(!isNull);
438 4621050 : break;
439 0 : default:
440 0 : elog(FATAL, "wrong number of hash keys: %d", nkeys);
441 : break;
442 : }
443 :
444 4621050 : return CatalogCacheComputeHashValue(cache, nkeys, v1, v2, v3, v4);
445 : }
446 :
447 : /*
448 : * CatalogCacheCompareTuple
449 : *
450 : * Compare a tuple to the passed arguments.
451 : */
452 : static inline bool
453 65628529 : CatalogCacheCompareTuple(const CatCache *cache, int nkeys,
454 : const Datum *cachekeys,
455 : const Datum *searchkeys)
456 : {
457 65628529 : const CCFastEqualFN *cc_fastequal = cache->cc_fastequal;
458 : int i;
459 :
460 155185248 : for (i = 0; i < nkeys; i++)
461 : {
462 89556719 : if (!(cc_fastequal[i]) (cachekeys[i], searchkeys[i]))
463 0 : return false;
464 : }
465 65628529 : return true;
466 : }
467 :
468 :
469 : #ifdef CATCACHE_STATS
470 :
471 : static void
472 : CatCachePrintStats(int code, Datum arg)
473 : {
474 : slist_iter iter;
475 : uint64 cc_searches = 0;
476 : uint64 cc_hits = 0;
477 : uint64 cc_neg_hits = 0;
478 : uint64 cc_newloads = 0;
479 : uint64 cc_invals = 0;
480 : uint64 cc_nlists = 0;
481 : uint64 cc_lsearches = 0;
482 : uint64 cc_lhits = 0;
483 :
484 : slist_foreach(iter, &CacheHdr->ch_caches)
485 : {
486 : CatCache *cache = slist_container(CatCache, cc_next, iter.cur);
487 :
488 : if (cache->cc_ntup == 0 && cache->cc_searches == 0)
489 : continue; /* don't print unused caches */
490 : elog(DEBUG2, "catcache %s/%u: %d tup, %" PRIu64 " srch, %" PRIu64 "+%"
491 : PRIu64 "=%" PRIu64 " hits, %" PRIu64 "+%" PRIu64 "=%"
492 : PRIu64 " loads, %" PRIu64 " invals, %d lists, %" PRIu64
493 : " lsrch, %" PRIu64 " lhits",
494 : cache->cc_relname,
495 : cache->cc_indexoid,
496 : cache->cc_ntup,
497 : cache->cc_searches,
498 : cache->cc_hits,
499 : cache->cc_neg_hits,
500 : cache->cc_hits + cache->cc_neg_hits,
501 : cache->cc_newloads,
502 : cache->cc_searches - cache->cc_hits - cache->cc_neg_hits - cache->cc_newloads,
503 : cache->cc_searches - cache->cc_hits - cache->cc_neg_hits,
504 : cache->cc_invals,
505 : cache->cc_nlist,
506 : cache->cc_lsearches,
507 : cache->cc_lhits);
508 : cc_searches += cache->cc_searches;
509 : cc_hits += cache->cc_hits;
510 : cc_neg_hits += cache->cc_neg_hits;
511 : cc_newloads += cache->cc_newloads;
512 : cc_invals += cache->cc_invals;
513 : cc_nlists += cache->cc_nlist;
514 : cc_lsearches += cache->cc_lsearches;
515 : cc_lhits += cache->cc_lhits;
516 : }
517 : elog(DEBUG2, "catcache totals: %d tup, %" PRIu64 " srch, %" PRIu64 "+%"
518 : PRIu64 "=%" PRIu64 " hits, %" PRIu64 "+%" PRIu64 "=%" PRIu64
519 : " loads, %" PRIu64 " invals, %" PRIu64 " lists, %" PRIu64
520 : " lsrch, %" PRIu64 " lhits",
521 : CacheHdr->ch_ntup,
522 : cc_searches,
523 : cc_hits,
524 : cc_neg_hits,
525 : cc_hits + cc_neg_hits,
526 : cc_newloads,
527 : cc_searches - cc_hits - cc_neg_hits - cc_newloads,
528 : cc_searches - cc_hits - cc_neg_hits,
529 : cc_invals,
530 : cc_nlists,
531 : cc_lsearches,
532 : cc_lhits);
533 : }
534 : #endif /* CATCACHE_STATS */
535 :
536 :
537 : /*
538 : * CatCacheRemoveCTup
539 : *
540 : * Unlink and delete the given cache entry
541 : *
542 : * NB: if it is a member of a CatCList, the CatCList is deleted too.
543 : * Both the cache entry and the list had better have zero refcount.
544 : */
545 : static void
546 1024708 : CatCacheRemoveCTup(CatCache *cache, CatCTup *ct)
547 : {
548 : Assert(ct->refcount == 0);
549 : Assert(ct->my_cache == cache);
550 :
551 1024708 : if (ct->c_list)
552 : {
553 : /*
554 : * The cleanest way to handle this is to call CatCacheRemoveCList,
555 : * which will recurse back to me, and the recursive call will do the
556 : * work. Set the "dead" flag to make sure it does recurse.
557 : */
558 0 : ct->dead = true;
559 0 : CatCacheRemoveCList(cache, ct->c_list);
560 0 : return; /* nothing left to do */
561 : }
562 :
563 : /* delink from linked list */
564 1024708 : dlist_delete(&ct->cache_elem);
565 :
566 : /*
567 : * Free keys when we're dealing with a negative entry, normal entries just
568 : * point into tuple, allocated together with the CatCTup.
569 : */
570 1024708 : if (ct->negative)
571 299749 : CatCacheFreeKeys(cache->cc_tupdesc, cache->cc_nkeys,
572 299749 : cache->cc_keyno, ct->keys);
573 :
574 1024708 : pfree(ct);
575 :
576 1024708 : --cache->cc_ntup;
577 1024708 : --CacheHdr->ch_ntup;
578 : }
579 :
580 : /*
581 : * CatCacheRemoveCList
582 : *
583 : * Unlink and delete the given cache list entry
584 : *
585 : * NB: any dead member entries that become unreferenced are deleted too.
586 : */
587 : static void
588 85775 : CatCacheRemoveCList(CatCache *cache, CatCList *cl)
589 : {
590 : int i;
591 :
592 : Assert(cl->refcount == 0);
593 : Assert(cl->my_cache == cache);
594 :
595 : /* delink from member tuples */
596 298515 : for (i = cl->n_members; --i >= 0;)
597 : {
598 212740 : CatCTup *ct = cl->members[i];
599 :
600 : Assert(ct->c_list == cl);
601 212740 : ct->c_list = NULL;
602 : /* if the member is dead and now has no references, remove it */
603 212740 : if (
604 : #ifndef CATCACHE_FORCE_RELEASE
605 212740 : ct->dead &&
606 : #endif
607 96 : ct->refcount == 0)
608 96 : CatCacheRemoveCTup(cache, ct);
609 : }
610 :
611 : /* delink from linked list */
612 85775 : dlist_delete(&cl->cache_elem);
613 :
614 : /* free associated column data */
615 85775 : CatCacheFreeKeys(cache->cc_tupdesc, cl->nkeys,
616 85775 : cache->cc_keyno, cl->keys);
617 :
618 85775 : pfree(cl);
619 :
620 85775 : --cache->cc_nlist;
621 85775 : }
622 :
623 :
624 : /*
625 : * CatCacheInvalidate
626 : *
627 : * Invalidate entries in the specified cache, given a hash value.
628 : *
629 : * We delete cache entries that match the hash value, whether positive
630 : * or negative. We don't care whether the invalidation is the result
631 : * of a tuple insertion or a deletion.
632 : *
633 : * We used to try to match positive cache entries by TID, but that is
634 : * unsafe after a VACUUM FULL on a system catalog: an inval event could
635 : * be queued before VACUUM FULL, and then processed afterwards, when the
636 : * target tuple that has to be invalidated has a different TID than it
637 : * did when the event was created. So now we just compare hash values and
638 : * accept the small risk of unnecessary invalidations due to false matches.
639 : *
640 : * This routine is only quasi-public: it should only be used by inval.c.
641 : */
642 : void
643 15766960 : CatCacheInvalidate(CatCache *cache, uint32 hashValue)
644 : {
645 : Index hashIndex;
646 : dlist_mutable_iter iter;
647 :
648 : CACHE_elog(DEBUG2, "CatCacheInvalidate: called");
649 :
650 : /*
651 : * We don't bother to check whether the cache has finished initialization
652 : * yet; if not, there will be no entries in it so no problem.
653 : */
654 :
655 : /*
656 : * Invalidate *all* CatCLists in this cache; it's too hard to tell which
657 : * searches might still be correct, so just zap 'em all.
658 : */
659 18292208 : for (int i = 0; i < cache->cc_nlbuckets; i++)
660 : {
661 2525248 : dlist_head *bucket = &cache->cc_lbucket[i];
662 :
663 2607557 : dlist_foreach_modify(iter, bucket)
664 : {
665 82309 : CatCList *cl = dlist_container(CatCList, cache_elem, iter.cur);
666 :
667 82309 : if (cl->refcount > 0)
668 96 : cl->dead = true;
669 : else
670 82213 : CatCacheRemoveCList(cache, cl);
671 : }
672 : }
673 :
674 : /*
675 : * inspect the proper hash bucket for tuple matches
676 : */
677 15766960 : hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
678 21685601 : dlist_foreach_modify(iter, &cache->cc_bucket[hashIndex])
679 : {
680 5918641 : CatCTup *ct = dlist_container(CatCTup, cache_elem, iter.cur);
681 :
682 5918641 : if (hashValue == ct->hash_value)
683 : {
684 900290 : if (ct->refcount > 0 ||
685 899413 : (ct->c_list && ct->c_list->refcount > 0))
686 : {
687 973 : ct->dead = true;
688 : /* list, if any, was marked dead above */
689 973 : Assert(ct->c_list == NULL || ct->c_list->dead);
690 : }
691 : else
692 899317 : CatCacheRemoveCTup(cache, ct);
693 : CACHE_elog(DEBUG2, "CatCacheInvalidate: invalidated");
694 : #ifdef CATCACHE_STATS
695 : cache->cc_invals++;
696 : #endif
697 : /* could be multiple matches, so keep looking! */
698 : }
699 : }
700 :
701 : /* Also invalidate any entries that are being built */
702 15874102 : for (CatCInProgress *e = catcache_in_progress_stack; e != NULL; e = e->next)
703 : {
704 107142 : if (e->cache == cache)
705 : {
706 447 : if (e->list || e->hash_value == hashValue)
707 414 : e->dead = true;
708 : }
709 : }
710 15766960 : }
711 :
712 : /* ----------------------------------------------------------------
713 : * public functions
714 : * ----------------------------------------------------------------
715 : */
716 :
717 :
718 : /*
719 : * Standard routine for creating cache context if it doesn't exist yet
720 : *
721 : * There are a lot of places (probably far more than necessary) that check
722 : * whether CacheMemoryContext exists yet and want to create it if not.
723 : * We centralize knowledge of exactly how to create it here.
724 : */
725 : void
726 19935 : CreateCacheMemoryContext(void)
727 : {
728 : /*
729 : * Purely for paranoia, check that context doesn't exist; caller probably
730 : * did so already.
731 : */
732 19935 : if (!CacheMemoryContext)
733 19935 : CacheMemoryContext = AllocSetContextCreate(TopMemoryContext,
734 : "CacheMemoryContext",
735 : ALLOCSET_DEFAULT_SIZES);
736 19935 : }
737 :
738 :
739 : /*
740 : * ResetCatalogCache
741 : *
742 : * Reset one catalog cache to empty.
743 : *
744 : * This is not very efficient if the target cache is nearly empty.
745 : * However, it shouldn't need to be efficient; we don't invoke it often.
746 : *
747 : * If 'debug_discard' is true, we are being called as part of
748 : * debug_discard_caches. In that case, the cache is not reset for
749 : * correctness, but just to get more testing of cache invalidation. We skip
750 : * resetting in-progress build entries in that case, or we'd never make any
751 : * progress.
752 : */
753 : static void
754 258163 : ResetCatalogCache(CatCache *cache, bool debug_discard)
755 : {
756 : dlist_mutable_iter iter;
757 : int i;
758 :
759 : /* Remove each list in this cache, or at least mark it dead */
760 285875 : for (i = 0; i < cache->cc_nlbuckets; i++)
761 : {
762 27712 : dlist_head *bucket = &cache->cc_lbucket[i];
763 :
764 31270 : dlist_foreach_modify(iter, bucket)
765 : {
766 3558 : CatCList *cl = dlist_container(CatCList, cache_elem, iter.cur);
767 :
768 3558 : if (cl->refcount > 0)
769 0 : cl->dead = true;
770 : else
771 3558 : CatCacheRemoveCList(cache, cl);
772 : }
773 : }
774 :
775 : /* Remove each tuple in this cache, or at least mark it dead */
776 9925385 : for (i = 0; i < cache->cc_nbuckets; i++)
777 : {
778 9667222 : dlist_head *bucket = &cache->cc_bucket[i];
779 :
780 9791649 : dlist_foreach_modify(iter, bucket)
781 : {
782 124427 : CatCTup *ct = dlist_container(CatCTup, cache_elem, iter.cur);
783 :
784 124427 : if (ct->refcount > 0 ||
785 124427 : (ct->c_list && ct->c_list->refcount > 0))
786 : {
787 0 : ct->dead = true;
788 : /* list, if any, was marked dead above */
789 0 : Assert(ct->c_list == NULL || ct->c_list->dead);
790 : }
791 : else
792 124427 : CatCacheRemoveCTup(cache, ct);
793 : #ifdef CATCACHE_STATS
794 : cache->cc_invals++;
795 : #endif
796 : }
797 : }
798 :
799 : /* Also invalidate any entries that are being built */
800 258163 : if (!debug_discard)
801 : {
802 258630 : for (CatCInProgress *e = catcache_in_progress_stack; e != NULL; e = e->next)
803 : {
804 467 : if (e->cache == cache)
805 5 : e->dead = true;
806 : }
807 : }
808 258163 : }
809 :
810 : /*
811 : * ResetCatalogCaches
812 : *
813 : * Reset all caches when a shared cache inval event forces it
814 : */
815 : void
816 0 : ResetCatalogCaches(void)
817 : {
818 0 : ResetCatalogCachesExt(false);
819 0 : }
820 :
821 : void
822 2769 : ResetCatalogCachesExt(bool debug_discard)
823 : {
824 : slist_iter iter;
825 :
826 : CACHE_elog(DEBUG2, "ResetCatalogCaches called");
827 :
828 260286 : slist_foreach(iter, &CacheHdr->ch_caches)
829 : {
830 257517 : CatCache *cache = slist_container(CatCache, cc_next, iter.cur);
831 :
832 257517 : ResetCatalogCache(cache, debug_discard);
833 : }
834 :
835 : CACHE_elog(DEBUG2, "end of ResetCatalogCaches call");
836 2769 : }
837 :
838 : /*
839 : * CatalogCacheFlushCatalog
840 : *
841 : * Flush all catcache entries that came from the specified system catalog.
842 : * This is needed after VACUUM FULL/CLUSTER on the catalog, since the
843 : * tuples very likely now have different TIDs than before. (At one point
844 : * we also tried to force re-execution of CatalogCacheInitializeCache for
845 : * the cache(s) on that catalog. This is a bad idea since it leads to all
846 : * kinds of trouble if a cache flush occurs while loading cache entries.
847 : * We now avoid the need to do it by copying cc_tupdesc out of the relcache,
848 : * rather than relying on the relcache to keep a tupdesc for us. Of course
849 : * this assumes the tupdesc of a cacheable system table will not change...)
850 : */
851 : void
852 457 : CatalogCacheFlushCatalog(Oid catId)
853 : {
854 : slist_iter iter;
855 :
856 : CACHE_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
857 :
858 42958 : slist_foreach(iter, &CacheHdr->ch_caches)
859 : {
860 42501 : CatCache *cache = slist_container(CatCache, cc_next, iter.cur);
861 :
862 : /* Does this cache store tuples of the target catalog? */
863 42501 : if (cache->cc_reloid == catId)
864 : {
865 : /* Yes, so flush all its contents */
866 646 : ResetCatalogCache(cache, false);
867 :
868 : /* Tell inval.c to call syscache callbacks for this cache */
869 646 : CallSyscacheCallbacks(cache->id, 0);
870 : }
871 : }
872 :
873 : CACHE_elog(DEBUG2, "end of CatalogCacheFlushCatalog call");
874 457 : }
875 :
876 : /*
877 : * InitCatCache
878 : *
879 : * This allocates and initializes a cache for a system catalog relation.
880 : * Actually, the cache is only partially initialized to avoid opening the
881 : * relation. The relation will be opened and the rest of the cache
882 : * structure initialized on the first access.
883 : */
884 : #ifdef CACHEDEBUG
885 : #define InitCatCache_DEBUG2 \
886 : do { \
887 : elog(DEBUG2, "InitCatCache: rel=%u ind=%u id=%d nkeys=%d size=%d", \
888 : cp->cc_reloid, cp->cc_indexoid, cp->id, \
889 : cp->cc_nkeys, cp->cc_nbuckets); \
890 : } while(0)
891 : #else
892 : #define InitCatCache_DEBUG2
893 : #endif
894 :
895 : CatCache *
896 1853955 : InitCatCache(int id,
897 : Oid reloid,
898 : Oid indexoid,
899 : int nkeys,
900 : const int *key,
901 : int nbuckets)
902 : {
903 : CatCache *cp;
904 : MemoryContext oldcxt;
905 : int i;
906 :
907 : /*
908 : * nbuckets is the initial number of hash buckets to use in this catcache.
909 : * It will be enlarged later if it becomes too full.
910 : *
911 : * nbuckets must be a power of two. We check this via Assert rather than
912 : * a full runtime check because the values will be coming from constant
913 : * tables.
914 : *
915 : * If you're confused by the power-of-two check, see comments in
916 : * bitmapset.c for an explanation.
917 : */
918 : Assert(nbuckets > 0 && (nbuckets & -nbuckets) == nbuckets);
919 :
920 : /*
921 : * first switch to the cache context so our allocations do not vanish at
922 : * the end of a transaction
923 : */
924 1853955 : if (!CacheMemoryContext)
925 0 : CreateCacheMemoryContext();
926 :
927 1853955 : oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
928 :
929 : /*
930 : * if first time through, initialize the cache group header
931 : */
932 1853955 : if (CacheHdr == NULL)
933 : {
934 19935 : CacheHdr = palloc_object(CatCacheHeader);
935 19935 : slist_init(&CacheHdr->ch_caches);
936 19935 : CacheHdr->ch_ntup = 0;
937 : #ifdef CATCACHE_STATS
938 : /* set up to dump stats at backend exit */
939 : on_proc_exit(CatCachePrintStats, 0);
940 : #endif
941 : }
942 :
943 : /*
944 : * Allocate a new cache structure, aligning to a cacheline boundary
945 : *
946 : * Note: we rely on zeroing to initialize all the dlist headers correctly
947 : */
948 1853955 : cp = (CatCache *) palloc_aligned(sizeof(CatCache), PG_CACHE_LINE_SIZE,
949 : MCXT_ALLOC_ZERO);
950 1853955 : cp->cc_bucket = palloc0(nbuckets * sizeof(dlist_head));
951 :
952 : /*
953 : * Many catcaches never receive any list searches. Therefore, we don't
954 : * allocate the cc_lbuckets till we get a list search.
955 : */
956 1853955 : cp->cc_lbucket = NULL;
957 :
958 : /*
959 : * initialize the cache's relation information for the relation
960 : * corresponding to this cache, and initialize some of the new cache's
961 : * other internal fields. But don't open the relation yet.
962 : */
963 1853955 : cp->id = id;
964 1853955 : cp->cc_relname = "(not known yet)";
965 1853955 : cp->cc_reloid = reloid;
966 1853955 : cp->cc_indexoid = indexoid;
967 1853955 : cp->cc_relisshared = false; /* temporary */
968 1853955 : cp->cc_tupdesc = (TupleDesc) NULL;
969 1853955 : cp->cc_ntup = 0;
970 1853955 : cp->cc_nlist = 0;
971 1853955 : cp->cc_nbuckets = nbuckets;
972 1853955 : cp->cc_nlbuckets = 0;
973 1853955 : cp->cc_nkeys = nkeys;
974 4844205 : for (i = 0; i < nkeys; ++i)
975 : {
976 : Assert(AttributeNumberIsValid(key[i]));
977 2990250 : cp->cc_keyno[i] = key[i];
978 : }
979 :
980 : /*
981 : * new cache is initialized as far as we can go for now. print some
982 : * debugging information, if appropriate.
983 : */
984 : InitCatCache_DEBUG2;
985 :
986 : /*
987 : * add completed cache to top of group header's list
988 : */
989 1853955 : slist_push_head(&CacheHdr->ch_caches, &cp->cc_next);
990 :
991 : /*
992 : * back to the old context before we return...
993 : */
994 1853955 : MemoryContextSwitchTo(oldcxt);
995 :
996 1853955 : return cp;
997 : }
998 :
999 : /*
1000 : * Enlarge a catcache, doubling the number of buckets.
1001 : */
1002 : static void
1003 4505 : RehashCatCache(CatCache *cp)
1004 : {
1005 : dlist_head *newbucket;
1006 : int newnbuckets;
1007 : int i;
1008 :
1009 4505 : elog(DEBUG1, "rehashing catalog cache id %d for %s; %d tups, %d buckets",
1010 : cp->id, cp->cc_relname, cp->cc_ntup, cp->cc_nbuckets);
1011 :
1012 : /* Allocate a new, larger, hash table. */
1013 4505 : newnbuckets = cp->cc_nbuckets * 2;
1014 4505 : newbucket = (dlist_head *) MemoryContextAllocZero(CacheMemoryContext, newnbuckets * sizeof(dlist_head));
1015 :
1016 : /* Move all entries from old hash table to new. */
1017 568645 : for (i = 0; i < cp->cc_nbuckets; i++)
1018 : {
1019 : dlist_mutable_iter iter;
1020 :
1021 1696925 : dlist_foreach_modify(iter, &cp->cc_bucket[i])
1022 : {
1023 1132785 : CatCTup *ct = dlist_container(CatCTup, cache_elem, iter.cur);
1024 1132785 : int hashIndex = HASH_INDEX(ct->hash_value, newnbuckets);
1025 :
1026 1132785 : dlist_delete(iter.cur);
1027 :
1028 : /*
1029 : * Note that each item is pushed at the tail of the new bucket,
1030 : * not its head. This is consistent with the SearchCatCache*()
1031 : * routines, where matching entries are moved at the front of the
1032 : * list to speed subsequent searches.
1033 : */
1034 1132785 : dlist_push_tail(&newbucket[hashIndex], &ct->cache_elem);
1035 : }
1036 : }
1037 :
1038 : /* Switch to the new array. */
1039 4505 : pfree(cp->cc_bucket);
1040 4505 : cp->cc_nbuckets = newnbuckets;
1041 4505 : cp->cc_bucket = newbucket;
1042 4505 : }
1043 :
1044 : /*
1045 : * Enlarge a catcache's list storage, doubling the number of buckets.
1046 : */
1047 : static void
1048 805 : RehashCatCacheLists(CatCache *cp)
1049 : {
1050 : dlist_head *newbucket;
1051 : int newnbuckets;
1052 : int i;
1053 :
1054 805 : elog(DEBUG1, "rehashing catalog cache id %d for %s; %d lists, %d buckets",
1055 : cp->id, cp->cc_relname, cp->cc_nlist, cp->cc_nlbuckets);
1056 :
1057 : /* Allocate a new, larger, hash table. */
1058 805 : newnbuckets = cp->cc_nlbuckets * 2;
1059 805 : newbucket = (dlist_head *) MemoryContextAllocZero(CacheMemoryContext, newnbuckets * sizeof(dlist_head));
1060 :
1061 : /* Move all entries from old hash table to new. */
1062 30133 : for (i = 0; i < cp->cc_nlbuckets; i++)
1063 : {
1064 : dlist_mutable_iter iter;
1065 :
1066 88789 : dlist_foreach_modify(iter, &cp->cc_lbucket[i])
1067 : {
1068 59461 : CatCList *cl = dlist_container(CatCList, cache_elem, iter.cur);
1069 59461 : int hashIndex = HASH_INDEX(cl->hash_value, newnbuckets);
1070 :
1071 59461 : dlist_delete(iter.cur);
1072 :
1073 : /*
1074 : * Note that each item is pushed at the tail of the new bucket,
1075 : * not its head. This is consistent with the SearchCatCache*()
1076 : * routines, where matching entries are moved at the front of the
1077 : * list to speed subsequent searches.
1078 : */
1079 59461 : dlist_push_tail(&newbucket[hashIndex], &cl->cache_elem);
1080 : }
1081 : }
1082 :
1083 : /* Switch to the new array. */
1084 805 : pfree(cp->cc_lbucket);
1085 805 : cp->cc_nlbuckets = newnbuckets;
1086 805 : cp->cc_lbucket = newbucket;
1087 805 : }
1088 :
1089 : /*
1090 : * ConditionalCatalogCacheInitializeCache
1091 : *
1092 : * Call CatalogCacheInitializeCache() if not yet done.
1093 : */
1094 : pg_attribute_always_inline
1095 : static void
1096 74807936 : ConditionalCatalogCacheInitializeCache(CatCache *cache)
1097 : {
1098 : #ifdef USE_ASSERT_CHECKING
1099 : /*
1100 : * TypeCacheRelCallback() runs outside transactions and relies on TYPEOID
1101 : * for hashing. This isn't ideal. Since lookup_type_cache() both
1102 : * registers the callback and searches TYPEOID, reaching trouble likely
1103 : * requires OOM at an unlucky moment.
1104 : *
1105 : * InvalidateAttoptCacheCallback() runs outside transactions and likewise
1106 : * relies on ATTNUM. InitPostgres() initializes ATTNUM, so it's reliable.
1107 : */
1108 : if (!(cache->id == TYPEOID || cache->id == ATTNUM) ||
1109 : IsTransactionState())
1110 : AssertCouldGetRelation();
1111 : else
1112 : Assert(cache->cc_tupdesc != NULL);
1113 : #endif
1114 :
1115 74807936 : if (unlikely(cache->cc_tupdesc == NULL))
1116 459148 : CatalogCacheInitializeCache(cache);
1117 74807936 : }
1118 :
1119 : /*
1120 : * CatalogCacheInitializeCache
1121 : *
1122 : * This function does final initialization of a catcache: obtain the tuple
1123 : * descriptor and set up the hash and equality function links.
1124 : */
1125 : #ifdef CACHEDEBUG
1126 : #define CatalogCacheInitializeCache_DEBUG1 \
1127 : elog(DEBUG2, "CatalogCacheInitializeCache: cache @%p rel=%u", cache, \
1128 : cache->cc_reloid)
1129 :
1130 : #define CatalogCacheInitializeCache_DEBUG2 \
1131 : do { \
1132 : if (cache->cc_keyno[i] > 0) { \
1133 : elog(DEBUG2, "CatalogCacheInitializeCache: load %d/%d w/%d, %u", \
1134 : i+1, cache->cc_nkeys, cache->cc_keyno[i], \
1135 : TupleDescAttr(tupdesc, cache->cc_keyno[i] - 1)->atttypid); \
1136 : } else { \
1137 : elog(DEBUG2, "CatalogCacheInitializeCache: load %d/%d w/%d", \
1138 : i+1, cache->cc_nkeys, cache->cc_keyno[i]); \
1139 : } \
1140 : } while(0)
1141 : #else
1142 : #define CatalogCacheInitializeCache_DEBUG1
1143 : #define CatalogCacheInitializeCache_DEBUG2
1144 : #endif
1145 :
1146 : static void
1147 459148 : CatalogCacheInitializeCache(CatCache *cache)
1148 : {
1149 : Relation relation;
1150 : MemoryContext oldcxt;
1151 : TupleDesc tupdesc;
1152 : int i;
1153 :
1154 : CatalogCacheInitializeCache_DEBUG1;
1155 :
1156 459148 : relation = table_open(cache->cc_reloid, AccessShareLock);
1157 :
1158 : /*
1159 : * switch to the cache context so our allocations do not vanish at the end
1160 : * of a transaction
1161 : */
1162 : Assert(CacheMemoryContext != NULL);
1163 :
1164 459148 : oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
1165 :
1166 : /*
1167 : * copy the relcache's tuple descriptor to permanent cache storage
1168 : */
1169 459148 : tupdesc = CreateTupleDescCopyConstr(RelationGetDescr(relation));
1170 :
1171 : /*
1172 : * save the relation's name and relisshared flag, too (cc_relname is used
1173 : * only for debugging purposes)
1174 : */
1175 459148 : cache->cc_relname = pstrdup(RelationGetRelationName(relation));
1176 459148 : cache->cc_relisshared = RelationGetForm(relation)->relisshared;
1177 :
1178 : /*
1179 : * return to the caller's memory context and close the rel
1180 : */
1181 459148 : MemoryContextSwitchTo(oldcxt);
1182 :
1183 459148 : table_close(relation, AccessShareLock);
1184 :
1185 : CACHE_elog(DEBUG2, "CatalogCacheInitializeCache: %s, %d keys",
1186 : cache->cc_relname, cache->cc_nkeys);
1187 :
1188 : /*
1189 : * initialize cache's key information
1190 : */
1191 1184268 : for (i = 0; i < cache->cc_nkeys; ++i)
1192 : {
1193 : Oid keytype;
1194 : RegProcedure eqfunc;
1195 :
1196 : CatalogCacheInitializeCache_DEBUG2;
1197 :
1198 725120 : if (cache->cc_keyno[i] > 0)
1199 : {
1200 725120 : Form_pg_attribute attr = TupleDescAttr(tupdesc,
1201 725120 : cache->cc_keyno[i] - 1);
1202 :
1203 725120 : keytype = attr->atttypid;
1204 : /* cache key columns should always be NOT NULL */
1205 : Assert(attr->attnotnull);
1206 : }
1207 : else
1208 : {
1209 0 : if (cache->cc_keyno[i] < 0)
1210 0 : elog(FATAL, "sys attributes are not supported in caches");
1211 0 : keytype = OIDOID;
1212 : }
1213 :
1214 725120 : GetCCHashEqFuncs(keytype,
1215 : &cache->cc_hashfunc[i],
1216 : &eqfunc,
1217 : &cache->cc_fastequal[i]);
1218 :
1219 : /*
1220 : * Do equality-function lookup (we assume this won't need a catalog
1221 : * lookup for any supported type)
1222 : */
1223 725120 : fmgr_info_cxt(eqfunc,
1224 : &cache->cc_skey[i].sk_func,
1225 : CacheMemoryContext);
1226 :
1227 : /* Initialize sk_attno suitably for HeapKeyTest() and heap scans */
1228 725120 : cache->cc_skey[i].sk_attno = cache->cc_keyno[i];
1229 :
1230 : /* Fill in sk_strategy as well --- always standard equality */
1231 725120 : cache->cc_skey[i].sk_strategy = BTEqualStrategyNumber;
1232 725120 : cache->cc_skey[i].sk_subtype = InvalidOid;
1233 : /* If a catcache key requires a collation, it must be C collation */
1234 725120 : cache->cc_skey[i].sk_collation = C_COLLATION_OID;
1235 :
1236 : CACHE_elog(DEBUG2, "CatalogCacheInitializeCache %s %d %p",
1237 : cache->cc_relname, i, cache);
1238 : }
1239 :
1240 : /*
1241 : * mark this cache fully initialized
1242 : */
1243 459148 : cache->cc_tupdesc = tupdesc;
1244 459148 : }
1245 :
1246 : /*
1247 : * InitCatCachePhase2 -- external interface for CatalogCacheInitializeCache
1248 : *
1249 : * One reason to call this routine is to ensure that the relcache has
1250 : * created entries for all the catalogs and indexes referenced by catcaches.
1251 : * Therefore, provide an option to open the index as well as fixing the
1252 : * cache itself. An exception is the indexes on pg_am, which we don't use
1253 : * (cf. IndexScanOK).
1254 : */
1255 : void
1256 206119 : InitCatCachePhase2(CatCache *cache, bool touch_index)
1257 : {
1258 206119 : ConditionalCatalogCacheInitializeCache(cache);
1259 :
1260 206119 : if (touch_index &&
1261 187209 : cache->id != AMOID &&
1262 185196 : cache->id != AMNAME)
1263 : {
1264 : Relation idesc;
1265 :
1266 : /*
1267 : * We must lock the underlying catalog before opening the index to
1268 : * avoid deadlock, since index_open could possibly result in reading
1269 : * this same catalog, and if anyone else is exclusive-locking this
1270 : * catalog and index they'll be doing it in that order.
1271 : */
1272 183183 : LockRelationOid(cache->cc_reloid, AccessShareLock);
1273 183183 : idesc = index_open(cache->cc_indexoid, AccessShareLock);
1274 :
1275 : /*
1276 : * While we've got the index open, let's check that it's unique (and
1277 : * not just deferrable-unique, thank you very much). This is just to
1278 : * catch thinkos in definitions of new catcaches, so we don't worry
1279 : * about the pg_am indexes not getting tested.
1280 : */
1281 : Assert(idesc->rd_index->indisunique &&
1282 : idesc->rd_index->indimmediate);
1283 :
1284 183183 : index_close(idesc, AccessShareLock);
1285 183183 : UnlockRelationOid(cache->cc_reloid, AccessShareLock);
1286 : }
1287 206119 : }
1288 :
1289 :
1290 : /*
1291 : * IndexScanOK
1292 : *
1293 : * This function checks for tuples that will be fetched by
1294 : * IndexSupportInitialize() during relcache initialization for
1295 : * certain system indexes that support critical syscaches.
1296 : * We can't use an indexscan to fetch these, else we'll get into
1297 : * infinite recursion. A plain heap scan will work, however.
1298 : * Once we have completed relcache initialization (signaled by
1299 : * criticalRelcachesBuilt), we don't have to worry anymore.
1300 : *
1301 : * Similarly, during backend startup we have to be able to use the
1302 : * pg_authid, pg_auth_members and pg_database syscaches for
1303 : * authentication even if we don't yet have relcache entries for those
1304 : * catalogs' indexes.
1305 : */
1306 : static bool
1307 4467474 : IndexScanOK(CatCache *cache)
1308 : {
1309 4467474 : switch (cache->id)
1310 : {
1311 426284 : case INDEXRELID:
1312 :
1313 : /*
1314 : * Rather than tracking exactly which indexes have to be loaded
1315 : * before we can use indexscans (which changes from time to time),
1316 : * just force all pg_index searches to be heap scans until we've
1317 : * built the critical relcaches.
1318 : */
1319 426284 : if (!criticalRelcachesBuilt)
1320 22508 : return false;
1321 403776 : break;
1322 :
1323 36352 : case AMOID:
1324 : case AMNAME:
1325 :
1326 : /*
1327 : * Always do heap scans in pg_am, because it's so small there's
1328 : * not much point in an indexscan anyway. We *must* do this when
1329 : * initially building critical relcache entries, but we might as
1330 : * well just always do it.
1331 : */
1332 36352 : return false;
1333 :
1334 65284 : case AUTHNAME:
1335 : case AUTHOID:
1336 : case AUTHMEMMEMROLE:
1337 : case DATABASEOID:
1338 :
1339 : /*
1340 : * Protect authentication lookups occurring before relcache has
1341 : * collected entries for shared indexes.
1342 : */
1343 65284 : if (!criticalSharedRelcachesBuilt)
1344 2705 : return false;
1345 62579 : break;
1346 :
1347 3939554 : default:
1348 3939554 : break;
1349 : }
1350 :
1351 : /* Normal case, allow index scan */
1352 4405909 : return true;
1353 : }
1354 :
1355 : /*
1356 : * SearchCatCache
1357 : *
1358 : * This call searches a system cache for a tuple, opening the relation
1359 : * if necessary (on the first access to a particular cache).
1360 : *
1361 : * The result is NULL if not found, or a pointer to a HeapTuple in
1362 : * the cache. The caller must not modify the tuple, and must call
1363 : * ReleaseCatCache() when done with it.
1364 : *
1365 : * The search key values should be expressed as Datums of the key columns'
1366 : * datatype(s). (Pass zeroes for any unused parameters.) As a special
1367 : * exception, the passed-in key for a NAME column can be just a C string;
1368 : * the caller need not go to the trouble of converting it to a fully
1369 : * null-padded NAME.
1370 : */
1371 : HeapTuple
1372 3832903 : SearchCatCache(CatCache *cache,
1373 : Datum v1,
1374 : Datum v2,
1375 : Datum v3,
1376 : Datum v4)
1377 : {
1378 3832903 : return SearchCatCacheInternal(cache, cache->cc_nkeys, v1, v2, v3, v4);
1379 : }
1380 :
1381 :
1382 : /*
1383 : * SearchCatCacheN() are SearchCatCache() versions for a specific number of
1384 : * arguments. The compiler can inline the body and unroll loops, making them a
1385 : * bit faster than SearchCatCache().
1386 : */
1387 :
1388 : HeapTuple
1389 50794227 : SearchCatCache1(CatCache *cache,
1390 : Datum v1)
1391 : {
1392 50794227 : return SearchCatCacheInternal(cache, 1, v1, 0, 0, 0);
1393 : }
1394 :
1395 :
1396 : HeapTuple
1397 4316052 : SearchCatCache2(CatCache *cache,
1398 : Datum v1, Datum v2)
1399 : {
1400 4316052 : return SearchCatCacheInternal(cache, 2, v1, v2, 0, 0);
1401 : }
1402 :
1403 :
1404 : HeapTuple
1405 4625823 : SearchCatCache3(CatCache *cache,
1406 : Datum v1, Datum v2, Datum v3)
1407 : {
1408 4625823 : return SearchCatCacheInternal(cache, 3, v1, v2, v3, 0);
1409 : }
1410 :
1411 :
1412 : HeapTuple
1413 3511050 : SearchCatCache4(CatCache *cache,
1414 : Datum v1, Datum v2, Datum v3, Datum v4)
1415 : {
1416 3511050 : return SearchCatCacheInternal(cache, 4, v1, v2, v3, v4);
1417 : }
1418 :
1419 : /*
1420 : * Work-horse for SearchCatCache/SearchCatCacheN.
1421 : */
1422 : static inline HeapTuple
1423 67080055 : SearchCatCacheInternal(CatCache *cache,
1424 : int nkeys,
1425 : Datum v1,
1426 : Datum v2,
1427 : Datum v3,
1428 : Datum v4)
1429 : {
1430 : Datum arguments[CATCACHE_MAXKEYS];
1431 : uint32 hashValue;
1432 : Index hashIndex;
1433 : dlist_iter iter;
1434 : dlist_head *bucket;
1435 : CatCTup *ct;
1436 :
1437 : Assert(cache->cc_nkeys == nkeys);
1438 :
1439 : /*
1440 : * one-time startup overhead for each cache
1441 : */
1442 67080055 : ConditionalCatalogCacheInitializeCache(cache);
1443 :
1444 : #ifdef CATCACHE_STATS
1445 : cache->cc_searches++;
1446 : #endif
1447 :
1448 : /* Initialize local parameter array */
1449 67080055 : arguments[0] = v1;
1450 67080055 : arguments[1] = v2;
1451 67080055 : arguments[2] = v3;
1452 67080055 : arguments[3] = v4;
1453 :
1454 : /*
1455 : * find the hash bucket in which to look for the tuple
1456 : */
1457 67080055 : hashValue = CatalogCacheComputeHashValue(cache, nkeys, v1, v2, v3, v4);
1458 67080055 : hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
1459 :
1460 : /*
1461 : * scan the hash bucket until we find a match or exhaust our tuples
1462 : *
1463 : * Note: it's okay to use dlist_foreach here, even though we modify the
1464 : * dlist within the loop, because we don't continue the loop afterwards.
1465 : */
1466 67080055 : bucket = &cache->cc_bucket[hashIndex];
1467 72474284 : dlist_foreach(iter, bucket)
1468 : {
1469 68202414 : ct = dlist_container(CatCTup, cache_elem, iter.cur);
1470 :
1471 68202414 : if (ct->dead)
1472 1 : continue; /* ignore dead entries */
1473 :
1474 68202413 : if (ct->hash_value != hashValue)
1475 5394228 : continue; /* quickly skip entry if wrong hash val */
1476 :
1477 62808185 : if (!CatalogCacheCompareTuple(cache, nkeys, ct->keys, arguments))
1478 0 : continue;
1479 :
1480 : /*
1481 : * We found a match in the cache. Move it to the front of the list
1482 : * for its hashbucket, in order to speed subsequent searches. (The
1483 : * most frequently accessed elements in any hashbucket will tend to be
1484 : * near the front of the hashbucket's list.)
1485 : */
1486 62808185 : dlist_move_head(bucket, &ct->cache_elem);
1487 :
1488 : /*
1489 : * If it's a positive entry, bump its refcount and return it. If it's
1490 : * negative, we can report failure to the caller.
1491 : */
1492 62808185 : if (!ct->negative)
1493 : {
1494 59371680 : ResourceOwnerEnlarge(CurrentResourceOwner);
1495 59371680 : ct->refcount++;
1496 59371680 : ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple);
1497 :
1498 : CACHE_elog(DEBUG2, "SearchCatCache(%s): found in bucket %d",
1499 : cache->cc_relname, hashIndex);
1500 :
1501 : #ifdef CATCACHE_STATS
1502 : cache->cc_hits++;
1503 : #endif
1504 :
1505 59371680 : return &ct->tuple;
1506 : }
1507 : else
1508 : {
1509 : CACHE_elog(DEBUG2, "SearchCatCache(%s): found neg entry in bucket %d",
1510 : cache->cc_relname, hashIndex);
1511 :
1512 : #ifdef CATCACHE_STATS
1513 : cache->cc_neg_hits++;
1514 : #endif
1515 :
1516 3436505 : return NULL;
1517 : }
1518 : }
1519 :
1520 4271870 : return SearchCatCacheMiss(cache, nkeys, hashValue, hashIndex, v1, v2, v3, v4);
1521 : }
1522 :
1523 : /*
1524 : * Search the actual catalogs, rather than the cache.
1525 : *
1526 : * This is kept separate from SearchCatCacheInternal() to keep the fast-path
1527 : * as small as possible. To avoid that effort being undone by a helpful
1528 : * compiler, try to explicitly forbid inlining.
1529 : */
1530 : static pg_noinline HeapTuple
1531 4271870 : SearchCatCacheMiss(CatCache *cache,
1532 : int nkeys,
1533 : uint32 hashValue,
1534 : Index hashIndex,
1535 : Datum v1,
1536 : Datum v2,
1537 : Datum v3,
1538 : Datum v4)
1539 : {
1540 : ScanKeyData cur_skey[CATCACHE_MAXKEYS];
1541 : Relation relation;
1542 : SysScanDesc scandesc;
1543 : HeapTuple ntp;
1544 : CatCTup *ct;
1545 : bool stale;
1546 : Datum arguments[CATCACHE_MAXKEYS];
1547 :
1548 : /* Initialize local parameter array */
1549 4271870 : arguments[0] = v1;
1550 4271870 : arguments[1] = v2;
1551 4271870 : arguments[2] = v3;
1552 4271870 : arguments[3] = v4;
1553 :
1554 : /*
1555 : * Tuple was not found in cache, so we have to try to retrieve it directly
1556 : * from the relation. If found, we will add it to the cache; if not
1557 : * found, we will add a negative cache entry instead.
1558 : *
1559 : * NOTE: it is possible for recursive cache lookups to occur while reading
1560 : * the relation --- for example, due to shared-cache-inval messages being
1561 : * processed during table_open(). This is OK. It's even possible for one
1562 : * of those lookups to find and enter the very same tuple we are trying to
1563 : * fetch here. If that happens, we will enter a second copy of the tuple
1564 : * into the cache. The first copy will never be referenced again, and
1565 : * will eventually age out of the cache, so there's no functional problem.
1566 : * This case is rare enough that it's not worth expending extra cycles to
1567 : * detect.
1568 : *
1569 : * Another case, which we *must* handle, is that the tuple could become
1570 : * outdated during CatalogCacheCreateEntry's attempt to detoast it (since
1571 : * AcceptInvalidationMessages can run during TOAST table access). We do
1572 : * not want to return already-stale catcache entries, so we loop around
1573 : * and do the table scan again if that happens.
1574 : */
1575 4271870 : relation = table_open(cache->cc_reloid, AccessShareLock);
1576 :
1577 : /*
1578 : * Ok, need to make a lookup in the relation, copy the scankey and fill
1579 : * out any per-call fields.
1580 : */
1581 4271870 : memcpy(cur_skey, cache->cc_skey, sizeof(ScanKeyData) * nkeys);
1582 4271870 : cur_skey[0].sk_argument = v1;
1583 4271870 : cur_skey[1].sk_argument = v2;
1584 4271870 : cur_skey[2].sk_argument = v3;
1585 4271870 : cur_skey[3].sk_argument = v4;
1586 :
1587 : do
1588 : {
1589 4271870 : scandesc = systable_beginscan(relation,
1590 : cache->cc_indexoid,
1591 4271870 : IndexScanOK(cache),
1592 : NULL,
1593 : nkeys,
1594 : cur_skey);
1595 :
1596 4271870 : ct = NULL;
1597 4271870 : stale = false;
1598 :
1599 4271870 : while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
1600 : {
1601 3169004 : ct = CatalogCacheCreateEntry(cache, ntp, NULL,
1602 : hashValue, hashIndex);
1603 : /* upon failure, we must start the scan over */
1604 3169004 : if (ct == NULL)
1605 : {
1606 0 : stale = true;
1607 0 : break;
1608 : }
1609 : /* immediately set the refcount to 1 */
1610 3169004 : ResourceOwnerEnlarge(CurrentResourceOwner);
1611 3169004 : ct->refcount++;
1612 3169004 : ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple);
1613 3169004 : break; /* assume only one match */
1614 : }
1615 :
1616 4271870 : systable_endscan(scandesc);
1617 4271870 : } while (stale);
1618 :
1619 4271870 : table_close(relation, AccessShareLock);
1620 :
1621 : /*
1622 : * If tuple was not found, we need to build a negative cache entry
1623 : * containing a fake tuple. The fake tuple has the correct key columns,
1624 : * but nulls everywhere else.
1625 : *
1626 : * In bootstrap mode, we don't build negative entries, because the cache
1627 : * invalidation mechanism isn't alive and can't clear them if the tuple
1628 : * gets created later. (Bootstrap doesn't do UPDATEs, so it doesn't need
1629 : * cache inval for that.)
1630 : */
1631 4271870 : if (ct == NULL)
1632 : {
1633 1102866 : if (IsBootstrapProcessingMode())
1634 33174 : return NULL;
1635 :
1636 1069692 : ct = CatalogCacheCreateEntry(cache, NULL, arguments,
1637 : hashValue, hashIndex);
1638 :
1639 : /* Creating a negative cache entry shouldn't fail */
1640 : Assert(ct != NULL);
1641 :
1642 : CACHE_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",
1643 : cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup);
1644 : CACHE_elog(DEBUG2, "SearchCatCache(%s): put neg entry in bucket %d",
1645 : cache->cc_relname, hashIndex);
1646 :
1647 : /*
1648 : * We are not returning the negative entry to the caller, so leave its
1649 : * refcount zero.
1650 : */
1651 :
1652 1069692 : return NULL;
1653 : }
1654 :
1655 : CACHE_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",
1656 : cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup);
1657 : CACHE_elog(DEBUG2, "SearchCatCache(%s): put in bucket %d",
1658 : cache->cc_relname, hashIndex);
1659 :
1660 : #ifdef CATCACHE_STATS
1661 : cache->cc_newloads++;
1662 : #endif
1663 :
1664 3169004 : return &ct->tuple;
1665 : }
1666 :
1667 : /*
1668 : * ReleaseCatCache
1669 : *
1670 : * Decrement the reference count of a catcache entry (releasing the
1671 : * hold grabbed by a successful SearchCatCache).
1672 : *
1673 : * NOTE: if compiled with -DCATCACHE_FORCE_RELEASE then catcache entries
1674 : * will be freed as soon as their refcount goes to zero. In combination
1675 : * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
1676 : * to catch references to already-released catcache entries.
1677 : */
1678 : void
1679 62533003 : ReleaseCatCache(HeapTuple tuple)
1680 : {
1681 62533003 : ReleaseCatCacheWithOwner(tuple, CurrentResourceOwner);
1682 62533003 : }
1683 :
1684 : static void
1685 62540684 : ReleaseCatCacheWithOwner(HeapTuple tuple, ResourceOwner resowner)
1686 : {
1687 62540684 : CatCTup *ct = (CatCTup *) (((char *) tuple) -
1688 : offsetof(CatCTup, tuple));
1689 :
1690 : /* Safety checks to ensure we were handed a cache entry */
1691 : Assert(ct->ct_magic == CT_MAGIC);
1692 : Assert(ct->refcount > 0);
1693 :
1694 62540684 : ct->refcount--;
1695 62540684 : if (resowner)
1696 62533003 : ResourceOwnerForgetCatCacheRef(resowner, &ct->tuple);
1697 :
1698 62540684 : if (
1699 : #ifndef CATCACHE_FORCE_RELEASE
1700 62540684 : ct->dead &&
1701 : #endif
1702 937 : ct->refcount == 0 &&
1703 868 : (ct->c_list == NULL || ct->c_list->refcount == 0))
1704 868 : CatCacheRemoveCTup(ct->my_cache, ct);
1705 62540684 : }
1706 :
1707 :
1708 : /*
1709 : * GetCatCacheHashValue
1710 : *
1711 : * Compute the hash value for a given set of search keys.
1712 : *
1713 : * The reason for exposing this as part of the API is that the hash value is
1714 : * exposed in cache invalidation operations, so there are places outside the
1715 : * catcache code that need to be able to compute the hash values.
1716 : */
1717 : uint32
1718 776808 : GetCatCacheHashValue(CatCache *cache,
1719 : Datum v1,
1720 : Datum v2,
1721 : Datum v3,
1722 : Datum v4)
1723 : {
1724 : /*
1725 : * one-time startup overhead for each cache
1726 : */
1727 776808 : ConditionalCatalogCacheInitializeCache(cache);
1728 :
1729 : /*
1730 : * calculate the hash value
1731 : */
1732 776808 : return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, v1, v2, v3, v4);
1733 : }
1734 :
1735 :
1736 : /*
1737 : * SearchCatCacheList
1738 : *
1739 : * Generate a list of all tuples matching a partial key (that is,
1740 : * a key specifying just the first K of the cache's N key columns).
1741 : *
1742 : * It doesn't make any sense to specify all of the cache's key columns
1743 : * here: since the key is unique, there could be at most one match, so
1744 : * you ought to use SearchCatCache() instead. Hence this function takes
1745 : * one fewer Datum argument than SearchCatCache() does.
1746 : *
1747 : * The caller must not modify the list object or the pointed-to tuples,
1748 : * and must call ReleaseCatCacheList() when done with the list.
1749 : */
1750 : CatCList *
1751 3015943 : SearchCatCacheList(CatCache *cache,
1752 : int nkeys,
1753 : Datum v1,
1754 : Datum v2,
1755 : Datum v3)
1756 : {
1757 3015943 : Datum v4 = 0; /* dummy last-column value */
1758 : Datum arguments[CATCACHE_MAXKEYS];
1759 : uint32 lHashValue;
1760 : Index lHashIndex;
1761 : dlist_iter iter;
1762 : dlist_head *lbucket;
1763 : CatCList *cl;
1764 : CatCTup *ct;
1765 : List *volatile ctlist;
1766 : ListCell *ctlist_item;
1767 : int nmembers;
1768 : bool ordered;
1769 : HeapTuple ntp;
1770 : MemoryContext oldcxt;
1771 : int i;
1772 : CatCInProgress *save_in_progress;
1773 : CatCInProgress in_progress_ent;
1774 :
1775 : /*
1776 : * one-time startup overhead for each cache
1777 : */
1778 3015943 : ConditionalCatalogCacheInitializeCache(cache);
1779 :
1780 : Assert(nkeys > 0 && nkeys < cache->cc_nkeys);
1781 :
1782 : #ifdef CATCACHE_STATS
1783 : cache->cc_lsearches++;
1784 : #endif
1785 :
1786 : /* Initialize local parameter array */
1787 3015943 : arguments[0] = v1;
1788 3015943 : arguments[1] = v2;
1789 3015943 : arguments[2] = v3;
1790 3015943 : arguments[3] = v4;
1791 :
1792 : /*
1793 : * If we haven't previously done a list search in this cache, create the
1794 : * bucket header array; otherwise, consider whether it's time to enlarge
1795 : * it.
1796 : */
1797 3015943 : if (cache->cc_lbucket == NULL)
1798 : {
1799 : /* Arbitrary initial size --- must be a power of 2 */
1800 23935 : int nbuckets = 16;
1801 :
1802 23935 : cache->cc_lbucket = (dlist_head *)
1803 23935 : MemoryContextAllocZero(CacheMemoryContext,
1804 : nbuckets * sizeof(dlist_head));
1805 : /* Don't set cc_nlbuckets if we get OOM allocating cc_lbucket */
1806 23935 : cache->cc_nlbuckets = nbuckets;
1807 : }
1808 : else
1809 : {
1810 : /*
1811 : * If the hash table has become too full, enlarge the buckets array.
1812 : * Quite arbitrarily, we enlarge when fill factor > 2.
1813 : */
1814 2992008 : if (cache->cc_nlist > cache->cc_nlbuckets * 2)
1815 805 : RehashCatCacheLists(cache);
1816 : }
1817 :
1818 : /*
1819 : * Find the hash bucket in which to look for the CatCList.
1820 : */
1821 3015943 : lHashValue = CatalogCacheComputeHashValue(cache, nkeys, v1, v2, v3, v4);
1822 3015943 : lHashIndex = HASH_INDEX(lHashValue, cache->cc_nlbuckets);
1823 :
1824 : /*
1825 : * scan the items until we find a match or exhaust our list
1826 : *
1827 : * Note: it's okay to use dlist_foreach here, even though we modify the
1828 : * dlist within the loop, because we don't continue the loop afterwards.
1829 : */
1830 3015943 : lbucket = &cache->cc_lbucket[lHashIndex];
1831 3277964 : dlist_foreach(iter, lbucket)
1832 : {
1833 3082365 : cl = dlist_container(CatCList, cache_elem, iter.cur);
1834 :
1835 3082365 : if (cl->dead)
1836 0 : continue; /* ignore dead entries */
1837 :
1838 3082365 : if (cl->hash_value != lHashValue)
1839 262021 : continue; /* quickly skip entry if wrong hash val */
1840 :
1841 : /*
1842 : * see if the cached list matches our key.
1843 : */
1844 2820344 : if (cl->nkeys != nkeys)
1845 0 : continue;
1846 :
1847 2820344 : if (!CatalogCacheCompareTuple(cache, nkeys, cl->keys, arguments))
1848 0 : continue;
1849 :
1850 : /*
1851 : * We found a matching list. Move the list to the front of the list
1852 : * for its hashbucket, so as to speed subsequent searches. (We do not
1853 : * move the members to the fronts of their hashbucket lists, however,
1854 : * since there's no point in that unless they are searched for
1855 : * individually.)
1856 : */
1857 2820344 : dlist_move_head(lbucket, &cl->cache_elem);
1858 :
1859 : /* Bump the list's refcount and return it */
1860 2820344 : ResourceOwnerEnlarge(CurrentResourceOwner);
1861 2820344 : cl->refcount++;
1862 2820344 : ResourceOwnerRememberCatCacheListRef(CurrentResourceOwner, cl);
1863 :
1864 : CACHE_elog(DEBUG2, "SearchCatCacheList(%s): found list",
1865 : cache->cc_relname);
1866 :
1867 : #ifdef CATCACHE_STATS
1868 : cache->cc_lhits++;
1869 : #endif
1870 :
1871 2820344 : return cl;
1872 : }
1873 :
1874 : /*
1875 : * List was not found in cache, so we have to build it by reading the
1876 : * relation. For each matching tuple found in the relation, use an
1877 : * existing cache entry if possible, else build a new one.
1878 : *
1879 : * We have to bump the member refcounts temporarily to ensure they won't
1880 : * get dropped from the cache while loading other members. We use a PG_TRY
1881 : * block to ensure we can undo those refcounts if we get an error before
1882 : * we finish constructing the CatCList. ctlist must be valid throughout
1883 : * the PG_TRY block.
1884 : */
1885 195599 : ctlist = NIL;
1886 :
1887 : /*
1888 : * Cache invalidation can happen while we're building the list.
1889 : * CatalogCacheCreateEntry() handles concurrent invalidation of individual
1890 : * tuples, but it's also possible that a new entry is concurrently added
1891 : * that should be part of the list we're building. Register an
1892 : * "in-progress" entry that will receive the invalidation, until we have
1893 : * built the final list entry.
1894 : */
1895 195599 : save_in_progress = catcache_in_progress_stack;
1896 195599 : in_progress_ent.next = catcache_in_progress_stack;
1897 195599 : in_progress_ent.cache = cache;
1898 195599 : in_progress_ent.hash_value = lHashValue;
1899 195599 : in_progress_ent.list = true;
1900 195599 : in_progress_ent.dead = false;
1901 195599 : catcache_in_progress_stack = &in_progress_ent;
1902 :
1903 195599 : PG_TRY();
1904 : {
1905 : ScanKeyData cur_skey[CATCACHE_MAXKEYS];
1906 : Relation relation;
1907 : SysScanDesc scandesc;
1908 195599 : bool first_iter = true;
1909 :
1910 195599 : relation = table_open(cache->cc_reloid, AccessShareLock);
1911 :
1912 : /*
1913 : * Ok, need to make a lookup in the relation, copy the scankey and
1914 : * fill out any per-call fields.
1915 : */
1916 195599 : memcpy(cur_skey, cache->cc_skey, sizeof(ScanKeyData) * cache->cc_nkeys);
1917 195599 : cur_skey[0].sk_argument = v1;
1918 195599 : cur_skey[1].sk_argument = v2;
1919 195599 : cur_skey[2].sk_argument = v3;
1920 195599 : cur_skey[3].sk_argument = v4;
1921 :
1922 : /*
1923 : * Scan the table for matching entries. If an invalidation arrives
1924 : * mid-build, we will loop back here to retry.
1925 : */
1926 : do
1927 : {
1928 : /*
1929 : * If we are retrying, release refcounts on any items created on
1930 : * the previous iteration. We dare not try to free them if
1931 : * they're now unreferenced, since an error while doing that would
1932 : * result in the PG_CATCH below doing extra refcount decrements.
1933 : * Besides, we'll likely re-adopt those items in the next
1934 : * iteration, so it's not worth complicating matters to try to get
1935 : * rid of them.
1936 : */
1937 195605 : foreach(ctlist_item, ctlist)
1938 : {
1939 1 : ct = (CatCTup *) lfirst(ctlist_item);
1940 : Assert(ct->c_list == NULL);
1941 : Assert(ct->refcount > 0);
1942 1 : ct->refcount--;
1943 : }
1944 : /* Reset ctlist in preparation for new try */
1945 195604 : ctlist = NIL;
1946 195604 : in_progress_ent.dead = false;
1947 :
1948 391208 : scandesc = systable_beginscan(relation,
1949 : cache->cc_indexoid,
1950 195604 : IndexScanOK(cache),
1951 : NULL,
1952 : nkeys,
1953 : cur_skey);
1954 :
1955 : /* The list will be ordered iff we are doing an index scan */
1956 195604 : ordered = (scandesc->irel != NULL);
1957 :
1958 : /* Injection point to help testing the recursive invalidation case */
1959 195604 : if (first_iter)
1960 : {
1961 195599 : INJECTION_POINT("catcache-list-miss-systable-scan-started", NULL);
1962 195599 : first_iter = false;
1963 : }
1964 :
1965 817236 : while (HeapTupleIsValid(ntp = systable_getnext(scandesc)) &&
1966 621636 : !in_progress_ent.dead)
1967 : {
1968 : uint32 hashValue;
1969 : Index hashIndex;
1970 621632 : bool found = false;
1971 : dlist_head *bucket;
1972 :
1973 : /*
1974 : * See if there's an entry for this tuple already.
1975 : */
1976 621632 : ct = NULL;
1977 621632 : hashValue = CatalogCacheComputeTupleHashValue(cache, cache->cc_nkeys, ntp);
1978 621632 : hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
1979 :
1980 621632 : bucket = &cache->cc_bucket[hashIndex];
1981 863375 : dlist_foreach(iter, bucket)
1982 : {
1983 352399 : ct = dlist_container(CatCTup, cache_elem, iter.cur);
1984 :
1985 352399 : if (ct->dead || ct->negative)
1986 618 : continue; /* ignore dead and negative entries */
1987 :
1988 351781 : if (ct->hash_value != hashValue)
1989 228704 : continue; /* quickly skip entry if wrong hash val */
1990 :
1991 123077 : if (!ItemPointerEquals(&(ct->tuple.t_self), &(ntp->t_self)))
1992 0 : continue; /* not same tuple */
1993 :
1994 : /*
1995 : * Found a match, but can't use it if it belongs to
1996 : * another list already
1997 : */
1998 123077 : if (ct->c_list)
1999 12421 : continue;
2000 :
2001 110656 : found = true;
2002 110656 : break; /* A-OK */
2003 : }
2004 :
2005 621632 : if (!found)
2006 : {
2007 : /* We didn't find a usable entry, so make a new one */
2008 510976 : ct = CatalogCacheCreateEntry(cache, ntp, NULL,
2009 : hashValue, hashIndex);
2010 :
2011 : /* upon failure, we must start the scan over */
2012 510976 : if (ct == NULL)
2013 : {
2014 0 : in_progress_ent.dead = true;
2015 0 : break;
2016 : }
2017 : }
2018 :
2019 : /* Careful here: add entry to ctlist, then bump its refcount */
2020 : /* This way leaves state correct if lappend runs out of memory */
2021 621632 : ctlist = lappend(ctlist, ct);
2022 621632 : ct->refcount++;
2023 : }
2024 :
2025 195604 : systable_endscan(scandesc);
2026 195604 : } while (in_progress_ent.dead);
2027 :
2028 195599 : table_close(relation, AccessShareLock);
2029 :
2030 : /* Make sure the resource owner has room to remember this entry. */
2031 195599 : ResourceOwnerEnlarge(CurrentResourceOwner);
2032 :
2033 : /* Now we can build the CatCList entry. */
2034 195599 : oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
2035 195599 : nmembers = list_length(ctlist);
2036 : cl = (CatCList *)
2037 195599 : palloc(offsetof(CatCList, members) + nmembers * sizeof(CatCTup *));
2038 :
2039 : /* Extract key values */
2040 195599 : CatCacheCopyKeys(cache->cc_tupdesc, nkeys, cache->cc_keyno,
2041 195599 : arguments, cl->keys);
2042 195599 : MemoryContextSwitchTo(oldcxt);
2043 :
2044 : /*
2045 : * We are now past the last thing that could trigger an elog before we
2046 : * have finished building the CatCList and remembering it in the
2047 : * resource owner. So it's OK to fall out of the PG_TRY, and indeed
2048 : * we'd better do so before we start marking the members as belonging
2049 : * to the list.
2050 : */
2051 : }
2052 0 : PG_CATCH();
2053 : {
2054 : Assert(catcache_in_progress_stack == &in_progress_ent);
2055 0 : catcache_in_progress_stack = save_in_progress;
2056 :
2057 0 : foreach(ctlist_item, ctlist)
2058 : {
2059 0 : ct = (CatCTup *) lfirst(ctlist_item);
2060 : Assert(ct->c_list == NULL);
2061 : Assert(ct->refcount > 0);
2062 0 : ct->refcount--;
2063 0 : if (
2064 : #ifndef CATCACHE_FORCE_RELEASE
2065 0 : ct->dead &&
2066 : #endif
2067 0 : ct->refcount == 0 &&
2068 0 : (ct->c_list == NULL || ct->c_list->refcount == 0))
2069 0 : CatCacheRemoveCTup(cache, ct);
2070 : }
2071 :
2072 0 : PG_RE_THROW();
2073 : }
2074 195599 : PG_END_TRY();
2075 : Assert(catcache_in_progress_stack == &in_progress_ent);
2076 195599 : catcache_in_progress_stack = save_in_progress;
2077 :
2078 195599 : cl->cl_magic = CL_MAGIC;
2079 195599 : cl->my_cache = cache;
2080 195599 : cl->refcount = 0; /* for the moment */
2081 195599 : cl->dead = false;
2082 195599 : cl->ordered = ordered;
2083 195599 : cl->nkeys = nkeys;
2084 195599 : cl->hash_value = lHashValue;
2085 195599 : cl->n_members = nmembers;
2086 :
2087 195599 : i = 0;
2088 817230 : foreach(ctlist_item, ctlist)
2089 : {
2090 621631 : cl->members[i++] = ct = (CatCTup *) lfirst(ctlist_item);
2091 : Assert(ct->c_list == NULL);
2092 621631 : ct->c_list = cl;
2093 : /* release the temporary refcount on the member */
2094 : Assert(ct->refcount > 0);
2095 621631 : ct->refcount--;
2096 : /* mark list dead if any members already dead */
2097 621631 : if (ct->dead)
2098 0 : cl->dead = true;
2099 : }
2100 : Assert(i == nmembers);
2101 :
2102 : /*
2103 : * Add the CatCList to the appropriate bucket, and count it.
2104 : */
2105 195599 : dlist_push_head(lbucket, &cl->cache_elem);
2106 :
2107 195599 : cache->cc_nlist++;
2108 :
2109 : /* Finally, bump the list's refcount and return it */
2110 195599 : cl->refcount++;
2111 195599 : ResourceOwnerRememberCatCacheListRef(CurrentResourceOwner, cl);
2112 :
2113 : CACHE_elog(DEBUG2, "SearchCatCacheList(%s): made list of %d members",
2114 : cache->cc_relname, nmembers);
2115 :
2116 195599 : return cl;
2117 : }
2118 :
2119 : /*
2120 : * ReleaseCatCacheList
2121 : *
2122 : * Decrement the reference count of a catcache list.
2123 : */
2124 : void
2125 3015919 : ReleaseCatCacheList(CatCList *list)
2126 : {
2127 3015919 : ReleaseCatCacheListWithOwner(list, CurrentResourceOwner);
2128 3015919 : }
2129 :
2130 : static void
2131 3015943 : ReleaseCatCacheListWithOwner(CatCList *list, ResourceOwner resowner)
2132 : {
2133 : /* Safety checks to ensure we were handed a cache entry */
2134 : Assert(list->cl_magic == CL_MAGIC);
2135 : Assert(list->refcount > 0);
2136 3015943 : list->refcount--;
2137 3015943 : if (resowner)
2138 3015919 : ResourceOwnerForgetCatCacheListRef(resowner, list);
2139 :
2140 3015943 : if (
2141 : #ifndef CATCACHE_FORCE_RELEASE
2142 3015943 : list->dead &&
2143 : #endif
2144 4 : list->refcount == 0)
2145 4 : CatCacheRemoveCList(list->my_cache, list);
2146 3015943 : }
2147 :
2148 :
2149 : /*
2150 : * CatalogCacheCreateEntry
2151 : * Create a new CatCTup entry, copying the given HeapTuple and other
2152 : * supplied data into it. The new entry initially has refcount 0.
2153 : *
2154 : * To create a normal cache entry, ntp must be the HeapTuple just fetched
2155 : * from scandesc, and "arguments" is not used. To create a negative cache
2156 : * entry, pass NULL for ntp; then "arguments" is the cache keys to use.
2157 : * In either case, hashValue/hashIndex are the hash values computed from
2158 : * the cache keys.
2159 : *
2160 : * Returns NULL if we attempt to detoast the tuple and observe that it
2161 : * became stale. (This cannot happen for a negative entry.) Caller must
2162 : * retry the tuple lookup in that case.
2163 : */
2164 : static CatCTup *
2165 4749672 : CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, Datum *arguments,
2166 : uint32 hashValue, Index hashIndex)
2167 : {
2168 : CatCTup *ct;
2169 : MemoryContext oldcxt;
2170 :
2171 4749672 : if (ntp)
2172 : {
2173 : int i;
2174 3679980 : HeapTuple dtp = NULL;
2175 :
2176 : /*
2177 : * The invalidation of the in-progress entry essentially never happens
2178 : * during our regression tests, and there's no easy way to force it to
2179 : * fail for testing purposes. To ensure we have test coverage for the
2180 : * retry paths in our callers, make debug builds randomly fail about
2181 : * 0.1% of the times through this code path, even when there's no
2182 : * toasted fields.
2183 : */
2184 : #ifdef USE_ASSERT_CHECKING
2185 : if (pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 1000))
2186 : return NULL;
2187 : #endif
2188 :
2189 : /*
2190 : * If there are any out-of-line toasted fields in the tuple, expand
2191 : * them in-line. This saves cycles during later use of the catcache
2192 : * entry, and also protects us against the possibility of the toast
2193 : * tuples being freed before we attempt to fetch them, in case of
2194 : * something using a slightly stale catcache entry.
2195 : */
2196 3679980 : if (HeapTupleHasExternal(ntp))
2197 : {
2198 : CatCInProgress *save_in_progress;
2199 : CatCInProgress in_progress_ent;
2200 :
2201 : /*
2202 : * The tuple could become stale while we are doing toast table
2203 : * access (since AcceptInvalidationMessages can run then). The
2204 : * invalidation will mark our in-progress entry as dead.
2205 : */
2206 3845 : save_in_progress = catcache_in_progress_stack;
2207 3845 : in_progress_ent.next = catcache_in_progress_stack;
2208 3845 : in_progress_ent.cache = cache;
2209 3845 : in_progress_ent.hash_value = hashValue;
2210 3845 : in_progress_ent.list = false;
2211 3845 : in_progress_ent.dead = false;
2212 3845 : catcache_in_progress_stack = &in_progress_ent;
2213 :
2214 3845 : PG_TRY();
2215 : {
2216 3845 : dtp = toast_flatten_tuple(ntp, cache->cc_tupdesc);
2217 : }
2218 0 : PG_FINALLY();
2219 : {
2220 : Assert(catcache_in_progress_stack == &in_progress_ent);
2221 3845 : catcache_in_progress_stack = save_in_progress;
2222 : }
2223 3845 : PG_END_TRY();
2224 :
2225 3845 : if (in_progress_ent.dead)
2226 : {
2227 0 : heap_freetuple(dtp);
2228 0 : return NULL;
2229 : }
2230 : }
2231 : else
2232 3676135 : dtp = ntp;
2233 :
2234 : /* Allocate memory for CatCTup and the cached tuple in one go */
2235 : ct = (CatCTup *)
2236 7359960 : MemoryContextAlloc(CacheMemoryContext,
2237 3679980 : MAXALIGN(sizeof(CatCTup)) + dtp->t_len);
2238 3679980 : ct->tuple.t_len = dtp->t_len;
2239 3679980 : ct->tuple.t_self = dtp->t_self;
2240 3679980 : ct->tuple.t_tableOid = dtp->t_tableOid;
2241 3679980 : ct->tuple.t_data = (HeapTupleHeader)
2242 : (((char *) ct) + MAXALIGN(sizeof(CatCTup)));
2243 : /* copy tuple contents */
2244 3679980 : memcpy((char *) ct->tuple.t_data,
2245 3679980 : (const char *) dtp->t_data,
2246 3679980 : dtp->t_len);
2247 :
2248 3679980 : if (dtp != ntp)
2249 3845 : heap_freetuple(dtp);
2250 :
2251 : /* extract keys - they'll point into the tuple if not by-value */
2252 10601101 : for (i = 0; i < cache->cc_nkeys; i++)
2253 : {
2254 : Datum atp;
2255 : bool isnull;
2256 :
2257 6921121 : atp = heap_getattr(&ct->tuple,
2258 : cache->cc_keyno[i],
2259 : cache->cc_tupdesc,
2260 : &isnull);
2261 : Assert(!isnull);
2262 6921121 : ct->keys[i] = atp;
2263 : }
2264 : }
2265 : else
2266 : {
2267 : /* Set up keys for a negative cache entry */
2268 1069692 : oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
2269 1069692 : ct = palloc_object(CatCTup);
2270 :
2271 : /*
2272 : * Store keys - they'll point into separately allocated memory if not
2273 : * by-value.
2274 : */
2275 1069692 : CatCacheCopyKeys(cache->cc_tupdesc, cache->cc_nkeys, cache->cc_keyno,
2276 1069692 : arguments, ct->keys);
2277 1069692 : MemoryContextSwitchTo(oldcxt);
2278 : }
2279 :
2280 : /*
2281 : * Finish initializing the CatCTup header, and add it to the cache's
2282 : * linked list and counts.
2283 : */
2284 4749672 : ct->ct_magic = CT_MAGIC;
2285 4749672 : ct->my_cache = cache;
2286 4749672 : ct->c_list = NULL;
2287 4749672 : ct->refcount = 0; /* for the moment */
2288 4749672 : ct->dead = false;
2289 4749672 : ct->negative = (ntp == NULL);
2290 4749672 : ct->hash_value = hashValue;
2291 :
2292 4749672 : dlist_push_head(&cache->cc_bucket[hashIndex], &ct->cache_elem);
2293 :
2294 4749672 : cache->cc_ntup++;
2295 4749672 : CacheHdr->ch_ntup++;
2296 :
2297 : /*
2298 : * If the hash table has become too full, enlarge the buckets array. Quite
2299 : * arbitrarily, we enlarge when fill factor > 2.
2300 : */
2301 4749672 : if (cache->cc_ntup > cache->cc_nbuckets * 2)
2302 4505 : RehashCatCache(cache);
2303 :
2304 4749672 : return ct;
2305 : }
2306 :
2307 : /*
2308 : * Helper routine that frees keys stored in the keys array.
2309 : */
2310 : static void
2311 385524 : CatCacheFreeKeys(TupleDesc tupdesc, int nkeys, const int *attnos, const Datum *keys)
2312 : {
2313 : int i;
2314 :
2315 1182548 : for (i = 0; i < nkeys; i++)
2316 : {
2317 797024 : int attnum = attnos[i];
2318 :
2319 : /* system attribute are not supported in caches */
2320 : Assert(attnum > 0);
2321 :
2322 797024 : if (!TupleDescCompactAttr(tupdesc, attnum - 1)->attbyval)
2323 339462 : pfree(DatumGetPointer(keys[i]));
2324 : }
2325 385524 : }
2326 :
2327 : /*
2328 : * Helper routine that copies the keys in the srckeys array into the dstkeys
2329 : * one, guaranteeing that the datums are fully allocated in the current memory
2330 : * context.
2331 : */
2332 : static void
2333 1265291 : CatCacheCopyKeys(TupleDesc tupdesc, int nkeys, const int *attnos,
2334 : const Datum *srckeys, Datum *dstkeys)
2335 : {
2336 : int i;
2337 :
2338 : /*
2339 : * XXX: memory and lookup performance could possibly be improved by
2340 : * storing all keys in one allocation.
2341 : */
2342 :
2343 3959551 : for (i = 0; i < nkeys; i++)
2344 : {
2345 2694260 : int attnum = attnos[i];
2346 2694260 : Form_pg_attribute att = TupleDescAttr(tupdesc, attnum - 1);
2347 2694260 : Datum src = srckeys[i];
2348 : NameData srcname;
2349 :
2350 : /*
2351 : * Must be careful in case the caller passed a C string where a NAME
2352 : * is wanted: convert the given argument to a correctly padded NAME.
2353 : * Otherwise the memcpy() done by datumCopy() could fall off the end
2354 : * of memory.
2355 : */
2356 2694260 : if (att->atttypid == NAMEOID)
2357 : {
2358 557775 : namestrcpy(&srcname, DatumGetCString(src));
2359 557775 : src = NameGetDatum(&srcname);
2360 : }
2361 :
2362 2694260 : dstkeys[i] = datumCopy(src,
2363 2694260 : att->attbyval,
2364 2694260 : att->attlen);
2365 : }
2366 1265291 : }
2367 :
2368 : /*
2369 : * PrepareToInvalidateCacheTuple()
2370 : *
2371 : * This is part of a rather subtle chain of events, so pay attention:
2372 : *
2373 : * When a tuple is inserted or deleted, it cannot be flushed from the
2374 : * catcaches immediately, for reasons explained at the top of cache/inval.c.
2375 : * Instead we have to add entry(s) for the tuple to a list of pending tuple
2376 : * invalidations that will be done at the end of the command or transaction.
2377 : *
2378 : * The lists of tuples that need to be flushed are kept by inval.c. This
2379 : * routine is a helper routine for inval.c. Given a tuple belonging to
2380 : * the specified relation, find all catcaches it could be in, compute the
2381 : * correct hash value for each such catcache, and call the specified
2382 : * function to record the cache id and hash value in inval.c's lists.
2383 : * SysCacheInvalidate will be called later, if appropriate,
2384 : * using the recorded information.
2385 : *
2386 : * For an insert or delete, tuple is the target tuple and newtuple is NULL.
2387 : * For an update, we are called just once, with tuple being the old tuple
2388 : * version and newtuple the new version. We should make two list entries
2389 : * if the tuple's hash value changed, but only one if it didn't.
2390 : *
2391 : * Note that it is irrelevant whether the given tuple is actually loaded
2392 : * into the catcache at the moment. Even if it's not there now, it might
2393 : * be by the end of the command, or there might be a matching negative entry
2394 : * to flush --- or other backends' caches might have such entries --- so
2395 : * we have to make list entries to flush it later.
2396 : *
2397 : * Also note that it's not an error if there are no catcaches for the
2398 : * specified relation. inval.c doesn't know exactly which rels have
2399 : * catcaches --- it will call this routine for any tuple that's in a
2400 : * system relation.
2401 : */
2402 : void
2403 2055241 : PrepareToInvalidateCacheTuple(Relation relation,
2404 : HeapTuple tuple,
2405 : HeapTuple newtuple,
2406 : void (*function) (int, uint32, Oid, void *),
2407 : void *context)
2408 : {
2409 : slist_iter iter;
2410 : Oid reloid;
2411 :
2412 : CACHE_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
2413 :
2414 : /*
2415 : * sanity checks
2416 : */
2417 : Assert(RelationIsValid(relation));
2418 : Assert(HeapTupleIsValid(tuple));
2419 : Assert(function);
2420 : Assert(CacheHdr != NULL);
2421 :
2422 2055241 : reloid = RelationGetRelid(relation);
2423 :
2424 : /* ----------------
2425 : * for each cache
2426 : * if the cache contains tuples from the specified relation
2427 : * compute the tuple's hash value(s) in this cache,
2428 : * and call the passed function to register the information.
2429 : * ----------------
2430 : */
2431 :
2432 193192654 : slist_foreach(iter, &CacheHdr->ch_caches)
2433 : {
2434 191137413 : CatCache *ccp = slist_container(CatCache, cc_next, iter.cur);
2435 : uint32 hashvalue;
2436 : Oid dbid;
2437 :
2438 191137413 : if (ccp->cc_reloid != reloid)
2439 187408402 : continue;
2440 :
2441 : /* Just in case cache hasn't finished initialization yet... */
2442 3729011 : ConditionalCatalogCacheInitializeCache(ccp);
2443 :
2444 3729011 : hashvalue = CatalogCacheComputeTupleHashValue(ccp, ccp->cc_nkeys, tuple);
2445 3729011 : dbid = ccp->cc_relisshared ? (Oid) 0 : MyDatabaseId;
2446 :
2447 3729011 : (*function) (ccp->id, hashvalue, dbid, context);
2448 :
2449 3729011 : if (newtuple)
2450 : {
2451 : uint32 newhashvalue;
2452 :
2453 270407 : newhashvalue = CatalogCacheComputeTupleHashValue(ccp, ccp->cc_nkeys, newtuple);
2454 :
2455 270407 : if (newhashvalue != hashvalue)
2456 4258 : (*function) (ccp->id, newhashvalue, dbid, context);
2457 : }
2458 : }
2459 2055241 : }
2460 :
2461 : /* ResourceOwner callbacks */
2462 :
2463 : static void
2464 7681 : ResOwnerReleaseCatCache(Datum res)
2465 : {
2466 7681 : ReleaseCatCacheWithOwner((HeapTuple) DatumGetPointer(res), NULL);
2467 7681 : }
2468 :
2469 : static char *
2470 0 : ResOwnerPrintCatCache(Datum res)
2471 : {
2472 0 : HeapTuple tuple = (HeapTuple) DatumGetPointer(res);
2473 0 : CatCTup *ct = (CatCTup *) (((char *) tuple) -
2474 : offsetof(CatCTup, tuple));
2475 :
2476 : /* Safety check to ensure we were handed a cache entry */
2477 : Assert(ct->ct_magic == CT_MAGIC);
2478 :
2479 0 : return psprintf("cache %s (%d), tuple %u/%u has count %d",
2480 0 : ct->my_cache->cc_relname, ct->my_cache->id,
2481 0 : ItemPointerGetBlockNumber(&(tuple->t_self)),
2482 0 : ItemPointerGetOffsetNumber(&(tuple->t_self)),
2483 : ct->refcount);
2484 : }
2485 :
2486 : static void
2487 24 : ResOwnerReleaseCatCacheList(Datum res)
2488 : {
2489 24 : ReleaseCatCacheListWithOwner((CatCList *) DatumGetPointer(res), NULL);
2490 24 : }
2491 :
2492 : static char *
2493 0 : ResOwnerPrintCatCacheList(Datum res)
2494 : {
2495 0 : CatCList *list = (CatCList *) DatumGetPointer(res);
2496 :
2497 0 : return psprintf("cache %s (%d), list %p has count %d",
2498 0 : list->my_cache->cc_relname, list->my_cache->id,
2499 : list, list->refcount);
2500 : }
|
