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