PostgreSQL Source Code  git master
relcache.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * relcache.c
4  * POSTGRES relation descriptor cache code
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/utils/cache/relcache.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 /*
16  * INTERFACE ROUTINES
17  * RelationCacheInitialize - initialize relcache (to empty)
18  * RelationCacheInitializePhase2 - initialize shared-catalog entries
19  * RelationCacheInitializePhase3 - finish initializing relcache
20  * RelationIdGetRelation - get a reldesc by relation id
21  * RelationClose - close an open relation
22  *
23  * NOTES
24  * The following code contains many undocumented hacks. Please be
25  * careful....
26  */
27 #include "postgres.h"
28 
29 #include <sys/file.h>
30 #include <fcntl.h>
31 #include <unistd.h>
32 
33 #include "access/htup_details.h"
34 #include "access/multixact.h"
35 #include "access/parallel.h"
36 #include "access/reloptions.h"
37 #include "access/sysattr.h"
38 #include "access/table.h"
39 #include "access/tableam.h"
40 #include "access/tupdesc_details.h"
41 #include "access/xact.h"
42 #include "catalog/binary_upgrade.h"
43 #include "catalog/catalog.h"
44 #include "catalog/indexing.h"
45 #include "catalog/namespace.h"
46 #include "catalog/partition.h"
47 #include "catalog/pg_am.h"
48 #include "catalog/pg_amproc.h"
49 #include "catalog/pg_attrdef.h"
51 #include "catalog/pg_authid.h"
52 #include "catalog/pg_constraint.h"
53 #include "catalog/pg_database.h"
54 #include "catalog/pg_namespace.h"
55 #include "catalog/pg_opclass.h"
56 #include "catalog/pg_proc.h"
57 #include "catalog/pg_publication.h"
58 #include "catalog/pg_rewrite.h"
59 #include "catalog/pg_shseclabel.h"
62 #include "catalog/pg_tablespace.h"
63 #include "catalog/pg_trigger.h"
64 #include "catalog/pg_type.h"
65 #include "catalog/schemapg.h"
66 #include "catalog/storage.h"
67 #include "commands/policy.h"
69 #include "commands/trigger.h"
70 #include "common/int.h"
71 #include "miscadmin.h"
72 #include "nodes/makefuncs.h"
73 #include "nodes/nodeFuncs.h"
74 #include "optimizer/optimizer.h"
75 #include "pgstat.h"
76 #include "rewrite/rewriteDefine.h"
77 #include "rewrite/rowsecurity.h"
78 #include "storage/lmgr.h"
79 #include "storage/smgr.h"
80 #include "utils/array.h"
81 #include "utils/builtins.h"
82 #include "utils/catcache.h"
83 #include "utils/datum.h"
84 #include "utils/fmgroids.h"
85 #include "utils/inval.h"
86 #include "utils/lsyscache.h"
87 #include "utils/memutils.h"
88 #include "utils/relmapper.h"
89 #include "utils/resowner.h"
90 #include "utils/snapmgr.h"
91 #include "utils/syscache.h"
92 
93 #define RELCACHE_INIT_FILEMAGIC 0x573266 /* version ID value */
94 
95 /*
96  * Whether to bother checking if relation cache memory needs to be freed
97  * eagerly. See also RelationBuildDesc() and pg_config_manual.h.
98  */
99 #if defined(RECOVER_RELATION_BUILD_MEMORY) && (RECOVER_RELATION_BUILD_MEMORY != 0)
100 #define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
101 #else
102 #define RECOVER_RELATION_BUILD_MEMORY 0
103 #ifdef DISCARD_CACHES_ENABLED
104 #define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
105 #endif
106 #endif
107 
108 /*
109  * hardcoded tuple descriptors, contents generated by genbki.pl
110  */
111 static const FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
112 static const FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
113 static const FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
114 static const FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
115 static const FormData_pg_attribute Desc_pg_database[Natts_pg_database] = {Schema_pg_database};
116 static const FormData_pg_attribute Desc_pg_authid[Natts_pg_authid] = {Schema_pg_authid};
117 static const FormData_pg_attribute Desc_pg_auth_members[Natts_pg_auth_members] = {Schema_pg_auth_members};
118 static const FormData_pg_attribute Desc_pg_index[Natts_pg_index] = {Schema_pg_index};
119 static const FormData_pg_attribute Desc_pg_shseclabel[Natts_pg_shseclabel] = {Schema_pg_shseclabel};
120 static const FormData_pg_attribute Desc_pg_subscription[Natts_pg_subscription] = {Schema_pg_subscription};
121 
122 /*
123  * Hash tables that index the relation cache
124  *
125  * We used to index the cache by both name and OID, but now there
126  * is only an index by OID.
127  */
128 typedef struct relidcacheent
129 {
133 
135 
136 /*
137  * This flag is false until we have prepared the critical relcache entries
138  * that are needed to do indexscans on the tables read by relcache building.
139  */
141 
142 /*
143  * This flag is false until we have prepared the critical relcache entries
144  * for shared catalogs (which are the tables needed for login).
145  */
147 
148 /*
149  * This counter counts relcache inval events received since backend startup
150  * (but only for rels that are actually in cache). Presently, we use it only
151  * to detect whether data about to be written by write_relcache_init_file()
152  * might already be obsolete.
153  */
154 static long relcacheInvalsReceived = 0L;
155 
156 /*
157  * in_progress_list is a stack of ongoing RelationBuildDesc() calls. CREATE
158  * INDEX CONCURRENTLY makes catalog changes under ShareUpdateExclusiveLock.
159  * It critically relies on each backend absorbing those changes no later than
160  * next transaction start. Hence, RelationBuildDesc() loops until it finishes
161  * without accepting a relevant invalidation. (Most invalidation consumers
162  * don't do this.)
163  */
164 typedef struct inprogressent
165 {
166  Oid reloid; /* OID of relation being built */
167  bool invalidated; /* whether an invalidation arrived for it */
169 
173 
174 /*
175  * eoxact_list[] stores the OIDs of relations that (might) need AtEOXact
176  * cleanup work. This list intentionally has limited size; if it overflows,
177  * we fall back to scanning the whole hashtable. There is no value in a very
178  * large list because (1) at some point, a hash_seq_search scan is faster than
179  * retail lookups, and (2) the value of this is to reduce EOXact work for
180  * short transactions, which can't have dirtied all that many tables anyway.
181  * EOXactListAdd() does not bother to prevent duplicate list entries, so the
182  * cleanup processing must be idempotent.
183  */
184 #define MAX_EOXACT_LIST 32
186 static int eoxact_list_len = 0;
187 static bool eoxact_list_overflowed = false;
188 
189 #define EOXactListAdd(rel) \
190  do { \
191  if (eoxact_list_len < MAX_EOXACT_LIST) \
192  eoxact_list[eoxact_list_len++] = (rel)->rd_id; \
193  else \
194  eoxact_list_overflowed = true; \
195  } while (0)
196 
197 /*
198  * EOXactTupleDescArray stores TupleDescs that (might) need AtEOXact
199  * cleanup work. The array expands as needed; there is no hashtable because
200  * we don't need to access individual items except at EOXact.
201  */
203 static int NextEOXactTupleDescNum = 0;
204 static int EOXactTupleDescArrayLen = 0;
205 
206 /*
207  * macros to manipulate the lookup hashtable
208  */
209 #define RelationCacheInsert(RELATION, replace_allowed) \
210 do { \
211  RelIdCacheEnt *hentry; bool found; \
212  hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
213  &((RELATION)->rd_id), \
214  HASH_ENTER, &found); \
215  if (found) \
216  { \
217  /* see comments in RelationBuildDesc and RelationBuildLocalRelation */ \
218  Relation _old_rel = hentry->reldesc; \
219  Assert(replace_allowed); \
220  hentry->reldesc = (RELATION); \
221  if (RelationHasReferenceCountZero(_old_rel)) \
222  RelationDestroyRelation(_old_rel, false); \
223  else if (!IsBootstrapProcessingMode()) \
224  elog(WARNING, "leaking still-referenced relcache entry for \"%s\"", \
225  RelationGetRelationName(_old_rel)); \
226  } \
227  else \
228  hentry->reldesc = (RELATION); \
229 } while(0)
230 
231 #define RelationIdCacheLookup(ID, RELATION) \
232 do { \
233  RelIdCacheEnt *hentry; \
234  hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
235  &(ID), \
236  HASH_FIND, NULL); \
237  if (hentry) \
238  RELATION = hentry->reldesc; \
239  else \
240  RELATION = NULL; \
241 } while(0)
242 
243 #define RelationCacheDelete(RELATION) \
244 do { \
245  RelIdCacheEnt *hentry; \
246  hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
247  &((RELATION)->rd_id), \
248  HASH_REMOVE, NULL); \
249  if (hentry == NULL) \
250  elog(WARNING, "failed to delete relcache entry for OID %u", \
251  (RELATION)->rd_id); \
252 } while(0)
253 
254 
255 /*
256  * Special cache for opclass-related information
257  *
258  * Note: only default support procs get cached, ie, those with
259  * lefttype = righttype = opcintype.
260  */
261 typedef struct opclasscacheent
262 {
263  Oid opclassoid; /* lookup key: OID of opclass */
264  bool valid; /* set true after successful fill-in */
265  StrategyNumber numSupport; /* max # of support procs (from pg_am) */
266  Oid opcfamily; /* OID of opclass's family */
267  Oid opcintype; /* OID of opclass's declared input type */
268  RegProcedure *supportProcs; /* OIDs of support procedures */
270 
271 static HTAB *OpClassCache = NULL;
272 
273 
274 /* non-export function prototypes */
275 
276 static void RelationCloseCleanup(Relation relation);
277 static void RelationDestroyRelation(Relation relation, bool remember_tupdesc);
278 static void RelationClearRelation(Relation relation, bool rebuild);
279 
280 static void RelationReloadIndexInfo(Relation relation);
281 static void RelationReloadNailed(Relation relation);
282 static void RelationFlushRelation(Relation relation);
284 #ifdef USE_ASSERT_CHECKING
285 static void AssertPendingSyncConsistency(Relation relation);
286 #endif
287 static void AtEOXact_cleanup(Relation relation, bool isCommit);
288 static void AtEOSubXact_cleanup(Relation relation, bool isCommit,
289  SubTransactionId mySubid, SubTransactionId parentSubid);
290 static bool load_relcache_init_file(bool shared);
291 static void write_relcache_init_file(bool shared);
292 static void write_item(const void *data, Size len, FILE *fp);
293 
294 static void formrdesc(const char *relationName, Oid relationReltype,
295  bool isshared, int natts, const FormData_pg_attribute *attrs);
296 
297 static HeapTuple ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic);
299 static void RelationParseRelOptions(Relation relation, HeapTuple tuple);
300 static void RelationBuildTupleDesc(Relation relation);
301 static Relation RelationBuildDesc(Oid targetRelId, bool insertIt);
302 static void RelationInitPhysicalAddr(Relation relation);
303 static void load_critical_index(Oid indexoid, Oid heapoid);
304 static TupleDesc GetPgClassDescriptor(void);
305 static TupleDesc GetPgIndexDescriptor(void);
306 static void AttrDefaultFetch(Relation relation, int ndef);
307 static int AttrDefaultCmp(const void *a, const void *b);
308 static void CheckConstraintFetch(Relation relation);
309 static int CheckConstraintCmp(const void *a, const void *b);
310 static void InitIndexAmRoutine(Relation relation);
311 static void IndexSupportInitialize(oidvector *indclass,
312  RegProcedure *indexSupport,
313  Oid *opFamily,
314  Oid *opcInType,
315  StrategyNumber maxSupportNumber,
316  AttrNumber maxAttributeNumber);
317 static OpClassCacheEnt *LookupOpclassInfo(Oid operatorClassOid,
318  StrategyNumber numSupport);
319 static void RelationCacheInitFileRemoveInDir(const char *tblspcpath);
320 static void unlink_initfile(const char *initfilename, int elevel);
321 
322 
323 /*
324  * ScanPgRelation
325  *
326  * This is used by RelationBuildDesc to find a pg_class
327  * tuple matching targetRelId. The caller must hold at least
328  * AccessShareLock on the target relid to prevent concurrent-update
329  * scenarios; it isn't guaranteed that all scans used to build the
330  * relcache entry will use the same snapshot. If, for example,
331  * an attribute were to be added after scanning pg_class and before
332  * scanning pg_attribute, relnatts wouldn't match.
333  *
334  * NB: the returned tuple has been copied into palloc'd storage
335  * and must eventually be freed with heap_freetuple.
336  */
337 static HeapTuple
338 ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic)
339 {
340  HeapTuple pg_class_tuple;
341  Relation pg_class_desc;
342  SysScanDesc pg_class_scan;
343  ScanKeyData key[1];
344  Snapshot snapshot = NULL;
345 
346  /*
347  * If something goes wrong during backend startup, we might find ourselves
348  * trying to read pg_class before we've selected a database. That ain't
349  * gonna work, so bail out with a useful error message. If this happens,
350  * it probably means a relcache entry that needs to be nailed isn't.
351  */
352  if (!OidIsValid(MyDatabaseId))
353  elog(FATAL, "cannot read pg_class without having selected a database");
354 
355  /*
356  * form a scan key
357  */
358  ScanKeyInit(&key[0],
359  Anum_pg_class_oid,
360  BTEqualStrategyNumber, F_OIDEQ,
361  ObjectIdGetDatum(targetRelId));
362 
363  /*
364  * Open pg_class and fetch a tuple. Force heap scan if we haven't yet
365  * built the critical relcache entries (this includes initdb and startup
366  * without a pg_internal.init file). The caller can also force a heap
367  * scan by setting indexOK == false.
368  */
369  pg_class_desc = table_open(RelationRelationId, AccessShareLock);
370 
371  /*
372  * The caller might need a tuple that's newer than the one the historic
373  * snapshot; currently the only case requiring to do so is looking up the
374  * relfilenumber of non mapped system relations during decoding. That
375  * snapshot can't change in the midst of a relcache build, so there's no
376  * need to register the snapshot.
377  */
378  if (force_non_historic)
379  snapshot = GetNonHistoricCatalogSnapshot(RelationRelationId);
380 
381  pg_class_scan = systable_beginscan(pg_class_desc, ClassOidIndexId,
382  indexOK && criticalRelcachesBuilt,
383  snapshot,
384  1, key);
385 
386  pg_class_tuple = systable_getnext(pg_class_scan);
387 
388  /*
389  * Must copy tuple before releasing buffer.
390  */
391  if (HeapTupleIsValid(pg_class_tuple))
392  pg_class_tuple = heap_copytuple(pg_class_tuple);
393 
394  /* all done */
395  systable_endscan(pg_class_scan);
396  table_close(pg_class_desc, AccessShareLock);
397 
398  return pg_class_tuple;
399 }
400 
401 /*
402  * AllocateRelationDesc
403  *
404  * This is used to allocate memory for a new relation descriptor
405  * and initialize the rd_rel field from the given pg_class tuple.
406  */
407 static Relation
409 {
410  Relation relation;
411  MemoryContext oldcxt;
412  Form_pg_class relationForm;
413 
414  /* Relcache entries must live in CacheMemoryContext */
416 
417  /*
418  * allocate and zero space for new relation descriptor
419  */
420  relation = (Relation) palloc0(sizeof(RelationData));
421 
422  /* make sure relation is marked as having no open file yet */
423  relation->rd_smgr = NULL;
424 
425  /*
426  * Copy the relation tuple form
427  *
428  * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. The
429  * variable-length fields (relacl, reloptions) are NOT stored in the
430  * relcache --- there'd be little point in it, since we don't copy the
431  * tuple's nulls bitmap and hence wouldn't know if the values are valid.
432  * Bottom line is that relacl *cannot* be retrieved from the relcache. Get
433  * it from the syscache if you need it. The same goes for the original
434  * form of reloptions (however, we do store the parsed form of reloptions
435  * in rd_options).
436  */
437  relationForm = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
438 
439  memcpy(relationForm, relp, CLASS_TUPLE_SIZE);
440 
441  /* initialize relation tuple form */
442  relation->rd_rel = relationForm;
443 
444  /* and allocate attribute tuple form storage */
445  relation->rd_att = CreateTemplateTupleDesc(relationForm->relnatts);
446  /* which we mark as a reference-counted tupdesc */
447  relation->rd_att->tdrefcount = 1;
448 
449  MemoryContextSwitchTo(oldcxt);
450 
451  return relation;
452 }
453 
454 /*
455  * RelationParseRelOptions
456  * Convert pg_class.reloptions into pre-parsed rd_options
457  *
458  * tuple is the real pg_class tuple (not rd_rel!) for relation
459  *
460  * Note: rd_rel and (if an index) rd_indam must be valid already
461  */
462 static void
464 {
465  bytea *options;
466  amoptions_function amoptsfn;
467 
468  relation->rd_options = NULL;
469 
470  /*
471  * Look up any AM-specific parse function; fall out if relkind should not
472  * have options.
473  */
474  switch (relation->rd_rel->relkind)
475  {
476  case RELKIND_RELATION:
477  case RELKIND_TOASTVALUE:
478  case RELKIND_VIEW:
479  case RELKIND_MATVIEW:
480  case RELKIND_PARTITIONED_TABLE:
481  amoptsfn = NULL;
482  break;
483  case RELKIND_INDEX:
484  case RELKIND_PARTITIONED_INDEX:
485  amoptsfn = relation->rd_indam->amoptions;
486  break;
487  default:
488  return;
489  }
490 
491  /*
492  * Fetch reloptions from tuple; have to use a hardwired descriptor because
493  * we might not have any other for pg_class yet (consider executing this
494  * code for pg_class itself)
495  */
496  options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn);
497 
498  /*
499  * Copy parsed data into CacheMemoryContext. To guard against the
500  * possibility of leaks in the reloptions code, we want to do the actual
501  * parsing in the caller's memory context and copy the results into
502  * CacheMemoryContext after the fact.
503  */
504  if (options)
505  {
507  VARSIZE(options));
508  memcpy(relation->rd_options, options, VARSIZE(options));
509  pfree(options);
510  }
511 }
512 
513 /*
514  * RelationBuildTupleDesc
515  *
516  * Form the relation's tuple descriptor from information in
517  * the pg_attribute, pg_attrdef & pg_constraint system catalogs.
518  */
519 static void
521 {
522  HeapTuple pg_attribute_tuple;
523  Relation pg_attribute_desc;
524  SysScanDesc pg_attribute_scan;
525  ScanKeyData skey[2];
526  int need;
527  TupleConstr *constr;
528  AttrMissing *attrmiss = NULL;
529  int ndef = 0;
530 
531  /* fill rd_att's type ID fields (compare heap.c's AddNewRelationTuple) */
532  relation->rd_att->tdtypeid =
533  relation->rd_rel->reltype ? relation->rd_rel->reltype : RECORDOID;
534  relation->rd_att->tdtypmod = -1; /* just to be sure */
535 
537  sizeof(TupleConstr));
538  constr->has_not_null = false;
539  constr->has_generated_stored = false;
540 
541  /*
542  * Form a scan key that selects only user attributes (attnum > 0).
543  * (Eliminating system attribute rows at the index level is lots faster
544  * than fetching them.)
545  */
546  ScanKeyInit(&skey[0],
547  Anum_pg_attribute_attrelid,
548  BTEqualStrategyNumber, F_OIDEQ,
550  ScanKeyInit(&skey[1],
551  Anum_pg_attribute_attnum,
552  BTGreaterStrategyNumber, F_INT2GT,
553  Int16GetDatum(0));
554 
555  /*
556  * Open pg_attribute and begin a scan. Force heap scan if we haven't yet
557  * built the critical relcache entries (this includes initdb and startup
558  * without a pg_internal.init file).
559  */
560  pg_attribute_desc = table_open(AttributeRelationId, AccessShareLock);
561  pg_attribute_scan = systable_beginscan(pg_attribute_desc,
562  AttributeRelidNumIndexId,
564  NULL,
565  2, skey);
566 
567  /*
568  * add attribute data to relation->rd_att
569  */
570  need = RelationGetNumberOfAttributes(relation);
571 
572  while (HeapTupleIsValid(pg_attribute_tuple = systable_getnext(pg_attribute_scan)))
573  {
574  Form_pg_attribute attp;
575  int attnum;
576 
577  attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);
578 
579  attnum = attp->attnum;
580  if (attnum <= 0 || attnum > RelationGetNumberOfAttributes(relation))
581  elog(ERROR, "invalid attribute number %d for relation \"%s\"",
582  attp->attnum, RelationGetRelationName(relation));
583 
584  memcpy(TupleDescAttr(relation->rd_att, attnum - 1),
585  attp,
587 
588  /* Update constraint/default info */
589  if (attp->attnotnull)
590  constr->has_not_null = true;
591  if (attp->attgenerated == ATTRIBUTE_GENERATED_STORED)
592  constr->has_generated_stored = true;
593  if (attp->atthasdef)
594  ndef++;
595 
596  /* If the column has a "missing" value, put it in the attrmiss array */
597  if (attp->atthasmissing)
598  {
599  Datum missingval;
600  bool missingNull;
601 
602  /* Do we have a missing value? */
603  missingval = heap_getattr(pg_attribute_tuple,
604  Anum_pg_attribute_attmissingval,
605  pg_attribute_desc->rd_att,
606  &missingNull);
607  if (!missingNull)
608  {
609  /* Yes, fetch from the array */
610  MemoryContext oldcxt;
611  bool is_null;
612  int one = 1;
613  Datum missval;
614 
615  if (attrmiss == NULL)
616  attrmiss = (AttrMissing *)
618  relation->rd_rel->relnatts *
619  sizeof(AttrMissing));
620 
621  missval = array_get_element(missingval,
622  1,
623  &one,
624  -1,
625  attp->attlen,
626  attp->attbyval,
627  attp->attalign,
628  &is_null);
629  Assert(!is_null);
630  if (attp->attbyval)
631  {
632  /* for copy by val just copy the datum direct */
633  attrmiss[attnum - 1].am_value = missval;
634  }
635  else
636  {
637  /* otherwise copy in the correct context */
639  attrmiss[attnum - 1].am_value = datumCopy(missval,
640  attp->attbyval,
641  attp->attlen);
642  MemoryContextSwitchTo(oldcxt);
643  }
644  attrmiss[attnum - 1].am_present = true;
645  }
646  }
647  need--;
648  if (need == 0)
649  break;
650  }
651 
652  /*
653  * end the scan and close the attribute relation
654  */
655  systable_endscan(pg_attribute_scan);
656  table_close(pg_attribute_desc, AccessShareLock);
657 
658  if (need != 0)
659  elog(ERROR, "pg_attribute catalog is missing %d attribute(s) for relation OID %u",
660  need, RelationGetRelid(relation));
661 
662  /*
663  * The attcacheoff values we read from pg_attribute should all be -1
664  * ("unknown"). Verify this if assert checking is on. They will be
665  * computed when and if needed during tuple access.
666  */
667 #ifdef USE_ASSERT_CHECKING
668  {
669  int i;
670 
671  for (i = 0; i < RelationGetNumberOfAttributes(relation); i++)
672  Assert(TupleDescAttr(relation->rd_att, i)->attcacheoff == -1);
673  }
674 #endif
675 
676  /*
677  * However, we can easily set the attcacheoff value for the first
678  * attribute: it must be zero. This eliminates the need for special cases
679  * for attnum=1 that used to exist in fastgetattr() and index_getattr().
680  */
681  if (RelationGetNumberOfAttributes(relation) > 0)
682  TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
683 
684  /*
685  * Set up constraint/default info
686  */
687  if (constr->has_not_null ||
688  constr->has_generated_stored ||
689  ndef > 0 ||
690  attrmiss ||
691  relation->rd_rel->relchecks > 0)
692  {
693  relation->rd_att->constr = constr;
694 
695  if (ndef > 0) /* DEFAULTs */
696  AttrDefaultFetch(relation, ndef);
697  else
698  constr->num_defval = 0;
699 
700  constr->missing = attrmiss;
701 
702  if (relation->rd_rel->relchecks > 0) /* CHECKs */
703  CheckConstraintFetch(relation);
704  else
705  constr->num_check = 0;
706  }
707  else
708  {
709  pfree(constr);
710  relation->rd_att->constr = NULL;
711  }
712 }
713 
714 /*
715  * RelationBuildRuleLock
716  *
717  * Form the relation's rewrite rules from information in
718  * the pg_rewrite system catalog.
719  *
720  * Note: The rule parsetrees are potentially very complex node structures.
721  * To allow these trees to be freed when the relcache entry is flushed,
722  * we make a private memory context to hold the RuleLock information for
723  * each relcache entry that has associated rules. The context is used
724  * just for rule info, not for any other subsidiary data of the relcache
725  * entry, because that keeps the update logic in RelationClearRelation()
726  * manageable. The other subsidiary data structures are simple enough
727  * to be easy to free explicitly, anyway.
728  *
729  * Note: The relation's reloptions must have been extracted first.
730  */
731 static void
733 {
734  MemoryContext rulescxt;
735  MemoryContext oldcxt;
736  HeapTuple rewrite_tuple;
737  Relation rewrite_desc;
738  TupleDesc rewrite_tupdesc;
739  SysScanDesc rewrite_scan;
741  RuleLock *rulelock;
742  int numlocks;
743  RewriteRule **rules;
744  int maxlocks;
745 
746  /*
747  * Make the private context. Assume it'll not contain much data.
748  */
750  "relation rules",
752  relation->rd_rulescxt = rulescxt;
754  RelationGetRelationName(relation));
755 
756  /*
757  * allocate an array to hold the rewrite rules (the array is extended if
758  * necessary)
759  */
760  maxlocks = 4;
761  rules = (RewriteRule **)
762  MemoryContextAlloc(rulescxt, sizeof(RewriteRule *) * maxlocks);
763  numlocks = 0;
764 
765  /*
766  * form a scan key
767  */
768  ScanKeyInit(&key,
769  Anum_pg_rewrite_ev_class,
770  BTEqualStrategyNumber, F_OIDEQ,
772 
773  /*
774  * open pg_rewrite and begin a scan
775  *
776  * Note: since we scan the rules using RewriteRelRulenameIndexId, we will
777  * be reading the rules in name order, except possibly during
778  * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
779  * ensures that rules will be fired in name order.
780  */
781  rewrite_desc = table_open(RewriteRelationId, AccessShareLock);
782  rewrite_tupdesc = RelationGetDescr(rewrite_desc);
783  rewrite_scan = systable_beginscan(rewrite_desc,
784  RewriteRelRulenameIndexId,
785  true, NULL,
786  1, &key);
787 
788  while (HeapTupleIsValid(rewrite_tuple = systable_getnext(rewrite_scan)))
789  {
790  Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple);
791  bool isnull;
792  Datum rule_datum;
793  char *rule_str;
794  RewriteRule *rule;
795  Oid check_as_user;
796 
797  rule = (RewriteRule *) MemoryContextAlloc(rulescxt,
798  sizeof(RewriteRule));
799 
800  rule->ruleId = rewrite_form->oid;
801 
802  rule->event = rewrite_form->ev_type - '0';
803  rule->enabled = rewrite_form->ev_enabled;
804  rule->isInstead = rewrite_form->is_instead;
805 
806  /*
807  * Must use heap_getattr to fetch ev_action and ev_qual. Also, the
808  * rule strings are often large enough to be toasted. To avoid
809  * leaking memory in the caller's context, do the detoasting here so
810  * we can free the detoasted version.
811  */
812  rule_datum = heap_getattr(rewrite_tuple,
813  Anum_pg_rewrite_ev_action,
814  rewrite_tupdesc,
815  &isnull);
816  Assert(!isnull);
817  rule_str = TextDatumGetCString(rule_datum);
818  oldcxt = MemoryContextSwitchTo(rulescxt);
819  rule->actions = (List *) stringToNode(rule_str);
820  MemoryContextSwitchTo(oldcxt);
821  pfree(rule_str);
822 
823  rule_datum = heap_getattr(rewrite_tuple,
824  Anum_pg_rewrite_ev_qual,
825  rewrite_tupdesc,
826  &isnull);
827  Assert(!isnull);
828  rule_str = TextDatumGetCString(rule_datum);
829  oldcxt = MemoryContextSwitchTo(rulescxt);
830  rule->qual = (Node *) stringToNode(rule_str);
831  MemoryContextSwitchTo(oldcxt);
832  pfree(rule_str);
833 
834  /*
835  * If this is a SELECT rule defining a view, and the view has
836  * "security_invoker" set, we must perform all permissions checks on
837  * relations referred to by the rule as the invoking user.
838  *
839  * In all other cases (including non-SELECT rules on security invoker
840  * views), perform the permissions checks as the relation owner.
841  */
842  if (rule->event == CMD_SELECT &&
843  relation->rd_rel->relkind == RELKIND_VIEW &&
844  RelationHasSecurityInvoker(relation))
845  check_as_user = InvalidOid;
846  else
847  check_as_user = relation->rd_rel->relowner;
848 
849  /*
850  * Scan through the rule's actions and set the checkAsUser field on
851  * all RTEPermissionInfos. We have to look at the qual as well, in
852  * case it contains sublinks.
853  *
854  * The reason for doing this when the rule is loaded, rather than when
855  * it is stored, is that otherwise ALTER TABLE OWNER would have to
856  * grovel through stored rules to update checkAsUser fields. Scanning
857  * the rule tree during load is relatively cheap (compared to
858  * constructing it in the first place), so we do it here.
859  */
860  setRuleCheckAsUser((Node *) rule->actions, check_as_user);
861  setRuleCheckAsUser(rule->qual, check_as_user);
862 
863  if (numlocks >= maxlocks)
864  {
865  maxlocks *= 2;
866  rules = (RewriteRule **)
867  repalloc(rules, sizeof(RewriteRule *) * maxlocks);
868  }
869  rules[numlocks++] = rule;
870  }
871 
872  /*
873  * end the scan and close the attribute relation
874  */
875  systable_endscan(rewrite_scan);
876  table_close(rewrite_desc, AccessShareLock);
877 
878  /*
879  * there might not be any rules (if relhasrules is out-of-date)
880  */
881  if (numlocks == 0)
882  {
883  relation->rd_rules = NULL;
884  relation->rd_rulescxt = NULL;
885  MemoryContextDelete(rulescxt);
886  return;
887  }
888 
889  /*
890  * form a RuleLock and insert into relation
891  */
892  rulelock = (RuleLock *) MemoryContextAlloc(rulescxt, sizeof(RuleLock));
893  rulelock->numLocks = numlocks;
894  rulelock->rules = rules;
895 
896  relation->rd_rules = rulelock;
897 }
898 
899 /*
900  * equalRuleLocks
901  *
902  * Determine whether two RuleLocks are equivalent
903  *
904  * Probably this should be in the rules code someplace...
905  */
906 static bool
908 {
909  int i;
910 
911  /*
912  * As of 7.3 we assume the rule ordering is repeatable, because
913  * RelationBuildRuleLock should read 'em in a consistent order. So just
914  * compare corresponding slots.
915  */
916  if (rlock1 != NULL)
917  {
918  if (rlock2 == NULL)
919  return false;
920  if (rlock1->numLocks != rlock2->numLocks)
921  return false;
922  for (i = 0; i < rlock1->numLocks; i++)
923  {
924  RewriteRule *rule1 = rlock1->rules[i];
925  RewriteRule *rule2 = rlock2->rules[i];
926 
927  if (rule1->ruleId != rule2->ruleId)
928  return false;
929  if (rule1->event != rule2->event)
930  return false;
931  if (rule1->enabled != rule2->enabled)
932  return false;
933  if (rule1->isInstead != rule2->isInstead)
934  return false;
935  if (!equal(rule1->qual, rule2->qual))
936  return false;
937  if (!equal(rule1->actions, rule2->actions))
938  return false;
939  }
940  }
941  else if (rlock2 != NULL)
942  return false;
943  return true;
944 }
945 
946 /*
947  * equalPolicy
948  *
949  * Determine whether two policies are equivalent
950  */
951 static bool
953 {
954  int i;
955  Oid *r1,
956  *r2;
957 
958  if (policy1 != NULL)
959  {
960  if (policy2 == NULL)
961  return false;
962 
963  if (policy1->polcmd != policy2->polcmd)
964  return false;
965  if (policy1->hassublinks != policy2->hassublinks)
966  return false;
967  if (strcmp(policy1->policy_name, policy2->policy_name) != 0)
968  return false;
969  if (ARR_DIMS(policy1->roles)[0] != ARR_DIMS(policy2->roles)[0])
970  return false;
971 
972  r1 = (Oid *) ARR_DATA_PTR(policy1->roles);
973  r2 = (Oid *) ARR_DATA_PTR(policy2->roles);
974 
975  for (i = 0; i < ARR_DIMS(policy1->roles)[0]; i++)
976  {
977  if (r1[i] != r2[i])
978  return false;
979  }
980 
981  if (!equal(policy1->qual, policy2->qual))
982  return false;
983  if (!equal(policy1->with_check_qual, policy2->with_check_qual))
984  return false;
985  }
986  else if (policy2 != NULL)
987  return false;
988 
989  return true;
990 }
991 
992 /*
993  * equalRSDesc
994  *
995  * Determine whether two RowSecurityDesc's are equivalent
996  */
997 static bool
999 {
1000  ListCell *lc,
1001  *rc;
1002 
1003  if (rsdesc1 == NULL && rsdesc2 == NULL)
1004  return true;
1005 
1006  if ((rsdesc1 != NULL && rsdesc2 == NULL) ||
1007  (rsdesc1 == NULL && rsdesc2 != NULL))
1008  return false;
1009 
1010  if (list_length(rsdesc1->policies) != list_length(rsdesc2->policies))
1011  return false;
1012 
1013  /* RelationBuildRowSecurity should build policies in order */
1014  forboth(lc, rsdesc1->policies, rc, rsdesc2->policies)
1015  {
1018 
1019  if (!equalPolicy(l, r))
1020  return false;
1021  }
1022 
1023  return true;
1024 }
1025 
1026 /*
1027  * RelationBuildDesc
1028  *
1029  * Build a relation descriptor. The caller must hold at least
1030  * AccessShareLock on the target relid.
1031  *
1032  * The new descriptor is inserted into the hash table if insertIt is true.
1033  *
1034  * Returns NULL if no pg_class row could be found for the given relid
1035  * (suggesting we are trying to access a just-deleted relation).
1036  * Any other error is reported via elog.
1037  */
1038 static Relation
1039 RelationBuildDesc(Oid targetRelId, bool insertIt)
1040 {
1041  int in_progress_offset;
1042  Relation relation;
1043  Oid relid;
1044  HeapTuple pg_class_tuple;
1045  Form_pg_class relp;
1046 
1047  /*
1048  * This function and its subroutines can allocate a good deal of transient
1049  * data in CurrentMemoryContext. Traditionally we've just leaked that
1050  * data, reasoning that the caller's context is at worst of transaction
1051  * scope, and relcache loads shouldn't happen so often that it's essential
1052  * to recover transient data before end of statement/transaction. However
1053  * that's definitely not true when debug_discard_caches is active, and
1054  * perhaps it's not true in other cases.
1055  *
1056  * When debug_discard_caches is active or when forced to by
1057  * RECOVER_RELATION_BUILD_MEMORY=1, arrange to allocate the junk in a
1058  * temporary context that we'll free before returning. Make it a child of
1059  * caller's context so that it will get cleaned up appropriately if we
1060  * error out partway through.
1061  */
1062 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
1063  MemoryContext tmpcxt = NULL;
1064  MemoryContext oldcxt = NULL;
1065 
1067  {
1069  "RelationBuildDesc workspace",
1071  oldcxt = MemoryContextSwitchTo(tmpcxt);
1072  }
1073 #endif
1074 
1075  /* Register to catch invalidation messages */
1077  {
1078  int allocsize;
1079 
1080  allocsize = in_progress_list_maxlen * 2;
1082  allocsize * sizeof(*in_progress_list));
1083  in_progress_list_maxlen = allocsize;
1084  }
1085  in_progress_offset = in_progress_list_len++;
1086  in_progress_list[in_progress_offset].reloid = targetRelId;
1087 retry:
1088  in_progress_list[in_progress_offset].invalidated = false;
1089 
1090  /*
1091  * find the tuple in pg_class corresponding to the given relation id
1092  */
1093  pg_class_tuple = ScanPgRelation(targetRelId, true, false);
1094 
1095  /*
1096  * if no such tuple exists, return NULL
1097  */
1098  if (!HeapTupleIsValid(pg_class_tuple))
1099  {
1100 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
1101  if (tmpcxt)
1102  {
1103  /* Return to caller's context, and blow away the temporary context */
1104  MemoryContextSwitchTo(oldcxt);
1105  MemoryContextDelete(tmpcxt);
1106  }
1107 #endif
1108  Assert(in_progress_offset + 1 == in_progress_list_len);
1110  return NULL;
1111  }
1112 
1113  /*
1114  * get information from the pg_class_tuple
1115  */
1116  relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
1117  relid = relp->oid;
1118  Assert(relid == targetRelId);
1119 
1120  /*
1121  * allocate storage for the relation descriptor, and copy pg_class_tuple
1122  * to relation->rd_rel.
1123  */
1124  relation = AllocateRelationDesc(relp);
1125 
1126  /*
1127  * initialize the relation's relation id (relation->rd_id)
1128  */
1129  RelationGetRelid(relation) = relid;
1130 
1131  /*
1132  * Normal relations are not nailed into the cache. Since we don't flush
1133  * new relations, it won't be new. It could be temp though.
1134  */
1135  relation->rd_refcnt = 0;
1136  relation->rd_isnailed = false;
1141  switch (relation->rd_rel->relpersistence)
1142  {
1143  case RELPERSISTENCE_UNLOGGED:
1144  case RELPERSISTENCE_PERMANENT:
1145  relation->rd_backend = INVALID_PROC_NUMBER;
1146  relation->rd_islocaltemp = false;
1147  break;
1148  case RELPERSISTENCE_TEMP:
1149  if (isTempOrTempToastNamespace(relation->rd_rel->relnamespace))
1150  {
1151  relation->rd_backend = ProcNumberForTempRelations();
1152  relation->rd_islocaltemp = true;
1153  }
1154  else
1155  {
1156  /*
1157  * If it's a temp table, but not one of ours, we have to use
1158  * the slow, grotty method to figure out the owning backend.
1159  *
1160  * Note: it's possible that rd_backend gets set to
1161  * MyProcNumber here, in case we are looking at a pg_class
1162  * entry left over from a crashed backend that coincidentally
1163  * had the same ProcNumber we're using. We should *not*
1164  * consider such a table to be "ours"; this is why we need the
1165  * separate rd_islocaltemp flag. The pg_class entry will get
1166  * flushed if/when we clean out the corresponding temp table
1167  * namespace in preparation for using it.
1168  */
1169  relation->rd_backend =
1170  GetTempNamespaceProcNumber(relation->rd_rel->relnamespace);
1171  Assert(relation->rd_backend != INVALID_PROC_NUMBER);
1172  relation->rd_islocaltemp = false;
1173  }
1174  break;
1175  default:
1176  elog(ERROR, "invalid relpersistence: %c",
1177  relation->rd_rel->relpersistence);
1178  break;
1179  }
1180 
1181  /*
1182  * initialize the tuple descriptor (relation->rd_att).
1183  */
1184  RelationBuildTupleDesc(relation);
1185 
1186  /* foreign key data is not loaded till asked for */
1187  relation->rd_fkeylist = NIL;
1188  relation->rd_fkeyvalid = false;
1189 
1190  /* partitioning data is not loaded till asked for */
1191  relation->rd_partkey = NULL;
1192  relation->rd_partkeycxt = NULL;
1193  relation->rd_partdesc = NULL;
1194  relation->rd_partdesc_nodetached = NULL;
1196  relation->rd_pdcxt = NULL;
1197  relation->rd_pddcxt = NULL;
1198  relation->rd_partcheck = NIL;
1199  relation->rd_partcheckvalid = false;
1200  relation->rd_partcheckcxt = NULL;
1201 
1202  /*
1203  * initialize access method information
1204  */
1205  if (relation->rd_rel->relkind == RELKIND_INDEX ||
1206  relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
1207  RelationInitIndexAccessInfo(relation);
1208  else if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) ||
1209  relation->rd_rel->relkind == RELKIND_SEQUENCE)
1211  else if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
1212  {
1213  /*
1214  * Do nothing: access methods are a setting that partitions can
1215  * inherit.
1216  */
1217  }
1218  else
1219  Assert(relation->rd_rel->relam == InvalidOid);
1220 
1221  /* extract reloptions if any */
1222  RelationParseRelOptions(relation, pg_class_tuple);
1223 
1224  /*
1225  * Fetch rules and triggers that affect this relation.
1226  *
1227  * Note that RelationBuildRuleLock() relies on this being done after
1228  * extracting the relation's reloptions.
1229  */
1230  if (relation->rd_rel->relhasrules)
1231  RelationBuildRuleLock(relation);
1232  else
1233  {
1234  relation->rd_rules = NULL;
1235  relation->rd_rulescxt = NULL;
1236  }
1237 
1238  if (relation->rd_rel->relhastriggers)
1239  RelationBuildTriggers(relation);
1240  else
1241  relation->trigdesc = NULL;
1242 
1243  if (relation->rd_rel->relrowsecurity)
1244  RelationBuildRowSecurity(relation);
1245  else
1246  relation->rd_rsdesc = NULL;
1247 
1248  /*
1249  * initialize the relation lock manager information
1250  */
1251  RelationInitLockInfo(relation); /* see lmgr.c */
1252 
1253  /*
1254  * initialize physical addressing information for the relation
1255  */
1256  RelationInitPhysicalAddr(relation);
1257 
1258  /* make sure relation is marked as having no open file yet */
1259  relation->rd_smgr = NULL;
1260 
1261  /*
1262  * now we can free the memory allocated for pg_class_tuple
1263  */
1264  heap_freetuple(pg_class_tuple);
1265 
1266  /*
1267  * If an invalidation arrived mid-build, start over. Between here and the
1268  * end of this function, don't add code that does or reasonably could read
1269  * system catalogs. That range must be free from invalidation processing
1270  * for the !insertIt case. For the insertIt case, RelationCacheInsert()
1271  * will enroll this relation in ordinary relcache invalidation processing,
1272  */
1273  if (in_progress_list[in_progress_offset].invalidated)
1274  {
1275  RelationDestroyRelation(relation, false);
1276  goto retry;
1277  }
1278  Assert(in_progress_offset + 1 == in_progress_list_len);
1280 
1281  /*
1282  * Insert newly created relation into relcache hash table, if requested.
1283  *
1284  * There is one scenario in which we might find a hashtable entry already
1285  * present, even though our caller failed to find it: if the relation is a
1286  * system catalog or index that's used during relcache load, we might have
1287  * recursively created the same relcache entry during the preceding steps.
1288  * So allow RelationCacheInsert to delete any already-present relcache
1289  * entry for the same OID. The already-present entry should have refcount
1290  * zero (else somebody forgot to close it); in the event that it doesn't,
1291  * we'll elog a WARNING and leak the already-present entry.
1292  */
1293  if (insertIt)
1294  RelationCacheInsert(relation, true);
1295 
1296  /* It's fully valid */
1297  relation->rd_isvalid = true;
1298 
1299 #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
1300  if (tmpcxt)
1301  {
1302  /* Return to caller's context, and blow away the temporary context */
1303  MemoryContextSwitchTo(oldcxt);
1304  MemoryContextDelete(tmpcxt);
1305  }
1306 #endif
1307 
1308  return relation;
1309 }
1310 
1311 /*
1312  * Initialize the physical addressing info (RelFileLocator) for a relcache entry
1313  *
1314  * Note: at the physical level, relations in the pg_global tablespace must
1315  * be treated as shared, even if relisshared isn't set. Hence we do not
1316  * look at relisshared here.
1317  */
1318 static void
1320 {
1321  RelFileNumber oldnumber = relation->rd_locator.relNumber;
1322 
1323  /* these relations kinds never have storage */
1324  if (!RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
1325  return;
1326 
1327  if (relation->rd_rel->reltablespace)
1328  relation->rd_locator.spcOid = relation->rd_rel->reltablespace;
1329  else
1331  if (relation->rd_locator.spcOid == GLOBALTABLESPACE_OID)
1332  relation->rd_locator.dbOid = InvalidOid;
1333  else
1334  relation->rd_locator.dbOid = MyDatabaseId;
1335 
1336  if (relation->rd_rel->relfilenode)
1337  {
1338  /*
1339  * Even if we are using a decoding snapshot that doesn't represent the
1340  * current state of the catalog we need to make sure the filenode
1341  * points to the current file since the older file will be gone (or
1342  * truncated). The new file will still contain older rows so lookups
1343  * in them will work correctly. This wouldn't work correctly if
1344  * rewrites were allowed to change the schema in an incompatible way,
1345  * but those are prevented both on catalog tables and on user tables
1346  * declared as additional catalog tables.
1347  */
1350  && IsTransactionState())
1351  {
1352  HeapTuple phys_tuple;
1353  Form_pg_class physrel;
1354 
1355  phys_tuple = ScanPgRelation(RelationGetRelid(relation),
1356  RelationGetRelid(relation) != ClassOidIndexId,
1357  true);
1358  if (!HeapTupleIsValid(phys_tuple))
1359  elog(ERROR, "could not find pg_class entry for %u",
1360  RelationGetRelid(relation));
1361  physrel = (Form_pg_class) GETSTRUCT(phys_tuple);
1362 
1363  relation->rd_rel->reltablespace = physrel->reltablespace;
1364  relation->rd_rel->relfilenode = physrel->relfilenode;
1365  heap_freetuple(phys_tuple);
1366  }
1367 
1368  relation->rd_locator.relNumber = relation->rd_rel->relfilenode;
1369  }
1370  else
1371  {
1372  /* Consult the relation mapper */
1373  relation->rd_locator.relNumber =
1375  relation->rd_rel->relisshared);
1376  if (!RelFileNumberIsValid(relation->rd_locator.relNumber))
1377  elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u",
1378  RelationGetRelationName(relation), relation->rd_id);
1379  }
1380 
1381  /*
1382  * For RelationNeedsWAL() to answer correctly on parallel workers, restore
1383  * rd_firstRelfilelocatorSubid. No subtransactions start or end while in
1384  * parallel mode, so the specific SubTransactionId does not matter.
1385  */
1386  if (IsParallelWorker() && oldnumber != relation->rd_locator.relNumber)
1387  {
1388  if (RelFileLocatorSkippingWAL(relation->rd_locator))
1390  else
1392  }
1393 }
1394 
1395 /*
1396  * Fill in the IndexAmRoutine for an index relation.
1397  *
1398  * relation's rd_amhandler and rd_indexcxt must be valid already.
1399  */
1400 static void
1402 {
1403  IndexAmRoutine *cached,
1404  *tmp;
1405 
1406  /*
1407  * Call the amhandler in current, short-lived memory context, just in case
1408  * it leaks anything (it probably won't, but let's be paranoid).
1409  */
1410  tmp = GetIndexAmRoutine(relation->rd_amhandler);
1411 
1412  /* OK, now transfer the data into relation's rd_indexcxt. */
1413  cached = (IndexAmRoutine *) MemoryContextAlloc(relation->rd_indexcxt,
1414  sizeof(IndexAmRoutine));
1415  memcpy(cached, tmp, sizeof(IndexAmRoutine));
1416  relation->rd_indam = cached;
1417 
1418  pfree(tmp);
1419 }
1420 
1421 /*
1422  * Initialize index-access-method support data for an index relation
1423  */
1424 void
1426 {
1427  HeapTuple tuple;
1428  Form_pg_am aform;
1429  Datum indcollDatum;
1430  Datum indclassDatum;
1431  Datum indoptionDatum;
1432  bool isnull;
1433  oidvector *indcoll;
1434  oidvector *indclass;
1435  int2vector *indoption;
1436  MemoryContext indexcxt;
1437  MemoryContext oldcontext;
1438  int indnatts;
1439  int indnkeyatts;
1440  uint16 amsupport;
1441 
1442  /*
1443  * Make a copy of the pg_index entry for the index. Since pg_index
1444  * contains variable-length and possibly-null fields, we have to do this
1445  * honestly rather than just treating it as a Form_pg_index struct.
1446  */
1447  tuple = SearchSysCache1(INDEXRELID,
1448  ObjectIdGetDatum(RelationGetRelid(relation)));
1449  if (!HeapTupleIsValid(tuple))
1450  elog(ERROR, "cache lookup failed for index %u",
1451  RelationGetRelid(relation));
1453  relation->rd_indextuple = heap_copytuple(tuple);
1454  relation->rd_index = (Form_pg_index) GETSTRUCT(relation->rd_indextuple);
1455  MemoryContextSwitchTo(oldcontext);
1456  ReleaseSysCache(tuple);
1457 
1458  /*
1459  * Look up the index's access method, save the OID of its handler function
1460  */
1461  Assert(relation->rd_rel->relam != InvalidOid);
1462  tuple = SearchSysCache1(AMOID, ObjectIdGetDatum(relation->rd_rel->relam));
1463  if (!HeapTupleIsValid(tuple))
1464  elog(ERROR, "cache lookup failed for access method %u",
1465  relation->rd_rel->relam);
1466  aform = (Form_pg_am) GETSTRUCT(tuple);
1467  relation->rd_amhandler = aform->amhandler;
1468  ReleaseSysCache(tuple);
1469 
1470  indnatts = RelationGetNumberOfAttributes(relation);
1471  if (indnatts != IndexRelationGetNumberOfAttributes(relation))
1472  elog(ERROR, "relnatts disagrees with indnatts for index %u",
1473  RelationGetRelid(relation));
1474  indnkeyatts = IndexRelationGetNumberOfKeyAttributes(relation);
1475 
1476  /*
1477  * Make the private context to hold index access info. The reason we need
1478  * a context, and not just a couple of pallocs, is so that we won't leak
1479  * any subsidiary info attached to fmgr lookup records.
1480  */
1482  "index info",
1484  relation->rd_indexcxt = indexcxt;
1486  RelationGetRelationName(relation));
1487 
1488  /*
1489  * Now we can fetch the index AM's API struct
1490  */
1491  InitIndexAmRoutine(relation);
1492 
1493  /*
1494  * Allocate arrays to hold data. Opclasses are not used for included
1495  * columns, so allocate them for indnkeyatts only.
1496  */
1497  relation->rd_opfamily = (Oid *)
1498  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
1499  relation->rd_opcintype = (Oid *)
1500  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
1501 
1502  amsupport = relation->rd_indam->amsupport;
1503  if (amsupport > 0)
1504  {
1505  int nsupport = indnatts * amsupport;
1506 
1507  relation->rd_support = (RegProcedure *)
1508  MemoryContextAllocZero(indexcxt, nsupport * sizeof(RegProcedure));
1509  relation->rd_supportinfo = (FmgrInfo *)
1510  MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
1511  }
1512  else
1513  {
1514  relation->rd_support = NULL;
1515  relation->rd_supportinfo = NULL;
1516  }
1517 
1518  relation->rd_indcollation = (Oid *)
1519  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
1520 
1521  relation->rd_indoption = (int16 *)
1522  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(int16));
1523 
1524  /*
1525  * indcollation cannot be referenced directly through the C struct,
1526  * because it comes after the variable-width indkey field. Must extract
1527  * the datum the hard way...
1528  */
1529  indcollDatum = fastgetattr(relation->rd_indextuple,
1530  Anum_pg_index_indcollation,
1532  &isnull);
1533  Assert(!isnull);
1534  indcoll = (oidvector *) DatumGetPointer(indcollDatum);
1535  memcpy(relation->rd_indcollation, indcoll->values, indnkeyatts * sizeof(Oid));
1536 
1537  /*
1538  * indclass cannot be referenced directly through the C struct, because it
1539  * comes after the variable-width indkey field. Must extract the datum
1540  * the hard way...
1541  */
1542  indclassDatum = fastgetattr(relation->rd_indextuple,
1543  Anum_pg_index_indclass,
1545  &isnull);
1546  Assert(!isnull);
1547  indclass = (oidvector *) DatumGetPointer(indclassDatum);
1548 
1549  /*
1550  * Fill the support procedure OID array, as well as the info about
1551  * opfamilies and opclass input types. (aminfo and supportinfo are left
1552  * as zeroes, and are filled on-the-fly when used)
1553  */
1554  IndexSupportInitialize(indclass, relation->rd_support,
1555  relation->rd_opfamily, relation->rd_opcintype,
1556  amsupport, indnkeyatts);
1557 
1558  /*
1559  * Similarly extract indoption and copy it to the cache entry
1560  */
1561  indoptionDatum = fastgetattr(relation->rd_indextuple,
1562  Anum_pg_index_indoption,
1564  &isnull);
1565  Assert(!isnull);
1566  indoption = (int2vector *) DatumGetPointer(indoptionDatum);
1567  memcpy(relation->rd_indoption, indoption->values, indnkeyatts * sizeof(int16));
1568 
1569  (void) RelationGetIndexAttOptions(relation, false);
1570 
1571  /*
1572  * expressions, predicate, exclusion caches will be filled later
1573  */
1574  relation->rd_indexprs = NIL;
1575  relation->rd_indpred = NIL;
1576  relation->rd_exclops = NULL;
1577  relation->rd_exclprocs = NULL;
1578  relation->rd_exclstrats = NULL;
1579  relation->rd_amcache = NULL;
1580 }
1581 
1582 /*
1583  * IndexSupportInitialize
1584  * Initializes an index's cached opclass information,
1585  * given the index's pg_index.indclass entry.
1586  *
1587  * Data is returned into *indexSupport, *opFamily, and *opcInType,
1588  * which are arrays allocated by the caller.
1589  *
1590  * The caller also passes maxSupportNumber and maxAttributeNumber, since these
1591  * indicate the size of the arrays it has allocated --- but in practice these
1592  * numbers must always match those obtainable from the system catalog entries
1593  * for the index and access method.
1594  */
1595 static void
1597  RegProcedure *indexSupport,
1598  Oid *opFamily,
1599  Oid *opcInType,
1600  StrategyNumber maxSupportNumber,
1601  AttrNumber maxAttributeNumber)
1602 {
1603  int attIndex;
1604 
1605  for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
1606  {
1607  OpClassCacheEnt *opcentry;
1608 
1609  if (!OidIsValid(indclass->values[attIndex]))
1610  elog(ERROR, "bogus pg_index tuple");
1611 
1612  /* look up the info for this opclass, using a cache */
1613  opcentry = LookupOpclassInfo(indclass->values[attIndex],
1614  maxSupportNumber);
1615 
1616  /* copy cached data into relcache entry */
1617  opFamily[attIndex] = opcentry->opcfamily;
1618  opcInType[attIndex] = opcentry->opcintype;
1619  if (maxSupportNumber > 0)
1620  memcpy(&indexSupport[attIndex * maxSupportNumber],
1621  opcentry->supportProcs,
1622  maxSupportNumber * sizeof(RegProcedure));
1623  }
1624 }
1625 
1626 /*
1627  * LookupOpclassInfo
1628  *
1629  * This routine maintains a per-opclass cache of the information needed
1630  * by IndexSupportInitialize(). This is more efficient than relying on
1631  * the catalog cache, because we can load all the info about a particular
1632  * opclass in a single indexscan of pg_amproc.
1633  *
1634  * The information from pg_am about expected range of support function
1635  * numbers is passed in, rather than being looked up, mainly because the
1636  * caller will have it already.
1637  *
1638  * Note there is no provision for flushing the cache. This is OK at the
1639  * moment because there is no way to ALTER any interesting properties of an
1640  * existing opclass --- all you can do is drop it, which will result in
1641  * a useless but harmless dead entry in the cache. To support altering
1642  * opclass membership (not the same as opfamily membership!), we'd need to
1643  * be able to flush this cache as well as the contents of relcache entries
1644  * for indexes.
1645  */
1646 static OpClassCacheEnt *
1647 LookupOpclassInfo(Oid operatorClassOid,
1648  StrategyNumber numSupport)
1649 {
1650  OpClassCacheEnt *opcentry;
1651  bool found;
1652  Relation rel;
1653  SysScanDesc scan;
1654  ScanKeyData skey[3];
1655  HeapTuple htup;
1656  bool indexOK;
1657 
1658  if (OpClassCache == NULL)
1659  {
1660  /* First time through: initialize the opclass cache */
1661  HASHCTL ctl;
1662 
1663  /* Also make sure CacheMemoryContext exists */
1664  if (!CacheMemoryContext)
1666 
1667  ctl.keysize = sizeof(Oid);
1668  ctl.entrysize = sizeof(OpClassCacheEnt);
1669  OpClassCache = hash_create("Operator class cache", 64,
1670  &ctl, HASH_ELEM | HASH_BLOBS);
1671  }
1672 
1673  opcentry = (OpClassCacheEnt *) hash_search(OpClassCache,
1674  &operatorClassOid,
1675  HASH_ENTER, &found);
1676 
1677  if (!found)
1678  {
1679  /* Initialize new entry */
1680  opcentry->valid = false; /* until known OK */
1681  opcentry->numSupport = numSupport;
1682  opcentry->supportProcs = NULL; /* filled below */
1683  }
1684  else
1685  {
1686  Assert(numSupport == opcentry->numSupport);
1687  }
1688 
1689  /*
1690  * When aggressively testing cache-flush hazards, we disable the operator
1691  * class cache and force reloading of the info on each call. This models
1692  * no real-world behavior, since the cache entries are never invalidated
1693  * otherwise. However it can be helpful for detecting bugs in the cache
1694  * loading logic itself, such as reliance on a non-nailed index. Given
1695  * the limited use-case and the fact that this adds a great deal of
1696  * expense, we enable it only for high values of debug_discard_caches.
1697  */
1698 #ifdef DISCARD_CACHES_ENABLED
1699  if (debug_discard_caches > 2)
1700  opcentry->valid = false;
1701 #endif
1702 
1703  if (opcentry->valid)
1704  return opcentry;
1705 
1706  /*
1707  * Need to fill in new entry. First allocate space, unless we already did
1708  * so in some previous attempt.
1709  */
1710  if (opcentry->supportProcs == NULL && numSupport > 0)
1711  opcentry->supportProcs = (RegProcedure *)
1713  numSupport * sizeof(RegProcedure));
1714 
1715  /*
1716  * To avoid infinite recursion during startup, force heap scans if we're
1717  * looking up info for the opclasses used by the indexes we would like to
1718  * reference here.
1719  */
1720  indexOK = criticalRelcachesBuilt ||
1721  (operatorClassOid != OID_BTREE_OPS_OID &&
1722  operatorClassOid != INT2_BTREE_OPS_OID);
1723 
1724  /*
1725  * We have to fetch the pg_opclass row to determine its opfamily and
1726  * opcintype, which are needed to look up related operators and functions.
1727  * It'd be convenient to use the syscache here, but that probably doesn't
1728  * work while bootstrapping.
1729  */
1730  ScanKeyInit(&skey[0],
1731  Anum_pg_opclass_oid,
1732  BTEqualStrategyNumber, F_OIDEQ,
1733  ObjectIdGetDatum(operatorClassOid));
1734  rel = table_open(OperatorClassRelationId, AccessShareLock);
1735  scan = systable_beginscan(rel, OpclassOidIndexId, indexOK,
1736  NULL, 1, skey);
1737 
1738  if (HeapTupleIsValid(htup = systable_getnext(scan)))
1739  {
1740  Form_pg_opclass opclassform = (Form_pg_opclass) GETSTRUCT(htup);
1741 
1742  opcentry->opcfamily = opclassform->opcfamily;
1743  opcentry->opcintype = opclassform->opcintype;
1744  }
1745  else
1746  elog(ERROR, "could not find tuple for opclass %u", operatorClassOid);
1747 
1748  systable_endscan(scan);
1750 
1751  /*
1752  * Scan pg_amproc to obtain support procs for the opclass. We only fetch
1753  * the default ones (those with lefttype = righttype = opcintype).
1754  */
1755  if (numSupport > 0)
1756  {
1757  ScanKeyInit(&skey[0],
1758  Anum_pg_amproc_amprocfamily,
1759  BTEqualStrategyNumber, F_OIDEQ,
1760  ObjectIdGetDatum(opcentry->opcfamily));
1761  ScanKeyInit(&skey[1],
1762  Anum_pg_amproc_amproclefttype,
1763  BTEqualStrategyNumber, F_OIDEQ,
1764  ObjectIdGetDatum(opcentry->opcintype));
1765  ScanKeyInit(&skey[2],
1766  Anum_pg_amproc_amprocrighttype,
1767  BTEqualStrategyNumber, F_OIDEQ,
1768  ObjectIdGetDatum(opcentry->opcintype));
1769  rel = table_open(AccessMethodProcedureRelationId, AccessShareLock);
1770  scan = systable_beginscan(rel, AccessMethodProcedureIndexId, indexOK,
1771  NULL, 3, skey);
1772 
1773  while (HeapTupleIsValid(htup = systable_getnext(scan)))
1774  {
1775  Form_pg_amproc amprocform = (Form_pg_amproc) GETSTRUCT(htup);
1776 
1777  if (amprocform->amprocnum <= 0 ||
1778  (StrategyNumber) amprocform->amprocnum > numSupport)
1779  elog(ERROR, "invalid amproc number %d for opclass %u",
1780  amprocform->amprocnum, operatorClassOid);
1781 
1782  opcentry->supportProcs[amprocform->amprocnum - 1] =
1783  amprocform->amproc;
1784  }
1785 
1786  systable_endscan(scan);
1788  }
1789 
1790  opcentry->valid = true;
1791  return opcentry;
1792 }
1793 
1794 /*
1795  * Fill in the TableAmRoutine for a relation
1796  *
1797  * relation's rd_amhandler must be valid already.
1798  */
1799 static void
1801 {
1802  relation->rd_tableam = GetTableAmRoutine(relation->rd_amhandler);
1803 }
1804 
1805 /*
1806  * Initialize table access method support for a table like relation
1807  */
1808 void
1810 {
1811  HeapTuple tuple;
1812  Form_pg_am aform;
1813 
1814  if (relation->rd_rel->relkind == RELKIND_SEQUENCE)
1815  {
1816  /*
1817  * Sequences are currently accessed like heap tables, but it doesn't
1818  * seem prudent to show that in the catalog. So just overwrite it
1819  * here.
1820  */
1821  Assert(relation->rd_rel->relam == InvalidOid);
1822  relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
1823  }
1824  else if (IsCatalogRelation(relation))
1825  {
1826  /*
1827  * Avoid doing a syscache lookup for catalog tables.
1828  */
1829  Assert(relation->rd_rel->relam == HEAP_TABLE_AM_OID);
1830  relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
1831  }
1832  else
1833  {
1834  /*
1835  * Look up the table access method, save the OID of its handler
1836  * function.
1837  */
1838  Assert(relation->rd_rel->relam != InvalidOid);
1839  tuple = SearchSysCache1(AMOID,
1840  ObjectIdGetDatum(relation->rd_rel->relam));
1841  if (!HeapTupleIsValid(tuple))
1842  elog(ERROR, "cache lookup failed for access method %u",
1843  relation->rd_rel->relam);
1844  aform = (Form_pg_am) GETSTRUCT(tuple);
1845  relation->rd_amhandler = aform->amhandler;
1846  ReleaseSysCache(tuple);
1847  }
1848 
1849  /*
1850  * Now we can fetch the table AM's API struct
1851  */
1852  InitTableAmRoutine(relation);
1853 }
1854 
1855 /*
1856  * formrdesc
1857  *
1858  * This is a special cut-down version of RelationBuildDesc(),
1859  * used while initializing the relcache.
1860  * The relation descriptor is built just from the supplied parameters,
1861  * without actually looking at any system table entries. We cheat
1862  * quite a lot since we only need to work for a few basic system
1863  * catalogs.
1864  *
1865  * The catalogs this is used for can't have constraints (except attnotnull),
1866  * default values, rules, or triggers, since we don't cope with any of that.
1867  * (Well, actually, this only matters for properties that need to be valid
1868  * during bootstrap or before RelationCacheInitializePhase3 runs, and none of
1869  * these properties matter then...)
1870  *
1871  * NOTE: we assume we are already switched into CacheMemoryContext.
1872  */
1873 static void
1874 formrdesc(const char *relationName, Oid relationReltype,
1875  bool isshared,
1876  int natts, const FormData_pg_attribute *attrs)
1877 {
1878  Relation relation;
1879  int i;
1880  bool has_not_null;
1881 
1882  /*
1883  * allocate new relation desc, clear all fields of reldesc
1884  */
1885  relation = (Relation) palloc0(sizeof(RelationData));
1886 
1887  /* make sure relation is marked as having no open file yet */
1888  relation->rd_smgr = NULL;
1889 
1890  /*
1891  * initialize reference count: 1 because it is nailed in cache
1892  */
1893  relation->rd_refcnt = 1;
1894 
1895  /*
1896  * all entries built with this routine are nailed-in-cache; none are for
1897  * new or temp relations.
1898  */
1899  relation->rd_isnailed = true;
1904  relation->rd_backend = INVALID_PROC_NUMBER;
1905  relation->rd_islocaltemp = false;
1906 
1907  /*
1908  * initialize relation tuple form
1909  *
1910  * The data we insert here is pretty incomplete/bogus, but it'll serve to
1911  * get us launched. RelationCacheInitializePhase3() will read the real
1912  * data from pg_class and replace what we've done here. Note in
1913  * particular that relowner is left as zero; this cues
1914  * RelationCacheInitializePhase3 that the real data isn't there yet.
1915  */
1917 
1918  namestrcpy(&relation->rd_rel->relname, relationName);
1919  relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
1920  relation->rd_rel->reltype = relationReltype;
1921 
1922  /*
1923  * It's important to distinguish between shared and non-shared relations,
1924  * even at bootstrap time, to make sure we know where they are stored.
1925  */
1926  relation->rd_rel->relisshared = isshared;
1927  if (isshared)
1928  relation->rd_rel->reltablespace = GLOBALTABLESPACE_OID;
1929 
1930  /* formrdesc is used only for permanent relations */
1931  relation->rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;
1932 
1933  /* ... and they're always populated, too */
1934  relation->rd_rel->relispopulated = true;
1935 
1936  relation->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
1937  relation->rd_rel->relpages = 0;
1938  relation->rd_rel->reltuples = -1;
1939  relation->rd_rel->relallvisible = 0;
1940  relation->rd_rel->relkind = RELKIND_RELATION;
1941  relation->rd_rel->relnatts = (int16) natts;
1942  relation->rd_rel->relam = HEAP_TABLE_AM_OID;
1943 
1944  /*
1945  * initialize attribute tuple form
1946  *
1947  * Unlike the case with the relation tuple, this data had better be right
1948  * because it will never be replaced. The data comes from
1949  * src/include/catalog/ headers via genbki.pl.
1950  */
1951  relation->rd_att = CreateTemplateTupleDesc(natts);
1952  relation->rd_att->tdrefcount = 1; /* mark as refcounted */
1953 
1954  relation->rd_att->tdtypeid = relationReltype;
1955  relation->rd_att->tdtypmod = -1; /* just to be sure */
1956 
1957  /*
1958  * initialize tuple desc info
1959  */
1960  has_not_null = false;
1961  for (i = 0; i < natts; i++)
1962  {
1963  memcpy(TupleDescAttr(relation->rd_att, i),
1964  &attrs[i],
1966  has_not_null |= attrs[i].attnotnull;
1967  /* make sure attcacheoff is valid */
1968  TupleDescAttr(relation->rd_att, i)->attcacheoff = -1;
1969  }
1970 
1971  /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
1972  TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
1973 
1974  /* mark not-null status */
1975  if (has_not_null)
1976  {
1977  TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
1978 
1979  constr->has_not_null = true;
1980  relation->rd_att->constr = constr;
1981  }
1982 
1983  /*
1984  * initialize relation id from info in att array (my, this is ugly)
1985  */
1986  RelationGetRelid(relation) = TupleDescAttr(relation->rd_att, 0)->attrelid;
1987 
1988  /*
1989  * All relations made with formrdesc are mapped. This is necessarily so
1990  * because there is no other way to know what filenumber they currently
1991  * have. In bootstrap mode, add them to the initial relation mapper data,
1992  * specifying that the initial filenumber is the same as the OID.
1993  */
1994  relation->rd_rel->relfilenode = InvalidRelFileNumber;
1997  RelationGetRelid(relation),
1998  isshared, true);
1999 
2000  /*
2001  * initialize the relation lock manager information
2002  */
2003  RelationInitLockInfo(relation); /* see lmgr.c */
2004 
2005  /*
2006  * initialize physical addressing information for the relation
2007  */
2008  RelationInitPhysicalAddr(relation);
2009 
2010  /*
2011  * initialize the table am handler
2012  */
2013  relation->rd_rel->relam = HEAP_TABLE_AM_OID;
2014  relation->rd_tableam = GetHeapamTableAmRoutine();
2015 
2016  /*
2017  * initialize the rel-has-index flag, using hardwired knowledge
2018  */
2020  {
2021  /* In bootstrap mode, we have no indexes */
2022  relation->rd_rel->relhasindex = false;
2023  }
2024  else
2025  {
2026  /* Otherwise, all the rels formrdesc is used for have indexes */
2027  relation->rd_rel->relhasindex = true;
2028  }
2029 
2030  /*
2031  * add new reldesc to relcache
2032  */
2033  RelationCacheInsert(relation, false);
2034 
2035  /* It's fully valid */
2036  relation->rd_isvalid = true;
2037 }
2038 
2039 
2040 /* ----------------------------------------------------------------
2041  * Relation Descriptor Lookup Interface
2042  * ----------------------------------------------------------------
2043  */
2044 
2045 /*
2046  * RelationIdGetRelation
2047  *
2048  * Lookup a reldesc by OID; make one if not already in cache.
2049  *
2050  * Returns NULL if no pg_class row could be found for the given relid
2051  * (suggesting we are trying to access a just-deleted relation).
2052  * Any other error is reported via elog.
2053  *
2054  * NB: caller should already have at least AccessShareLock on the
2055  * relation ID, else there are nasty race conditions.
2056  *
2057  * NB: relation ref count is incremented, or set to 1 if new entry.
2058  * Caller should eventually decrement count. (Usually,
2059  * that happens by calling RelationClose().)
2060  */
2061 Relation
2063 {
2064  Relation rd;
2065 
2066  /* Make sure we're in an xact, even if this ends up being a cache hit */
2068 
2069  /*
2070  * first try to find reldesc in the cache
2071  */
2072  RelationIdCacheLookup(relationId, rd);
2073 
2074  if (RelationIsValid(rd))
2075  {
2076  /* return NULL for dropped relations */
2078  {
2079  Assert(!rd->rd_isvalid);
2080  return NULL;
2081  }
2082 
2084  /* revalidate cache entry if necessary */
2085  if (!rd->rd_isvalid)
2086  {
2087  /*
2088  * Indexes only have a limited number of possible schema changes,
2089  * and we don't want to use the full-blown procedure because it's
2090  * a headache for indexes that reload itself depends on.
2091  */
2092  if (rd->rd_rel->relkind == RELKIND_INDEX ||
2093  rd->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
2095  else
2096  RelationClearRelation(rd, true);
2097 
2098  /*
2099  * Normally entries need to be valid here, but before the relcache
2100  * has been initialized, not enough infrastructure exists to
2101  * perform pg_class lookups. The structure of such entries doesn't
2102  * change, but we still want to update the rd_rel entry. So
2103  * rd_isvalid = false is left in place for a later lookup.
2104  */
2105  Assert(rd->rd_isvalid ||
2107  }
2108  return rd;
2109  }
2110 
2111  /*
2112  * no reldesc in the cache, so have RelationBuildDesc() build one and add
2113  * it.
2114  */
2115  rd = RelationBuildDesc(relationId, true);
2116  if (RelationIsValid(rd))
2118  return rd;
2119 }
2120 
2121 /* ----------------------------------------------------------------
2122  * cache invalidation support routines
2123  * ----------------------------------------------------------------
2124  */
2125 
2126 /* ResourceOwner callbacks to track relcache references */
2127 static void ResOwnerReleaseRelation(Datum res);
2128 static char *ResOwnerPrintRelCache(Datum res);
2129 
2131 {
2132  .name = "relcache reference",
2133  .release_phase = RESOURCE_RELEASE_BEFORE_LOCKS,
2134  .release_priority = RELEASE_PRIO_RELCACHE_REFS,
2135  .ReleaseResource = ResOwnerReleaseRelation,
2136  .DebugPrint = ResOwnerPrintRelCache
2137 };
2138 
2139 /* Convenience wrappers over ResourceOwnerRemember/Forget */
2140 static inline void
2142 {
2144 }
2145 static inline void
2147 {
2149 }
2150 
2151 /*
2152  * RelationIncrementReferenceCount
2153  * Increments relation reference count.
2154  *
2155  * Note: bootstrap mode has its own weird ideas about relation refcount
2156  * behavior; we ought to fix it someday, but for now, just disable
2157  * reference count ownership tracking in bootstrap mode.
2158  */
2159 void
2161 {
2163  rel->rd_refcnt += 1;
2166 }
2167 
2168 /*
2169  * RelationDecrementReferenceCount
2170  * Decrements relation reference count.
2171  */
2172 void
2174 {
2175  Assert(rel->rd_refcnt > 0);
2176  rel->rd_refcnt -= 1;
2179 }
2180 
2181 /*
2182  * RelationClose - close an open relation
2183  *
2184  * Actually, we just decrement the refcount.
2185  *
2186  * NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries
2187  * will be freed as soon as their refcount goes to zero. In combination
2188  * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
2189  * to catch references to already-released relcache entries. It slows
2190  * things down quite a bit, however.
2191  */
2192 void
2194 {
2195  /* Note: no locking manipulations needed */
2197 
2198  RelationCloseCleanup(relation);
2199 }
2200 
2201 static void
2203 {
2204  /*
2205  * If the relation is no longer open in this session, we can clean up any
2206  * stale partition descriptors it has. This is unlikely, so check to see
2207  * if there are child contexts before expending a call to mcxt.c.
2208  */
2209  if (RelationHasReferenceCountZero(relation))
2210  {
2211  if (relation->rd_pdcxt != NULL &&
2212  relation->rd_pdcxt->firstchild != NULL)
2214 
2215  if (relation->rd_pddcxt != NULL &&
2216  relation->rd_pddcxt->firstchild != NULL)
2218  }
2219 
2220 #ifdef RELCACHE_FORCE_RELEASE
2221  if (RelationHasReferenceCountZero(relation) &&
2222  relation->rd_createSubid == InvalidSubTransactionId &&
2224  RelationClearRelation(relation, false);
2225 #endif
2226 }
2227 
2228 /*
2229  * RelationReloadIndexInfo - reload minimal information for an open index
2230  *
2231  * This function is used only for indexes. A relcache inval on an index
2232  * can mean that its pg_class or pg_index row changed. There are only
2233  * very limited changes that are allowed to an existing index's schema,
2234  * so we can update the relcache entry without a complete rebuild; which
2235  * is fortunate because we can't rebuild an index entry that is "nailed"
2236  * and/or in active use. We support full replacement of the pg_class row,
2237  * as well as updates of a few simple fields of the pg_index row.
2238  *
2239  * We can't necessarily reread the catalog rows right away; we might be
2240  * in a failed transaction when we receive the SI notification. If so,
2241  * RelationClearRelation just marks the entry as invalid by setting
2242  * rd_isvalid to false. This routine is called to fix the entry when it
2243  * is next needed.
2244  *
2245  * We assume that at the time we are called, we have at least AccessShareLock
2246  * on the target index. (Note: in the calls from RelationClearRelation,
2247  * this is legitimate because we know the rel has positive refcount.)
2248  *
2249  * If the target index is an index on pg_class or pg_index, we'd better have
2250  * previously gotten at least AccessShareLock on its underlying catalog,
2251  * else we are at risk of deadlock against someone trying to exclusive-lock
2252  * the heap and index in that order. This is ensured in current usage by
2253  * only applying this to indexes being opened or having positive refcount.
2254  */
2255 static void
2257 {
2258  bool indexOK;
2259  HeapTuple pg_class_tuple;
2260  Form_pg_class relp;
2261 
2262  /* Should be called only for invalidated, live indexes */
2263  Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
2264  relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
2265  !relation->rd_isvalid &&
2267 
2268  /* Ensure it's closed at smgr level */
2269  RelationCloseSmgr(relation);
2270 
2271  /* Must free any AM cached data upon relcache flush */
2272  if (relation->rd_amcache)
2273  pfree(relation->rd_amcache);
2274  relation->rd_amcache = NULL;
2275 
2276  /*
2277  * If it's a shared index, we might be called before backend startup has
2278  * finished selecting a database, in which case we have no way to read
2279  * pg_class yet. However, a shared index can never have any significant
2280  * schema updates, so it's okay to ignore the invalidation signal. Just
2281  * mark it valid and return without doing anything more.
2282  */
2283  if (relation->rd_rel->relisshared && !criticalRelcachesBuilt)
2284  {
2285  relation->rd_isvalid = true;
2286  return;
2287  }
2288 
2289  /*
2290  * Read the pg_class row
2291  *
2292  * Don't try to use an indexscan of pg_class_oid_index to reload the info
2293  * for pg_class_oid_index ...
2294  */
2295  indexOK = (RelationGetRelid(relation) != ClassOidIndexId);
2296  pg_class_tuple = ScanPgRelation(RelationGetRelid(relation), indexOK, false);
2297  if (!HeapTupleIsValid(pg_class_tuple))
2298  elog(ERROR, "could not find pg_class tuple for index %u",
2299  RelationGetRelid(relation));
2300  relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
2301  memcpy(relation->rd_rel, relp, CLASS_TUPLE_SIZE);
2302  /* Reload reloptions in case they changed */
2303  if (relation->rd_options)
2304  pfree(relation->rd_options);
2305  RelationParseRelOptions(relation, pg_class_tuple);
2306  /* done with pg_class tuple */
2307  heap_freetuple(pg_class_tuple);
2308  /* We must recalculate physical address in case it changed */
2309  RelationInitPhysicalAddr(relation);
2310 
2311  /*
2312  * For a non-system index, there are fields of the pg_index row that are
2313  * allowed to change, so re-read that row and update the relcache entry.
2314  * Most of the info derived from pg_index (such as support function lookup
2315  * info) cannot change, and indeed the whole point of this routine is to
2316  * update the relcache entry without clobbering that data; so wholesale
2317  * replacement is not appropriate.
2318  */
2319  if (!IsSystemRelation(relation))
2320  {
2321  HeapTuple tuple;
2323 
2324  tuple = SearchSysCache1(INDEXRELID,
2325  ObjectIdGetDatum(RelationGetRelid(relation)));
2326  if (!HeapTupleIsValid(tuple))
2327  elog(ERROR, "cache lookup failed for index %u",
2328  RelationGetRelid(relation));
2329  index = (Form_pg_index) GETSTRUCT(tuple);
2330 
2331  /*
2332  * Basically, let's just copy all the bool fields. There are one or
2333  * two of these that can't actually change in the current code, but
2334  * it's not worth it to track exactly which ones they are. None of
2335  * the array fields are allowed to change, though.
2336  */
2337  relation->rd_index->indisunique = index->indisunique;
2338  relation->rd_index->indnullsnotdistinct = index->indnullsnotdistinct;
2339  relation->rd_index->indisprimary = index->indisprimary;
2340  relation->rd_index->indisexclusion = index->indisexclusion;
2341  relation->rd_index->indimmediate = index->indimmediate;
2342  relation->rd_index->indisclustered = index->indisclustered;
2343  relation->rd_index->indisvalid = index->indisvalid;
2344  relation->rd_index->indcheckxmin = index->indcheckxmin;
2345  relation->rd_index->indisready = index->indisready;
2346  relation->rd_index->indislive = index->indislive;
2347  relation->rd_index->indisreplident = index->indisreplident;
2348 
2349  /* Copy xmin too, as that is needed to make sense of indcheckxmin */
2351  HeapTupleHeaderGetXmin(tuple->t_data));
2352 
2353  ReleaseSysCache(tuple);
2354  }
2355 
2356  /* Okay, now it's valid again */
2357  relation->rd_isvalid = true;
2358 }
2359 
2360 /*
2361  * RelationReloadNailed - reload minimal information for nailed relations.
2362  *
2363  * The structure of a nailed relation can never change (which is good, because
2364  * we rely on knowing their structure to be able to read catalog content). But
2365  * some parts, e.g. pg_class.relfrozenxid, are still important to have
2366  * accurate content for. Therefore those need to be reloaded after the arrival
2367  * of invalidations.
2368  */
2369 static void
2371 {
2372  Assert(relation->rd_isnailed);
2373 
2374  /*
2375  * Redo RelationInitPhysicalAddr in case it is a mapped relation whose
2376  * mapping changed.
2377  */
2378  RelationInitPhysicalAddr(relation);
2379 
2380  /* flag as needing to be revalidated */
2381  relation->rd_isvalid = false;
2382 
2383  /*
2384  * Can only reread catalog contents if in a transaction. If the relation
2385  * is currently open (not counting the nailed refcount), do so
2386  * immediately. Otherwise we've already marked the entry as possibly
2387  * invalid, and it'll be fixed when next opened.
2388  */
2389  if (!IsTransactionState() || relation->rd_refcnt <= 1)
2390  return;
2391 
2392  if (relation->rd_rel->relkind == RELKIND_INDEX)
2393  {
2394  /*
2395  * If it's a nailed-but-not-mapped index, then we need to re-read the
2396  * pg_class row to see if its relfilenumber changed.
2397  */
2398  RelationReloadIndexInfo(relation);
2399  }
2400  else
2401  {
2402  /*
2403  * Reload a non-index entry. We can't easily do so if relcaches
2404  * aren't yet built, but that's fine because at that stage the
2405  * attributes that need to be current (like relfrozenxid) aren't yet
2406  * accessed. To ensure the entry will later be revalidated, we leave
2407  * it in invalid state, but allow use (cf. RelationIdGetRelation()).
2408  */
2410  {
2411  HeapTuple pg_class_tuple;
2412  Form_pg_class relp;
2413 
2414  /*
2415  * NB: Mark the entry as valid before starting to scan, to avoid
2416  * self-recursion when re-building pg_class.
2417  */
2418  relation->rd_isvalid = true;
2419 
2420  pg_class_tuple = ScanPgRelation(RelationGetRelid(relation),
2421  true, false);
2422  relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
2423  memcpy(relation->rd_rel, relp, CLASS_TUPLE_SIZE);
2424  heap_freetuple(pg_class_tuple);
2425 
2426  /*
2427  * Again mark as valid, to protect against concurrently arriving
2428  * invalidations.
2429  */
2430  relation->rd_isvalid = true;
2431  }
2432  }
2433 }
2434 
2435 /*
2436  * RelationDestroyRelation
2437  *
2438  * Physically delete a relation cache entry and all subsidiary data.
2439  * Caller must already have unhooked the entry from the hash table.
2440  */
2441 static void
2442 RelationDestroyRelation(Relation relation, bool remember_tupdesc)
2443 {
2445 
2446  /*
2447  * Make sure smgr and lower levels close the relation's files, if they
2448  * weren't closed already. (This was probably done by caller, but let's
2449  * just be real sure.)
2450  */
2451  RelationCloseSmgr(relation);
2452 
2453  /* break mutual link with stats entry */
2454  pgstat_unlink_relation(relation);
2455 
2456  /*
2457  * Free all the subsidiary data structures of the relcache entry, then the
2458  * entry itself.
2459  */
2460  if (relation->rd_rel)
2461  pfree(relation->rd_rel);
2462  /* can't use DecrTupleDescRefCount here */
2463  Assert(relation->rd_att->tdrefcount > 0);
2464  if (--relation->rd_att->tdrefcount == 0)
2465  {
2466  /*
2467  * If we Rebuilt a relcache entry during a transaction then its
2468  * possible we did that because the TupDesc changed as the result of
2469  * an ALTER TABLE that ran at less than AccessExclusiveLock. It's
2470  * possible someone copied that TupDesc, in which case the copy would
2471  * point to free'd memory. So if we rebuild an entry we keep the
2472  * TupDesc around until end of transaction, to be safe.
2473  */
2474  if (remember_tupdesc)
2476  else
2477  FreeTupleDesc(relation->rd_att);
2478  }
2479  FreeTriggerDesc(relation->trigdesc);
2480  list_free_deep(relation->rd_fkeylist);
2481  list_free(relation->rd_indexlist);
2482  list_free(relation->rd_statlist);
2483  bms_free(relation->rd_keyattr);
2484  bms_free(relation->rd_pkattr);
2485  bms_free(relation->rd_idattr);
2486  bms_free(relation->rd_hotblockingattr);
2487  bms_free(relation->rd_summarizedattr);
2488  if (relation->rd_pubdesc)
2489  pfree(relation->rd_pubdesc);
2490  if (relation->rd_options)
2491  pfree(relation->rd_options);
2492  if (relation->rd_indextuple)
2493  pfree(relation->rd_indextuple);
2494  if (relation->rd_amcache)
2495  pfree(relation->rd_amcache);
2496  if (relation->rd_fdwroutine)
2497  pfree(relation->rd_fdwroutine);
2498  if (relation->rd_indexcxt)
2499  MemoryContextDelete(relation->rd_indexcxt);
2500  if (relation->rd_rulescxt)
2501  MemoryContextDelete(relation->rd_rulescxt);
2502  if (relation->rd_rsdesc)
2503  MemoryContextDelete(relation->rd_rsdesc->rscxt);
2504  if (relation->rd_partkeycxt)
2506  if (relation->rd_pdcxt)
2507  MemoryContextDelete(relation->rd_pdcxt);
2508  if (relation->rd_pddcxt)
2509  MemoryContextDelete(relation->rd_pddcxt);
2510  if (relation->rd_partcheckcxt)
2512  pfree(relation);
2513 }
2514 
2515 /*
2516  * RelationClearRelation
2517  *
2518  * Physically blow away a relation cache entry, or reset it and rebuild
2519  * it from scratch (that is, from catalog entries). The latter path is
2520  * used when we are notified of a change to an open relation (one with
2521  * refcount > 0).
2522  *
2523  * NB: when rebuilding, we'd better hold some lock on the relation,
2524  * else the catalog data we need to read could be changing under us.
2525  * Also, a rel to be rebuilt had better have refcnt > 0. This is because
2526  * a sinval reset could happen while we're accessing the catalogs, and
2527  * the rel would get blown away underneath us by RelationCacheInvalidate
2528  * if it has zero refcnt.
2529  *
2530  * The "rebuild" parameter is redundant in current usage because it has
2531  * to match the relation's refcnt status, but we keep it as a crosscheck
2532  * that we're doing what the caller expects.
2533  */
2534 static void
2535 RelationClearRelation(Relation relation, bool rebuild)
2536 {
2537  /*
2538  * As per notes above, a rel to be rebuilt MUST have refcnt > 0; while of
2539  * course it would be an equally bad idea to blow away one with nonzero
2540  * refcnt, since that would leave someone somewhere with a dangling
2541  * pointer. All callers are expected to have verified that this holds.
2542  */
2543  Assert(rebuild ?
2544  !RelationHasReferenceCountZero(relation) :
2545  RelationHasReferenceCountZero(relation));
2546 
2547  /*
2548  * Make sure smgr and lower levels close the relation's files, if they
2549  * weren't closed already. If the relation is not getting deleted, the
2550  * next smgr access should reopen the files automatically. This ensures
2551  * that the low-level file access state is updated after, say, a vacuum
2552  * truncation.
2553  */
2554  RelationCloseSmgr(relation);
2555 
2556  /* Free AM cached data, if any */
2557  if (relation->rd_amcache)
2558  pfree(relation->rd_amcache);
2559  relation->rd_amcache = NULL;
2560 
2561  /*
2562  * Treat nailed-in system relations separately, they always need to be
2563  * accessible, so we can't blow them away.
2564  */
2565  if (relation->rd_isnailed)
2566  {
2567  RelationReloadNailed(relation);
2568  return;
2569  }
2570 
2571  /* Mark it invalid until we've finished rebuild */
2572  relation->rd_isvalid = false;
2573 
2574  /* See RelationForgetRelation(). */
2575  if (relation->rd_droppedSubid != InvalidSubTransactionId)
2576  return;
2577 
2578  /*
2579  * Even non-system indexes should not be blown away if they are open and
2580  * have valid index support information. This avoids problems with active
2581  * use of the index support information. As with nailed indexes, we
2582  * re-read the pg_class row to handle possible physical relocation of the
2583  * index, and we check for pg_index updates too.
2584  */
2585  if ((relation->rd_rel->relkind == RELKIND_INDEX ||
2586  relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
2587  relation->rd_refcnt > 0 &&
2588  relation->rd_indexcxt != NULL)
2589  {
2590  if (IsTransactionState())
2591  RelationReloadIndexInfo(relation);
2592  return;
2593  }
2594 
2595  /*
2596  * If we're really done with the relcache entry, blow it away. But if
2597  * someone is still using it, reconstruct the whole deal without moving
2598  * the physical RelationData record (so that the someone's pointer is
2599  * still valid).
2600  */
2601  if (!rebuild)
2602  {
2603  /* Remove it from the hash table */
2604  RelationCacheDelete(relation);
2605 
2606  /* And release storage */
2607  RelationDestroyRelation(relation, false);
2608  }
2609  else if (!IsTransactionState())
2610  {
2611  /*
2612  * If we're not inside a valid transaction, we can't do any catalog
2613  * access so it's not possible to rebuild yet. Just exit, leaving
2614  * rd_isvalid = false so that the rebuild will occur when the entry is
2615  * next opened.
2616  *
2617  * Note: it's possible that we come here during subtransaction abort,
2618  * and the reason for wanting to rebuild is that the rel is open in
2619  * the outer transaction. In that case it might seem unsafe to not
2620  * rebuild immediately, since whatever code has the rel already open
2621  * will keep on using the relcache entry as-is. However, in such a
2622  * case the outer transaction should be holding a lock that's
2623  * sufficient to prevent any significant change in the rel's schema,
2624  * so the existing entry contents should be good enough for its
2625  * purposes; at worst we might be behind on statistics updates or the
2626  * like. (See also CheckTableNotInUse() and its callers.) These same
2627  * remarks also apply to the cases above where we exit without having
2628  * done RelationReloadIndexInfo() yet.
2629  */
2630  return;
2631  }
2632  else
2633  {
2634  /*
2635  * Our strategy for rebuilding an open relcache entry is to build a
2636  * new entry from scratch, swap its contents with the old entry, and
2637  * finally delete the new entry (along with any infrastructure swapped
2638  * over from the old entry). This is to avoid trouble in case an
2639  * error causes us to lose control partway through. The old entry
2640  * will still be marked !rd_isvalid, so we'll try to rebuild it again
2641  * on next access. Meanwhile it's not any less valid than it was
2642  * before, so any code that might expect to continue accessing it
2643  * isn't hurt by the rebuild failure. (Consider for example a
2644  * subtransaction that ALTERs a table and then gets canceled partway
2645  * through the cache entry rebuild. The outer transaction should
2646  * still see the not-modified cache entry as valid.) The worst
2647  * consequence of an error is leaking the necessarily-unreferenced new
2648  * entry, and this shouldn't happen often enough for that to be a big
2649  * problem.
2650  *
2651  * When rebuilding an open relcache entry, we must preserve ref count,
2652  * rd_*Subid, and rd_toastoid state. Also attempt to preserve the
2653  * pg_class entry (rd_rel), tupledesc, rewrite-rule, partition key,
2654  * and partition descriptor substructures in place, because various
2655  * places assume that these structures won't move while they are
2656  * working with an open relcache entry. (Note: the refcount
2657  * mechanism for tupledescs might someday allow us to remove this hack
2658  * for the tupledesc.)
2659  *
2660  * Note that this process does not touch CurrentResourceOwner; which
2661  * is good because whatever ref counts the entry may have do not
2662  * necessarily belong to that resource owner.
2663  */
2664  Relation newrel;
2665  Oid save_relid = RelationGetRelid(relation);
2666  bool keep_tupdesc;
2667  bool keep_rules;
2668  bool keep_policies;
2669  bool keep_partkey;
2670 
2671  /* Build temporary entry, but don't link it into hashtable */
2672  newrel = RelationBuildDesc(save_relid, false);
2673 
2674  /*
2675  * Between here and the end of the swap, don't add code that does or
2676  * reasonably could read system catalogs. That range must be free
2677  * from invalidation processing. See RelationBuildDesc() manipulation
2678  * of in_progress_list.
2679  */
2680 
2681  if (newrel == NULL)
2682  {
2683  /*
2684  * We can validly get here, if we're using a historic snapshot in
2685  * which a relation, accessed from outside logical decoding, is
2686  * still invisible. In that case it's fine to just mark the
2687  * relation as invalid and return - it'll fully get reloaded by
2688  * the cache reset at the end of logical decoding (or at the next
2689  * access). During normal processing we don't want to ignore this
2690  * case as it shouldn't happen there, as explained below.
2691  */
2692  if (HistoricSnapshotActive())
2693  return;
2694 
2695  /*
2696  * This shouldn't happen as dropping a relation is intended to be
2697  * impossible if still referenced (cf. CheckTableNotInUse()). But
2698  * if we get here anyway, we can't just delete the relcache entry,
2699  * as it possibly could get accessed later (as e.g. the error
2700  * might get trapped and handled via a subtransaction rollback).
2701  */
2702  elog(ERROR, "relation %u deleted while still in use", save_relid);
2703  }
2704 
2705  /*
2706  * If we were to, again, have cases of the relkind of a relcache entry
2707  * changing, we would need to ensure that pgstats does not get
2708  * confused.
2709  */
2710  Assert(relation->rd_rel->relkind == newrel->rd_rel->relkind);
2711 
2712  keep_tupdesc = equalTupleDescs(relation->rd_att, newrel->rd_att);
2713  keep_rules = equalRuleLocks(relation->rd_rules, newrel->rd_rules);
2714  keep_policies = equalRSDesc(relation->rd_rsdesc, newrel->rd_rsdesc);
2715  /* partkey is immutable once set up, so we can always keep it */
2716  keep_partkey = (relation->rd_partkey != NULL);
2717 
2718  /*
2719  * Perform swapping of the relcache entry contents. Within this
2720  * process the old entry is momentarily invalid, so there *must* be no
2721  * possibility of CHECK_FOR_INTERRUPTS within this sequence. Do it in
2722  * all-in-line code for safety.
2723  *
2724  * Since the vast majority of fields should be swapped, our method is
2725  * to swap the whole structures and then re-swap those few fields we
2726  * didn't want swapped.
2727  */
2728 #define SWAPFIELD(fldtype, fldname) \
2729  do { \
2730  fldtype _tmp = newrel->fldname; \
2731  newrel->fldname = relation->fldname; \
2732  relation->fldname = _tmp; \
2733  } while (0)
2734 
2735  /* swap all Relation struct fields */
2736  {
2737  RelationData tmpstruct;
2738 
2739  memcpy(&tmpstruct, newrel, sizeof(RelationData));
2740  memcpy(newrel, relation, sizeof(RelationData));
2741  memcpy(relation, &tmpstruct, sizeof(RelationData));
2742  }
2743 
2744  /* rd_smgr must not be swapped, due to back-links from smgr level */
2745  SWAPFIELD(SMgrRelation, rd_smgr);
2746  /* rd_refcnt must be preserved */
2747  SWAPFIELD(int, rd_refcnt);
2748  /* isnailed shouldn't change */
2749  Assert(newrel->rd_isnailed == relation->rd_isnailed);
2750  /* creation sub-XIDs must be preserved */
2751  SWAPFIELD(SubTransactionId, rd_createSubid);
2752  SWAPFIELD(SubTransactionId, rd_newRelfilelocatorSubid);
2753  SWAPFIELD(SubTransactionId, rd_firstRelfilelocatorSubid);
2754  SWAPFIELD(SubTransactionId, rd_droppedSubid);
2755  /* un-swap rd_rel pointers, swap contents instead */
2756  SWAPFIELD(Form_pg_class, rd_rel);
2757  /* ... but actually, we don't have to update newrel->rd_rel */
2758  memcpy(relation->rd_rel, newrel->rd_rel, CLASS_TUPLE_SIZE);
2759  /* preserve old tupledesc, rules, policies if no logical change */
2760  if (keep_tupdesc)
2761  SWAPFIELD(TupleDesc, rd_att);
2762  if (keep_rules)
2763  {
2764  SWAPFIELD(RuleLock *, rd_rules);
2765  SWAPFIELD(MemoryContext, rd_rulescxt);
2766  }
2767  if (keep_policies)
2768  SWAPFIELD(RowSecurityDesc *, rd_rsdesc);
2769  /* toast OID override must be preserved */
2770  SWAPFIELD(Oid, rd_toastoid);
2771  /* pgstat_info / enabled must be preserved */
2772  SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
2773  SWAPFIELD(bool, pgstat_enabled);
2774  /* preserve old partition key if we have one */
2775  if (keep_partkey)
2776  {
2777  SWAPFIELD(PartitionKey, rd_partkey);
2778  SWAPFIELD(MemoryContext, rd_partkeycxt);
2779  }
2780  if (newrel->rd_pdcxt != NULL || newrel->rd_pddcxt != NULL)
2781  {
2782  /*
2783  * We are rebuilding a partitioned relation with a non-zero
2784  * reference count, so we must keep the old partition descriptor
2785  * around, in case there's a PartitionDirectory with a pointer to
2786  * it. This means we can't free the old rd_pdcxt yet. (This is
2787  * necessary because RelationGetPartitionDesc hands out direct
2788  * pointers to the relcache's data structure, unlike our usual
2789  * practice which is to hand out copies. We'd have the same
2790  * problem with rd_partkey, except that we always preserve that
2791  * once created.)
2792  *
2793  * To ensure that it's not leaked completely, re-attach it to the
2794  * new reldesc, or make it a child of the new reldesc's rd_pdcxt
2795  * in the unlikely event that there is one already. (Compare hack
2796  * in RelationBuildPartitionDesc.) RelationClose will clean up
2797  * any such contexts once the reference count reaches zero.
2798  *
2799  * In the case where the reference count is zero, this code is not
2800  * reached, which should be OK because in that case there should
2801  * be no PartitionDirectory with a pointer to the old entry.
2802  *
2803  * Note that newrel and relation have already been swapped, so the
2804  * "old" partition descriptor is actually the one hanging off of
2805  * newrel.
2806  */
2807  relation->rd_partdesc = NULL; /* ensure rd_partdesc is invalid */
2808  relation->rd_partdesc_nodetached = NULL;
2810  if (relation->rd_pdcxt != NULL) /* probably never happens */
2811  MemoryContextSetParent(newrel->rd_pdcxt, relation->rd_pdcxt);
2812  else
2813  relation->rd_pdcxt = newrel->rd_pdcxt;
2814  if (relation->rd_pddcxt != NULL)
2815  MemoryContextSetParent(newrel->rd_pddcxt, relation->rd_pddcxt);
2816  else
2817  relation->rd_pddcxt = newrel->rd_pddcxt;
2818  /* drop newrel's pointers so we don't destroy it below */
2819  newrel->rd_partdesc = NULL;
2820  newrel->rd_partdesc_nodetached = NULL;
2822  newrel->rd_pdcxt = NULL;
2823  newrel->rd_pddcxt = NULL;
2824  }
2825 
2826 #undef SWAPFIELD
2827 
2828  /* And now we can throw away the temporary entry */
2829  RelationDestroyRelation(newrel, !keep_tupdesc);
2830  }
2831 }
2832 
2833 /*
2834  * RelationFlushRelation
2835  *
2836  * Rebuild the relation if it is open (refcount > 0), else blow it away.
2837  * This is used when we receive a cache invalidation event for the rel.
2838  */
2839 static void
2841 {
2842  if (relation->rd_createSubid != InvalidSubTransactionId ||
2844  {
2845  /*
2846  * New relcache entries are always rebuilt, not flushed; else we'd
2847  * forget the "new" status of the relation. Ditto for the
2848  * new-relfilenumber status.
2849  *
2850  * The rel could have zero refcnt here, so temporarily increment the
2851  * refcnt to ensure it's safe to rebuild it. We can assume that the
2852  * current transaction has some lock on the rel already.
2853  */
2855  RelationClearRelation(relation, true);
2857  }
2858  else
2859  {
2860  /*
2861  * Pre-existing rels can be dropped from the relcache if not open.
2862  */
2863  bool rebuild = !RelationHasReferenceCountZero(relation);
2864 
2865  RelationClearRelation(relation, rebuild);
2866  }
2867 }
2868 
2869 /*
2870  * RelationForgetRelation - caller reports that it dropped the relation
2871  */
2872 void
2874 {
2875  Relation relation;
2876 
2877  RelationIdCacheLookup(rid, relation);
2878 
2879  if (!PointerIsValid(relation))
2880  return; /* not in cache, nothing to do */
2881 
2882  if (!RelationHasReferenceCountZero(relation))
2883  elog(ERROR, "relation %u is still open", rid);
2884 
2886  if (relation->rd_createSubid != InvalidSubTransactionId ||
2888  {
2889  /*
2890  * In the event of subtransaction rollback, we must not forget
2891  * rd_*Subid. Mark the entry "dropped" so RelationClearRelation()
2892  * invalidates it in lieu of destroying it. (If we're in a top
2893  * transaction, we could opt to destroy the entry.)
2894  */
2896  }
2897 
2898  RelationClearRelation(relation, false);
2899 }
2900 
2901 /*
2902  * RelationCacheInvalidateEntry
2903  *
2904  * This routine is invoked for SI cache flush messages.
2905  *
2906  * Any relcache entry matching the relid must be flushed. (Note: caller has
2907  * already determined that the relid belongs to our database or is a shared
2908  * relation.)
2909  *
2910  * We used to skip local relations, on the grounds that they could
2911  * not be targets of cross-backend SI update messages; but it seems
2912  * safer to process them, so that our *own* SI update messages will
2913  * have the same effects during CommandCounterIncrement for both
2914  * local and nonlocal relations.
2915  */
2916 void
2918 {
2919  Relation relation;
2920 
2921  RelationIdCacheLookup(relationId, relation);
2922 
2923  if (PointerIsValid(relation))
2924  {
2926  RelationFlushRelation(relation);
2927  }
2928  else
2929  {
2930  int i;
2931 
2932  for (i = 0; i < in_progress_list_len; i++)
2933  if (in_progress_list[i].reloid == relationId)
2934  in_progress_list[i].invalidated = true;
2935  }
2936 }
2937 
2938 /*
2939  * RelationCacheInvalidate
2940  * Blow away cached relation descriptors that have zero reference counts,
2941  * and rebuild those with positive reference counts. Also reset the smgr
2942  * relation cache and re-read relation mapping data.
2943  *
2944  * Apart from debug_discard_caches, this is currently used only to recover
2945  * from SI message buffer overflow, so we do not touch relations having
2946  * new-in-transaction relfilenumbers; they cannot be targets of cross-backend
2947  * SI updates (and our own updates now go through a separate linked list
2948  * that isn't limited by the SI message buffer size).
2949  *
2950  * We do this in two phases: the first pass deletes deletable items, and
2951  * the second one rebuilds the rebuildable items. This is essential for
2952  * safety, because hash_seq_search only copes with concurrent deletion of
2953  * the element it is currently visiting. If a second SI overflow were to
2954  * occur while we are walking the table, resulting in recursive entry to
2955  * this routine, we could crash because the inner invocation blows away
2956  * the entry next to be visited by the outer scan. But this way is OK,
2957  * because (a) during the first pass we won't process any more SI messages,
2958  * so hash_seq_search will complete safely; (b) during the second pass we
2959  * only hold onto pointers to nondeletable entries.
2960  *
2961  * The two-phase approach also makes it easy to update relfilenumbers for
2962  * mapped relations before we do anything else, and to ensure that the
2963  * second pass processes nailed-in-cache items before other nondeletable
2964  * items. This should ensure that system catalogs are up to date before
2965  * we attempt to use them to reload information about other open relations.
2966  *
2967  * After those two phases of work having immediate effects, we normally
2968  * signal any RelationBuildDesc() on the stack to start over. However, we
2969  * don't do this if called as part of debug_discard_caches. Otherwise,
2970  * RelationBuildDesc() would become an infinite loop.
2971  */
2972 void
2973 RelationCacheInvalidate(bool debug_discard)
2974 {
2975  HASH_SEQ_STATUS status;
2976  RelIdCacheEnt *idhentry;
2977  Relation relation;
2978  List *rebuildFirstList = NIL;
2979  List *rebuildList = NIL;
2980  ListCell *l;
2981  int i;
2982 
2983  /*
2984  * Reload relation mapping data before starting to reconstruct cache.
2985  */
2987 
2988  /* Phase 1 */
2989  hash_seq_init(&status, RelationIdCache);
2990 
2991  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
2992  {
2993  relation = idhentry->reldesc;
2994 
2995  /*
2996  * Ignore new relations; no other backend will manipulate them before
2997  * we commit. Likewise, before replacing a relation's relfilelocator,
2998  * we shall have acquired AccessExclusiveLock and drained any
2999  * applicable pending invalidations.
3000  */
3001  if (relation->rd_createSubid != InvalidSubTransactionId ||
3003  continue;
3004 
3006 
3007  if (RelationHasReferenceCountZero(relation))
3008  {
3009  /* Delete this entry immediately */
3010  Assert(!relation->rd_isnailed);
3011  RelationClearRelation(relation, false);
3012  }
3013  else
3014  {
3015  /*
3016  * If it's a mapped relation, immediately update its rd_locator in
3017  * case its relfilenumber changed. We must do this during phase 1
3018  * in case the relation is consulted during rebuild of other
3019  * relcache entries in phase 2. It's safe since consulting the
3020  * map doesn't involve any access to relcache entries.
3021  */
3022  if (RelationIsMapped(relation))
3023  RelationInitPhysicalAddr(relation);
3024 
3025  /*
3026  * Add this entry to list of stuff to rebuild in second pass.
3027  * pg_class goes to the front of rebuildFirstList while
3028  * pg_class_oid_index goes to the back of rebuildFirstList, so
3029  * they are done first and second respectively. Other nailed
3030  * relations go to the front of rebuildList, so they'll be done
3031  * next in no particular order; and everything else goes to the
3032  * back of rebuildList.
3033  */
3034  if (RelationGetRelid(relation) == RelationRelationId)
3035  rebuildFirstList = lcons(relation, rebuildFirstList);
3036  else if (RelationGetRelid(relation) == ClassOidIndexId)
3037  rebuildFirstList = lappend(rebuildFirstList, relation);
3038  else if (relation->rd_isnailed)
3039  rebuildList = lcons(relation, rebuildList);
3040  else
3041  rebuildList = lappend(rebuildList, relation);
3042  }
3043  }
3044 
3045  /*
3046  * We cannot destroy the SMgrRelations as there might still be references
3047  * to them, but close the underlying file descriptors.
3048  */
3049  smgrreleaseall();
3050 
3051  /* Phase 2: rebuild the items found to need rebuild in phase 1 */
3052  foreach(l, rebuildFirstList)
3053  {
3054  relation = (Relation) lfirst(l);
3055  RelationClearRelation(relation, true);
3056  }
3057  list_free(rebuildFirstList);
3058  foreach(l, rebuildList)
3059  {
3060  relation = (Relation) lfirst(l);
3061  RelationClearRelation(relation, true);
3062  }
3063  list_free(rebuildList);
3064 
3065  if (!debug_discard)
3066  /* Any RelationBuildDesc() on the stack must start over. */
3067  for (i = 0; i < in_progress_list_len; i++)
3068  in_progress_list[i].invalidated = true;
3069 }
3070 
3071 static void
3073 {
3074  if (EOXactTupleDescArray == NULL)
3075  {
3076  MemoryContext oldcxt;
3077 
3079 
3080  EOXactTupleDescArray = (TupleDesc *) palloc(16 * sizeof(TupleDesc));
3083  MemoryContextSwitchTo(oldcxt);
3084  }
3086  {
3087  int32 newlen = EOXactTupleDescArrayLen * 2;
3088 
3090 
3092  newlen * sizeof(TupleDesc));
3093  EOXactTupleDescArrayLen = newlen;
3094  }
3095 
3097 }
3098 
3099 #ifdef USE_ASSERT_CHECKING
3100 static void
3101 AssertPendingSyncConsistency(Relation relation)
3102 {
3103  bool relcache_verdict =
3104  RelationIsPermanent(relation) &&
3105  ((relation->rd_createSubid != InvalidSubTransactionId &&
3106  RELKIND_HAS_STORAGE(relation->rd_rel->relkind)) ||
3108 
3109  Assert(relcache_verdict == RelFileLocatorSkippingWAL(relation->rd_locator));
3110 
3111  if (relation->rd_droppedSubid != InvalidSubTransactionId)
3112  Assert(!relation->rd_isvalid &&
3113  (relation->rd_createSubid != InvalidSubTransactionId ||
3115 }
3116 
3117 /*
3118  * AssertPendingSyncs_RelationCache
3119  *
3120  * Assert that relcache.c and storage.c agree on whether to skip WAL.
3121  */
3122 void
3124 {
3125  HASH_SEQ_STATUS status;
3126  LOCALLOCK *locallock;
3127  Relation *rels;
3128  int maxrels;
3129  int nrels;
3130  RelIdCacheEnt *idhentry;
3131  int i;
3132 
3133  /*
3134  * Open every relation that this transaction has locked. If, for some
3135  * relation, storage.c is skipping WAL and relcache.c is not skipping WAL,
3136  * a CommandCounterIncrement() typically yields a local invalidation
3137  * message that destroys the relcache entry. By recreating such entries
3138  * here, we detect the problem.
3139  */
3141  maxrels = 1;
3142  rels = palloc(maxrels * sizeof(*rels));
3143  nrels = 0;
3144  hash_seq_init(&status, GetLockMethodLocalHash());
3145  while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
3146  {
3147  Oid relid;
3148  Relation r;
3149 
3150  if (locallock->nLocks <= 0)
3151  continue;
3152  if ((LockTagType) locallock->tag.lock.locktag_type !=
3154  continue;
3155  relid = ObjectIdGetDatum(locallock->tag.lock.locktag_field2);
3156  r = RelationIdGetRelation(relid);
3157  if (!RelationIsValid(r))
3158  continue;
3159  if (nrels >= maxrels)
3160  {
3161  maxrels *= 2;
3162  rels = repalloc(rels, maxrels * sizeof(*rels));
3163  }
3164  rels[nrels++] = r;
3165  }
3166 
3167  hash_seq_init(&status, RelationIdCache);
3168  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
3169  AssertPendingSyncConsistency(idhentry->reldesc);
3170 
3171  for (i = 0; i < nrels; i++)
3172  RelationClose(rels[i]);
3174 }
3175 #endif
3176 
3177 /*
3178  * AtEOXact_RelationCache
3179  *
3180  * Clean up the relcache at main-transaction commit or abort.
3181  *
3182  * Note: this must be called *before* processing invalidation messages.
3183  * In the case of abort, we don't want to try to rebuild any invalidated
3184  * cache entries (since we can't safely do database accesses). Therefore
3185  * we must reset refcnts before handling pending invalidations.
3186  *
3187  * As of PostgreSQL 8.1, relcache refcnts should get released by the
3188  * ResourceOwner mechanism. This routine just does a debugging
3189  * cross-check that no pins remain. However, we also need to do special
3190  * cleanup when the current transaction created any relations or made use
3191  * of forced index lists.
3192  */
3193 void
3195 {
3196  HASH_SEQ_STATUS status;
3197  RelIdCacheEnt *idhentry;
3198  int i;
3199 
3200  /*
3201  * Forget in_progress_list. This is relevant when we're aborting due to
3202  * an error during RelationBuildDesc().
3203  */
3204  Assert(in_progress_list_len == 0 || !isCommit);
3206 
3207  /*
3208  * Unless the eoxact_list[] overflowed, we only need to examine the rels
3209  * listed in it. Otherwise fall back on a hash_seq_search scan.
3210  *
3211  * For simplicity, eoxact_list[] entries are not deleted till end of
3212  * top-level transaction, even though we could remove them at
3213  * subtransaction end in some cases, or remove relations from the list if
3214  * they are cleared for other reasons. Therefore we should expect the
3215  * case that list entries are not found in the hashtable; if not, there's
3216  * nothing to do for them.
3217  */
3219  {
3220  hash_seq_init(&status, RelationIdCache);
3221  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
3222  {
3223  AtEOXact_cleanup(idhentry->reldesc, isCommit);
3224  }
3225  }
3226  else
3227  {
3228  for (i = 0; i < eoxact_list_len; i++)
3229  {
3230  idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
3231  &eoxact_list[i],
3232  HASH_FIND,
3233  NULL);
3234  if (idhentry != NULL)
3235  AtEOXact_cleanup(idhentry->reldesc, isCommit);
3236  }
3237  }
3238 
3239  if (EOXactTupleDescArrayLen > 0)
3240  {
3241  Assert(EOXactTupleDescArray != NULL);
3242  for (i = 0; i < NextEOXactTupleDescNum; i++)
3245  EOXactTupleDescArray = NULL;
3246  }
3247 
3248  /* Now we're out of the transaction and can clear the lists */
3249  eoxact_list_len = 0;
3250  eoxact_list_overflowed = false;
3253 }
3254 
3255 /*
3256  * AtEOXact_cleanup
3257  *
3258  * Clean up a single rel at main-transaction commit or abort
3259  *
3260  * NB: this processing must be idempotent, because EOXactListAdd() doesn't
3261  * bother to prevent duplicate entries in eoxact_list[].
3262  */
3263 static void
3264 AtEOXact_cleanup(Relation relation, bool isCommit)
3265 {
3266  bool clear_relcache = false;
3267 
3268  /*
3269  * The relcache entry's ref count should be back to its normal
3270  * not-in-a-transaction state: 0 unless it's nailed in cache.
3271  *
3272  * In bootstrap mode, this is NOT true, so don't check it --- the
3273  * bootstrap code expects relations to stay open across start/commit
3274  * transaction calls. (That seems bogus, but it's not worth fixing.)
3275  *
3276  * Note: ideally this check would be applied to every relcache entry, not
3277  * just those that have eoxact work to do. But it's not worth forcing a
3278  * scan of the whole relcache just for this. (Moreover, doing so would
3279  * mean that assert-enabled testing never tests the hash_search code path
3280  * above, which seems a bad idea.)
3281  */
3282 #ifdef USE_ASSERT_CHECKING
3284  {
3285  int expected_refcnt;
3286 
3287  expected_refcnt = relation->rd_isnailed ? 1 : 0;
3288  Assert(relation->rd_refcnt == expected_refcnt);
3289  }
3290 #endif
3291 
3292  /*
3293  * Is the relation live after this transaction ends?
3294  *
3295  * During commit, clear the relcache entry if it is preserved after
3296  * relation drop, in order not to orphan the entry. During rollback,
3297  * clear the relcache entry if the relation is created in the current
3298  * transaction since it isn't interesting any longer once we are out of
3299  * the transaction.
3300  */
3301  clear_relcache =
3302  (isCommit ?
3305 
3306  /*
3307  * Since we are now out of the transaction, reset the subids to zero. That
3308  * also lets RelationClearRelation() drop the relcache entry.
3309  */
3314 
3315  if (clear_relcache)
3316  {
3317  if (RelationHasReferenceCountZero(relation))
3318  {
3319  RelationClearRelation(relation, false);
3320  return;
3321  }
3322  else
3323  {
3324  /*
3325  * Hmm, somewhere there's a (leaked?) reference to the relation.
3326  * We daren't remove the entry for fear of dereferencing a
3327  * dangling pointer later. Bleat, and mark it as not belonging to
3328  * the current transaction. Hopefully it'll get cleaned up
3329  * eventually. This must be just a WARNING to avoid
3330  * error-during-error-recovery loops.
3331  */
3332  elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
3333  RelationGetRelationName(relation));
3334  }
3335  }
3336 }
3337 
3338 /*
3339  * AtEOSubXact_RelationCache
3340  *
3341  * Clean up the relcache at sub-transaction commit or abort.
3342  *
3343  * Note: this must be called *before* processing invalidation messages.
3344  */
3345 void
3347  SubTransactionId parentSubid)
3348 {
3349  HASH_SEQ_STATUS status;
3350  RelIdCacheEnt *idhentry;
3351  int i;
3352 
3353  /*
3354  * Forget in_progress_list. This is relevant when we're aborting due to
3355  * an error during RelationBuildDesc(). We don't commit subtransactions
3356  * during RelationBuildDesc().
3357  */
3358  Assert(in_progress_list_len == 0 || !isCommit);
3360 
3361  /*
3362  * Unless the eoxact_list[] overflowed, we only need to examine the rels
3363  * listed in it. Otherwise fall back on a hash_seq_search scan. Same
3364  * logic as in AtEOXact_RelationCache.
3365  */
3367  {
3368  hash_seq_init(&status, RelationIdCache);
3369  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
3370  {
3371  AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
3372  mySubid, parentSubid);
3373  }
3374  }
3375  else
3376  {
3377  for (i = 0; i < eoxact_list_len; i++)
3378  {
3379  idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
3380  &eoxact_list[i],
3381  HASH_FIND,
3382  NULL);
3383  if (idhentry != NULL)
3384  AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
3385  mySubid, parentSubid);
3386  }
3387  }
3388 
3389  /* Don't reset the list; we still need more cleanup later */
3390 }
3391 
3392 /*
3393  * AtEOSubXact_cleanup
3394  *
3395  * Clean up a single rel at subtransaction commit or abort
3396  *
3397  * NB: this processing must be idempotent, because EOXactListAdd() doesn't
3398  * bother to prevent duplicate entries in eoxact_list[].
3399  */
3400 static void
3401 AtEOSubXact_cleanup(Relation relation, bool isCommit,
3402  SubTransactionId mySubid, SubTransactionId parentSubid)
3403 {
3404  /*
3405  * Is it a relation created in the current subtransaction?
3406  *
3407  * During subcommit, mark it as belonging to the parent, instead, as long
3408  * as it has not been dropped. Otherwise simply delete the relcache entry.
3409  * --- it isn't interesting any longer.
3410  */
3411  if (relation->rd_createSubid == mySubid)
3412  {
3413  /*
3414  * Valid rd_droppedSubid means the corresponding relation is dropped
3415  * but the relcache entry is preserved for at-commit pending sync. We
3416  * need to drop it explicitly here not to make the entry orphan.
3417  */
3418  Assert(relation->rd_droppedSubid == mySubid ||
3420  if (isCommit && relation->rd_droppedSubid == InvalidSubTransactionId)
3421  relation->rd_createSubid = parentSubid;
3422  else if (RelationHasReferenceCountZero(relation))
3423  {
3424  /* allow the entry to be removed */
3429  RelationClearRelation(relation, false);
3430  return;
3431  }
3432  else
3433  {
3434  /*
3435  * Hmm, somewhere there's a (leaked?) reference to the relation.
3436  * We daren't remove the entry for fear of dereferencing a
3437  * dangling pointer later. Bleat, and transfer it to the parent
3438  * subtransaction so we can try again later. This must be just a
3439  * WARNING to avoid error-during-error-recovery loops.
3440  */
3441  relation->rd_createSubid = parentSubid;
3442  elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
3443  RelationGetRelationName(relation));
3444  }
3445  }
3446 
3447  /*
3448  * Likewise, update or drop any new-relfilenumber-in-subtransaction record
3449  * or drop record.
3450  */
3451  if (relation->rd_newRelfilelocatorSubid == mySubid)
3452  {
3453  if (isCommit)
3454  relation->rd_newRelfilelocatorSubid = parentSubid;
3455  else
3457  }
3458 
3459  if (relation->rd_firstRelfilelocatorSubid == mySubid)
3460  {
3461  if (isCommit)
3462  relation->rd_firstRelfilelocatorSubid = parentSubid;
3463  else
3465  }
3466 
3467  if (relation->rd_droppedSubid == mySubid)
3468  {
3469  if (isCommit)
3470  relation->rd_droppedSubid = parentSubid;
3471  else
3473  }
3474 }
3475 
3476 
3477 /*
3478  * RelationBuildLocalRelation
3479  * Build a relcache entry for an about-to-be-created relation,
3480  * and enter it into the relcache.
3481  */
3482 Relation
3484  Oid relnamespace,
3485  TupleDesc tupDesc,
3486  Oid relid,
3487  Oid accessmtd,
3488  RelFileNumber relfilenumber,
3489  Oid reltablespace,
3490  bool shared_relation,
3491  bool mapped_relation,
3492  char relpersistence,
3493  char relkind)
3494 {
3495  Relation rel;
3496  MemoryContext oldcxt;
3497  int natts = tupDesc->natts;
3498  int i;
3499  bool has_not_null;
3500  bool nailit;
3501 
3502  Assert(natts >= 0);
3503 
3504  /*
3505  * check for creation of a rel that must be nailed in cache.
3506  *
3507  * XXX this list had better match the relations specially handled in
3508  * RelationCacheInitializePhase2/3.
3509  */
3510  switch (relid)
3511  {
3512  case DatabaseRelationId:
3513  case AuthIdRelationId:
3514  case AuthMemRelationId:
3515  case RelationRelationId:
3516  case AttributeRelationId:
3517  case ProcedureRelationId:
3518  case TypeRelationId:
3519  nailit = true;
3520  break;
3521  default:
3522  nailit = false;
3523  break;
3524  }
3525 
3526  /*
3527  * check that hardwired list of shared rels matches what's in the
3528  * bootstrap .bki file. If you get a failure here during initdb, you
3529  * probably need to fix IsSharedRelation() to match whatever you've done
3530  * to the set of shared relations.
3531  */
3532  if (shared_relation != IsSharedRelation(relid))
3533  elog(ERROR, "shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
3534  relname, relid);
3535 
3536  /* Shared relations had better be mapped, too */
3537  Assert(mapped_relation || !shared_relation);
3538 
3539  /*
3540  * switch to the cache context to create the relcache entry.
3541  */
3542  if (!CacheMemoryContext)
3544 
3546 
3547  /*
3548  * allocate a new relation descriptor and fill in basic state fields.
3549  */
3550  rel = (Relation) palloc0(sizeof(RelationData));
3551 
3552  /* make sure relation is marked as having no open file yet */
3553  rel->rd_smgr = NULL;
3554 
3555  /* mark it nailed if appropriate */
3556  rel->rd_isnailed = nailit;
3557 
3558  rel->rd_refcnt = nailit ? 1 : 0;
3559 
3560  /* it's being created in this transaction */
3565 
3566  /*
3567  * create a new tuple descriptor from the one passed in. We do this
3568  * partly to copy it into the cache context, and partly because the new
3569  * relation can't have any defaults or constraints yet; they have to be
3570  * added in later steps, because they require additions to multiple system
3571  * catalogs. We can copy attnotnull constraints here, however.
3572  */
3573  rel->rd_att = CreateTupleDescCopy(tupDesc);
3574  rel->rd_att->tdrefcount = 1; /* mark as refcounted */
3575  has_not_null = false;
3576  for (i = 0; i < natts; i++)
3577  {
3578  Form_pg_attribute satt = TupleDescAttr(tupDesc, i);
3579  Form_pg_attribute datt = TupleDescAttr(rel->rd_att, i);
3580 
3581  datt->attidentity = satt->attidentity;
3582  datt->attgenerated = satt->attgenerated;
3583  datt->attnotnull = satt->attnotnull;
3584  has_not_null |= satt->attnotnull;
3585  }
3586 
3587  if (has_not_null)
3588  {
3589  TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
3590 
3591  constr->has_not_null = true;
3592  rel->rd_att->constr = constr;
3593  }
3594 
3595  /*
3596  * initialize relation tuple form (caller may add/override data later)
3597  */
3599 
3600  namestrcpy(&rel->rd_rel->relname, relname);
3601  rel->rd_rel->relnamespace = relnamespace;
3602 
3603  rel->rd_rel->relkind = relkind;
3604  rel->rd_rel->relnatts = natts;
3605  rel->rd_rel->reltype = InvalidOid;
3606  /* needed when bootstrapping: */
3607  rel->rd_rel->relowner = BOOTSTRAP_SUPERUSERID;
3608 
3609  /* set up persistence and relcache fields dependent on it */
3610  rel->rd_rel->relpersistence = relpersistence;
3611  switch (relpersistence)
3612  {
3613  case RELPERSISTENCE_UNLOGGED:
3614  case RELPERSISTENCE_PERMANENT:
3616  rel->rd_islocaltemp = false;
3617  break;
3618  case RELPERSISTENCE_TEMP:
3619  Assert(isTempOrTempToastNamespace(relnamespace));
3621  rel->rd_islocaltemp = true;
3622  break;
3623  default:
3624  elog(ERROR, "invalid relpersistence: %c", relpersistence);
3625  break;
3626  }
3627 
3628  /* if it's a materialized view, it's not populated initially */
3629  if (relkind == RELKIND_MATVIEW)
3630  rel->rd_rel->relispopulated = false;
3631  else
3632  rel->rd_rel->relispopulated = true;
3633 
3634  /* set replica identity -- system catalogs and non-tables don't have one */
3635  if (!IsCatalogNamespace(relnamespace) &&
3636  (relkind == RELKIND_RELATION ||
3637  relkind == RELKIND_MATVIEW ||
3638  relkind == RELKIND_PARTITIONED_TABLE))
3639  rel->rd_rel->relreplident = REPLICA_IDENTITY_DEFAULT;
3640  else
3641  rel->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
3642 
3643  /*
3644  * Insert relation physical and logical identifiers (OIDs) into the right
3645  * places. For a mapped relation, we set relfilenumber to zero and rely
3646  * on RelationInitPhysicalAddr to consult the map.
3647  */
3648  rel->rd_rel->relisshared = shared_relation;
3649 
3650  RelationGetRelid(rel) = relid;
3651 
3652  for (i = 0; i < natts; i++)
3653  TupleDescAttr(rel->rd_att, i)->attrelid = relid;
3654 
3655  rel->rd_rel->reltablespace = reltablespace;
3656 
3657  if (mapped_relation)
3658  {
3659  rel->rd_rel->relfilenode = InvalidRelFileNumber;
3660  /* Add it to the active mapping information */
3661  RelationMapUpdateMap(relid, relfilenumber, shared_relation, true);
3662  }
3663  else
3664  rel->rd_rel->relfilenode = relfilenumber;
3665 
3666  RelationInitLockInfo(rel); /* see lmgr.c */
3667 
3669 
3670  rel->rd_rel->relam = accessmtd;
3671 
3672  /*
3673  * RelationInitTableAccessMethod will do syscache lookups, so we mustn't
3674  * run it in CacheMemoryContext. Fortunately, the remaining steps don't
3675  * require a long-lived current context.
3676  */
3677  MemoryContextSwitchTo(oldcxt);
3678 
3679  if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_SEQUENCE)
3681 
3682  /*
3683  * Okay to insert into the relcache hash table.
3684  *
3685  * Ordinarily, there should certainly not be an existing hash entry for
3686  * the same OID; but during bootstrap, when we create a "real" relcache
3687  * entry for one of the bootstrap relations, we'll be overwriting the
3688  * phony one created with formrdesc. So allow that to happen for nailed
3689  * rels.
3690  */
3691  RelationCacheInsert(rel, nailit);
3692 
3693  /*
3694  * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
3695  * can't do this before storing relid in it.
3696  */
3697  EOXactListAdd(rel);
3698 
3699  /* It's fully valid */
3700  rel->rd_isvalid = true;
3701 
3702  /*
3703  * Caller expects us to pin the returned entry.
3704  */
3706 
3707  return rel;
3708 }
3709 
3710 
3711 /*
3712  * RelationSetNewRelfilenumber
3713  *
3714  * Assign a new relfilenumber (physical file name), and possibly a new
3715  * persistence setting, to the relation.
3716  *
3717  * This allows a full rewrite of the relation to be done with transactional
3718  * safety (since the filenumber assignment can be rolled back). Note however
3719  * that there is no simple way to access the relation's old data for the
3720  * remainder of the current transaction. This limits the usefulness to cases
3721  * such as TRUNCATE or rebuilding an index from scratch.
3722  *
3723  * Caller must already hold exclusive lock on the relation.
3724  */
3725 void
3726 RelationSetNewRelfilenumber(Relation relation, char persistence)
3727 {
3728  RelFileNumber newrelfilenumber;
3729  Relation pg_class;
3730  HeapTuple tuple;
3731  Form_pg_class classform;
3732  MultiXactId minmulti = InvalidMultiXactId;
3733  TransactionId freezeXid = InvalidTransactionId;
3734  RelFileLocator newrlocator;
3735 
3736  if (!IsBinaryUpgrade)
3737  {
3738  /* Allocate a new relfilenumber */
3739  newrelfilenumber = GetNewRelFileNumber(relation->rd_rel->reltablespace,
3740  NULL, persistence);
3741  }
3742  else if (relation->rd_rel->relkind == RELKIND_INDEX)
3743  {
3745  ereport(ERROR,
3746  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3747  errmsg("index relfilenumber value not set when in binary upgrade mode")));
3748 
3751  }
3752  else if (relation->rd_rel->relkind == RELKIND_RELATION)
3753  {
3755  ereport(ERROR,
3756  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3757  errmsg("heap relfilenumber value not set when in binary upgrade mode")));
3758 
3761  }
3762  else
3763  ereport(ERROR,
3764  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3765  errmsg("unexpected request for new relfilenumber in binary upgrade mode")));
3766 
3767  /*
3768  * Get a writable copy of the pg_class tuple for the given relation.
3769  */
3770  pg_class = table_open(RelationRelationId, RowExclusiveLock);
3771 
3772  tuple = SearchSysCacheCopy1(RELOID,
3773  ObjectIdGetDatum(RelationGetRelid(relation)));
3774  if (!HeapTupleIsValid(tuple))
3775  elog(ERROR, "could not find tuple for relation %u",
3776  RelationGetRelid(relation));
3777  classform = (Form_pg_class) GETSTRUCT(tuple);
3778 
3779  /*
3780  * Schedule unlinking of the old storage at transaction commit, except
3781  * when performing a binary upgrade, when we must do it immediately.
3782  */
3783  if (IsBinaryUpgrade)
3784  {
3785  SMgrRelation srel;
3786 
3787  /*
3788  * During a binary upgrade, we use this code path to ensure that
3789  * pg_largeobject and its index have the same relfilenumbers as in the
3790  * old cluster. This is necessary because pg_upgrade treats
3791  * pg_largeobject like a user table, not a system table. It is however
3792  * possible that a table or index may need to end up with the same
3793  * relfilenumber in the new cluster as what it had in the old cluster.
3794  * Hence, we can't wait until commit time to remove the old storage.
3795  *
3796  * In general, this function needs to have transactional semantics,
3797  * and removing the old storage before commit time surely isn't.
3798  * However, it doesn't really matter, because if a binary upgrade
3799  * fails at this stage, the new cluster will need to be recreated
3800  * anyway.
3801  */
3802  srel = smgropen(relation->rd_locator, relation->rd_backend);
3803  smgrdounlinkall(&srel, 1, false);
3804  smgrclose(srel);
3805  }
3806  else
3807  {
3808  /* Not a binary upgrade, so just schedule it to happen later. */
3809  RelationDropStorage(relation);
3810  }
3811 
3812  /*
3813  * Create storage for the main fork of the new relfilenumber. If it's a
3814  * table-like object, call into the table AM to do so, which'll also
3815  * create the table's init fork if needed.
3816  *
3817  * NOTE: If relevant for the AM, any conflict in relfilenumber value will
3818  * be caught here, if GetNewRelFileNumber messes up for any reason.
3819  */
3820  newrlocator = relation->rd_locator;
3821  newrlocator.relNumber = newrelfilenumber;
3822 
3823  if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind))
3824  {
3825  table_relation_set_new_filelocator(relation, &newrlocator,
3826  persistence,
3827  &freezeXid, &minmulti);
3828  }
3829  else if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
3830  {
3831  /* handle these directly, at least for now */
3832  SMgrRelation srel;
3833 
3834  srel = RelationCreateStorage(newrlocator, persistence, true);
3835  smgrclose(srel);
3836  }
3837  else
3838  {
3839  /* we shouldn't be called for anything else */
3840  elog(ERROR, "relation \"%s\" does not have storage",
3841  RelationGetRelationName(relation));
3842  }
3843 
3844  /*
3845  * If we're dealing with a mapped index, pg_class.relfilenode doesn't
3846  * change; instead we have to send the update to the relation mapper.
3847  *
3848  * For mapped indexes, we don't actually change the pg_class entry at all;
3849  * this is essential when reindexing pg_class itself. That leaves us with
3850  * possibly-inaccurate values of relpages etc, but those will be fixed up
3851  * later.
3852  */
3853  if (RelationIsMapped(relation))
3854  {
3855  /* This case is only supported for indexes */
3856  Assert(relation->rd_rel->relkind == RELKIND_INDEX);
3857 
3858  /* Since we're not updating pg_class, these had better not change */
3859  Assert(classform->relfrozenxid == freezeXid);
3860  Assert(classform->relminmxid == minmulti);
3861  Assert(classform->relpersistence == persistence);
3862 
3863  /*
3864  * In some code paths it's possible that the tuple update we'd
3865  * otherwise do here is the only thing that would assign an XID for
3866  * the current transaction. However, we must have an XID to delete
3867  * files, so make sure one is assigned.
3868  */
3869  (void) GetCurrentTransactionId();
3870 
3871  /* Do the deed */
3873  newrelfilenumber,
3874  relation->rd_rel->relisshared,
3875  false);
3876 
3877  /* Since we're not updating pg_class, must trigger inval manually */
3878  CacheInvalidateRelcache(relation);
3879  }
3880  else
3881  {
3882  /* Normal case, update the pg_class entry */
3883  classform->relfilenode = newrelfilenumber;
3884 
3885  /* relpages etc. never change for sequences */
3886  if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
3887  {
3888  classform->relpages = 0; /* it's empty until further notice */
3889  classform->reltuples = -1;
3890  classform->relallvisible = 0;
3891  }
3892  classform->relfrozenxid = freezeXid;
3893  classform->relminmxid = minmulti;
3894  classform->relpersistence = persistence;
3895 
3896  CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
3897  }
3898 
3899  heap_freetuple(tuple);
3900 
3901  table_close(pg_class, RowExclusiveLock);
3902 
3903  /*
3904  * Make the pg_class row change or relation map change visible. This will
3905  * cause the relcache entry to get updated, too.
3906  */
3908 
3910 }
3911 
3912 /*
3913  * RelationAssumeNewRelfilelocator
3914  *
3915  * Code that modifies pg_class.reltablespace or pg_class.relfilenode must call
3916  * this. The call shall precede any code that might insert WAL records whose
3917  * replay would modify bytes in the new RelFileLocator, and the call shall follow
3918  * any WAL modifying bytes in the prior RelFileLocator. See struct RelationData.
3919  * Ideally, call this as near as possible to the CommandCounterIncrement()
3920  * that makes the pg_class change visible (before it or after it); that
3921  * minimizes the chance of future development adding a forbidden WAL insertion
3922  * between RelationAssumeNewRelfilelocator() and CommandCounterIncrement().
3923  */
3924 void
3926 {
3930 
3931  /* Flag relation as needing eoxact cleanup (to clear these fields) */
3932  EOXactListAdd(relation);
3933 }
3934 
3935 
3936 /*
3937  * RelationCacheInitialize
3938  *
3939  * This initializes the relation descriptor cache. At the time
3940  * that this is invoked, we can't do database access yet (mainly
3941  * because the transaction subsystem is not up); all we are doing
3942  * is making an empty cache hashtable. This must be done before
3943  * starting the initialization transaction, because otherwise
3944  * AtEOXact_RelationCache would crash if that transaction aborts
3945  * before we can get the relcache set up.
3946  */
3947 
3948 #define INITRELCACHESIZE 400
3949 
3950 void
3952 {
3953  HASHCTL ctl;
3954  int allocsize;
3955 
3956  /*
3957  * make sure cache memory context exists
3958  */
3959  if (!CacheMemoryContext)
3961 
3962  /*
3963  * create hashtable that indexes the relcache
3964  */
3965  ctl.keysize = sizeof(Oid);
3966  ctl.entrysize = sizeof(RelIdCacheEnt);
3967  RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
3968  &ctl, HASH_ELEM | HASH_BLOBS);
3969 
3970  /*
3971  * reserve enough in_progress_list slots for many cases
3972  */
3973  allocsize = 4;
3976  allocsize * sizeof(*in_progress_list));
3977  in_progress_list_maxlen = allocsize;
3978 
3979  /*
3980  * relation mapper needs to be initialized too
3981  */
3983 }
3984 
3985 /*
3986  * RelationCacheInitializePhase2
3987  *
3988  * This is called to prepare for access to shared catalogs during startup.
3989  * We must at least set up nailed reldescs for pg_database, pg_authid,
3990  * pg_auth_members, and pg_shseclabel. Ideally we'd like to have reldescs
3991  * for their indexes, too. We attempt to load this information from the
3992  * shared relcache init file. If that's missing or broken, just make
3993  * phony entries for the catalogs themselves.
3994  * RelationCacheInitializePhase3 will clean up as needed.
3995  */
3996 void
3998 {
3999  MemoryContext oldcxt;
4000 
4001  /*
4002  * relation mapper needs initialized too
4003  */
4005 
4006  /*
4007  * In bootstrap mode, the shared catalogs aren't there yet anyway, so do
4008  * nothing.
4009  */
4011  return;
4012 
4013  /*
4014  * switch to cache memory context
4015  */
4017 
4018  /*
4019  * Try to load the shared relcache cache file. If unsuccessful, bootstrap
4020  * the cache with pre-made descriptors for the critical shared catalogs.
4021  */
4022  if (!load_relcache_init_file(true))
4023  {
4024  formrdesc("pg_database", DatabaseRelation_Rowtype_Id, true,
4025  Natts_pg_database, Desc_pg_database);
4026  formrdesc("pg_authid", AuthIdRelation_Rowtype_Id, true,
4027  Natts_pg_authid, Desc_pg_authid);
4028  formrdesc("pg_auth_members", AuthMemRelation_Rowtype_Id, true,
4029  Natts_pg_auth_members, Desc_pg_auth_members);
4030  formrdesc("pg_shseclabel", SharedSecLabelRelation_Rowtype_Id, true,
4031  Natts_pg_shseclabel, Desc_pg_shseclabel);
4032  formrdesc("pg_subscription", SubscriptionRelation_Rowtype_Id, true,
4033  Natts_pg_subscription, Desc_pg_subscription);
4034 
4035 #define NUM_CRITICAL_SHARED_RELS 5 /* fix if you change list above */
4036  }
4037 
4038  MemoryContextSwitchTo(oldcxt);
4039 }
4040 
4041 /*
4042  * RelationCacheInitializePhase3
4043  *
4044  * This is called as soon as the catcache and transaction system
4045  * are functional and we have determined MyDatabaseId. At this point
4046  * we can actually read data from the database's system catalogs.
4047  * We first try to read pre-computed relcache entries from the local
4048  * relcache init file. If that's missing or broken, make phony entries
4049  * for the minimum set of nailed-in-cache relations. Then (unless
4050  * bootstrapping) make sure we have entries for the critical system
4051  * indexes. Once we've done all this, we have enough infrastructure to
4052  * open any system catalog or use any catcache. The last step is to
4053  * rewrite the cache files if needed.
4054  */
4055 void
4057 {
4058  HASH_SEQ_STATUS status;
4059  RelIdCacheEnt *idhentry;
4060  MemoryContext oldcxt;
4061  bool needNewCacheFile = !criticalSharedRelcachesBuilt;
4062 
4063  /*
4064  * relation mapper needs initialized too
4065  */
4067 
4068  /*
4069  * switch to cache memory context
4070  */
4072 
4073  /*
4074  * Try to load the local relcache cache file. If unsuccessful, bootstrap
4075  * the cache with pre-made descriptors for the critical "nailed-in" system
4076  * catalogs.
4077  */
4078  if (IsBootstrapProcessingMode() ||
4079  !load_relcache_init_file(false))
4080  {
4081  needNewCacheFile = true;
4082 
4083  formrdesc("pg_class", RelationRelation_Rowtype_Id, false,
4084  Natts_pg_class, Desc_pg_class);
4085  formrdesc("pg_attribute", AttributeRelation_Rowtype_Id, false,
4086  Natts_pg_attribute, Desc_pg_attribute);
4087  formrdesc("pg_proc", ProcedureRelation_Rowtype_Id, false,
4088  Natts_pg_proc, Desc_pg_proc);
4089  formrdesc("pg_type", TypeRelation_Rowtype_Id, false,
4090  Natts_pg_type, Desc_pg_type);
4091 
4092 #define NUM_CRITICAL_LOCAL_RELS 4 /* fix if you change list above */
4093  }
4094 
4095  MemoryContextSwitchTo(oldcxt);
4096 
4097  /* In bootstrap mode, the faked-up formrdesc info is all we'll have */
4099  return;
4100 
4101  /*
4102  * If we didn't get the critical system indexes loaded into relcache, do
4103  * so now. These are critical because the catcache and/or opclass cache
4104  * depend on them for fetches done during relcache load. Thus, we have an
4105  * infinite-recursion problem. We can break the recursion by doing
4106  * heapscans instead of indexscans at certain key spots. To avoid hobbling
4107  * performance, we only want to do that until we have the critical indexes
4108  * loaded into relcache. Thus, the flag criticalRelcachesBuilt is used to
4109  * decide whether to do heapscan or indexscan at the key spots, and we set
4110  * it true after we've loaded the critical indexes.
4111  *
4112  * The critical indexes are marked as "nailed in cache", partly to make it
4113  * easy for load_relcache_init_file to count them, but mainly because we
4114  * cannot flush and rebuild them once we've set criticalRelcachesBuilt to
4115  * true. (NOTE: perhaps it would be possible to reload them by
4116  * temporarily setting criticalRelcachesBuilt to false again. For now,
4117  * though, we just nail 'em in.)
4118  *
4119  * RewriteRelRulenameIndexId and TriggerRelidNameIndexId are not critical
4120  * in the same way as the others, because the critical catalogs don't
4121  * (currently) have any rules or triggers, and so these indexes can be
4122  * rebuilt without inducing recursion. However they are used during
4123  * relcache load when a rel does have rules or triggers, so we choose to
4124  * nail them for performance reasons.
4125  */
4127  {
4128  load_critical_index(ClassOidIndexId,
4129  RelationRelationId);
4130  load_critical_index(AttributeRelidNumIndexId,
4131  AttributeRelationId);
4132  load_critical_index(IndexRelidIndexId,
4133  IndexRelationId);
4134  load_critical_index(OpclassOidIndexId,
4135  OperatorClassRelationId);
4136  load_critical_index(AccessMethodProcedureIndexId,
4137  AccessMethodProcedureRelationId);
4138  load_critical_index(RewriteRelRulenameIndexId,
4139  RewriteRelationId);
4140  load_critical_index(TriggerRelidNameIndexId,
4141  TriggerRelationId);
4142 
4143 #define NUM_CRITICAL_LOCAL_INDEXES 7 /* fix if you change list above */
4144 
4145  criticalRelcachesBuilt = true;
4146  }
4147 
4148  /*
4149  * Process critical shared indexes too.
4150  *
4151  * DatabaseNameIndexId isn't critical for relcache loading, but rather for
4152  * initial lookup of MyDatabaseId, without which we'll never find any
4153  * non-shared catalogs at all. Autovacuum calls InitPostgres with a
4154  * database OID, so it instead depends on DatabaseOidIndexId. We also
4155  * need to nail up some indexes on pg_authid and pg_auth_members for use
4156  * during client authentication. SharedSecLabelObjectIndexId isn't
4157  * critical for the core system, but authentication hooks might be
4158  * interested in it.
4159  */
4161  {
4162  load_critical_index(DatabaseNameIndexId,
4163  DatabaseRelationId);
4164  load_critical_index(DatabaseOidIndexId,
4165  DatabaseRelationId);
4166  load_critical_index(AuthIdRolnameIndexId,
4167  AuthIdRelationId);
4168  load_critical_index(AuthIdOidIndexId,
4169  AuthIdRelationId);
4170  load_critical_index(AuthMemMemRoleIndexId,
4171  AuthMemRelationId);
4172  load_critical_index(SharedSecLabelObjectIndexId,
4173  SharedSecLabelRelationId);
4174 
4175 #define NUM_CRITICAL_SHARED_INDEXES 6 /* fix if you change list above */
4176 
4178  }
4179 
4180  /*
4181  * Now, scan all the relcache entries and update anything that might be
4182  * wrong in the results from formrdesc or the relcache cache file. If we
4183  * faked up relcache entries using formrdesc, then read the real pg_class
4184  * rows and replace the fake entries with them. Also, if any of the
4185  * relcache entries have rules, triggers, or security policies, load that
4186  * info the hard way since it isn't recorded in the cache file.
4187  *
4188  * Whenever we access the catalogs to read data, there is a possibility of
4189  * a shared-inval cache flush causing relcache entries to be removed.
4190  * Since hash_seq_search only guarantees to still work after the *current*
4191  * entry is removed, it's unsafe to continue the hashtable scan afterward.
4192  * We handle this by restarting the scan from scratch after each access.
4193  * This is theoretically O(N^2), but the number of entries that actually
4194  * need to be fixed is small enough that it doesn't matter.
4195  */
4196  hash_seq_init(&status, RelationIdCache);
4197 
4198  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
4199  {
4200  Relation relation = idhentry->reldesc;
4201  bool restart = false;
4202 
4203  /*
4204  * Make sure *this* entry doesn't get flushed while we work with it.
4205  */
4207 
4208  /*
4209  * If it's a faked-up entry, read the real pg_class tuple.
4210  */
4211  if (relation->rd_rel->relowner == InvalidOid)
4212  {
4213  HeapTuple htup;
4214  Form_pg_class relp;
4215 
4216  htup = SearchSysCache1(RELOID,
4217  ObjectIdGetDatum(RelationGetRelid(relation)));
4218  if (!HeapTupleIsValid(htup))
4219  ereport(FATAL,
4220  errcode(ERRCODE_UNDEFINED_OBJECT),
4221  errmsg_internal("cache lookup failed for relation %u",
4222  RelationGetRelid(relation)));
4223  relp = (Form_pg_class) GETSTRUCT(htup);
4224 
4225  /*
4226  * Copy tuple to relation->rd_rel. (See notes in
4227  * AllocateRelationDesc())
4228  */
4229  memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
4230 
4231  /* Update rd_options while we have the tuple */
4232  if (relation->rd_options)
4233  pfree(relation->rd_options);
4234  RelationParseRelOptions(relation, htup);
4235 
4236  /*
4237  * Check the values in rd_att were set up correctly. (We cannot
4238  * just copy them over now: formrdesc must have set up the rd_att
4239  * data correctly to start with, because it may already have been
4240  * copied into one or more catcache entries.)
4241  */
4242  Assert(relation->rd_att->tdtypeid == relp->reltype);
4243  Assert(relation->rd_att->tdtypmod == -1);
4244 
4245  ReleaseSysCache(htup);
4246 
4247  /* relowner had better be OK now, else we'll loop forever */
4248  if (relation->rd_rel->relowner == InvalidOid)
4249  elog(ERROR, "invalid relowner in pg_class entry for \"%s\"",
4250  RelationGetRelationName(relation));
4251 
4252  restart = true;
4253  }
4254 
4255  /*
4256  * Fix data that isn't saved in relcache cache file.
4257  *
4258  * relhasrules or relhastriggers could possibly be wrong or out of
4259  * date. If we don't actually find any rules or triggers, clear the
4260  * local copy of the flag so that we don't get into an infinite loop
4261  * here. We don't make any attempt to fix the pg_class entry, though.
4262  */
4263  if (relation->rd_rel->relhasrules && relation->rd_rules == NULL)
4264  {
4265  RelationBuildRuleLock(relation);
4266  if (relation->rd_rules == NULL)
4267  relation->rd_rel->relhasrules = false;
4268  restart = true;
4269  }
4270  if (relation->rd_rel->relhastriggers && relation->trigdesc == NULL)
4271  {
4272  RelationBuildTriggers(relation);
4273  if (relation->trigdesc == NULL)
4274  relation->rd_rel->relhastriggers = false;
4275  restart = true;
4276  }
4277 
4278  /*
4279  * Re-load the row security policies if the relation has them, since
4280  * they are not preserved in the cache. Note that we can never NOT
4281  * have a policy while relrowsecurity is true,
4282  * RelationBuildRowSecurity will create a single default-deny policy
4283  * if there is no policy defined in pg_policy.
4284  */
4285  if (relation->rd_rel->relrowsecurity && relation->rd_rsdesc == NULL)
4286  {
4287  RelationBuildRowSecurity(relation);
4288 
4289  Assert(relation->rd_rsdesc != NULL);
4290  restart = true;
4291  }
4292 
4293  /* Reload tableam data if needed */
4294  if (relation->rd_tableam == NULL &&
4295  (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) || relation->rd_rel->relkind == RELKIND_SEQUENCE))
4296  {
4298  Assert(relation->rd_tableam != NULL);
4299 
4300  restart = true;
4301  }
4302 
4303  /* Release hold on the relation */
4305 
4306  /* Now, restart the hashtable scan if needed */
4307  if (restart)
4308  {
4309  hash_seq_term(&status);
4310  hash_seq_init(&status, RelationIdCache);
4311  }
4312  }
4313 
4314  /*
4315  * Lastly, write out new relcache cache files if needed. We don't bother
4316  * to distinguish cases where only one of the two needs an update.
4317  */
4318  if (needNewCacheFile)
4319  {
4320  /*
4321  * Force all the catcaches to finish initializing and thereby open the
4322  * catalogs and indexes they use. This will preload the relcache with
4323  * entries for all the most important system catalogs and indexes, so
4324  * that the init files will be most useful for future backends.
4325  */
4327 
4328  /* now write the files */
4330  write_relcache_init_file(false);
4331  }
4332 }
4333 
4334 /*
4335  * Load one critical system index into the relcache
4336  *
4337  * indexoid is the OID of the target index, heapoid is the OID of the catalog
4338  * it belongs to.
4339  */
4340 static void
4341 load_critical_index(Oid indexoid, Oid heapoid)
4342 {
4343  Relation ird;
4344 
4345  /*
4346  * We must lock the underlying catalog before locking the index to avoid
4347  * deadlock, since RelationBuildDesc might well need to read the catalog,
4348  * and if anyone else is exclusive-locking this catalog and index they'll
4349  * be doing it in that order.
4350  */
4351  LockRelationOid(heapoid, AccessShareLock);
4352  LockRelationOid(indexoid, AccessShareLock);
4353  ird = RelationBuildDesc(indexoid, true);
4354  if (ird == NULL)
4355  ereport(PANIC,
4357  errmsg_internal("could not open critical system index %u", indexoid));
4358  ird->rd_isnailed = true;
4359  ird->rd_refcnt = 1;
4362 
4363  (void) RelationGetIndexAttOptions(ird, false);
4364 }
4365 
4366 /*
4367  * GetPgClassDescriptor -- get a predefined tuple descriptor for pg_class
4368  * GetPgIndexDescriptor -- get a predefined tuple descriptor for pg_index
4369  *
4370  * We need this kluge because we have to be able to access non-fixed-width
4371  * fields of pg_class and pg_index before we have the standard catalog caches
4372  * available. We use predefined data that's set up in just the same way as
4373  * the bootstrapped reldescs used by formrdesc(). The resulting tupdesc is
4374  * not 100% kosher: it does not have the correct rowtype OID in tdtypeid, nor
4375  * does it have a TupleConstr field. But it's good enough for the purpose of
4376  * extracting fields.
4377  */
4378 static TupleDesc
4380 {
4381  TupleDesc result;
4382  MemoryContext oldcxt;
4383  int i;
4384 
4386 
4387  result = CreateTemplateTupleDesc(natts);
4388  result->tdtypeid = RECORDOID; /* not right, but we don't care */
4389  result->tdtypmod = -1;
4390 
4391  for (i = 0; i < natts; i++)
4392  {
4393  memcpy(TupleDescAttr(result, i), &attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
4394  /* make sure attcacheoff is valid */
4395  TupleDescAttr(result, i)->attcacheoff = -1;
4396  }
4397 
4398  /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
4399  TupleDescAttr(result, 0)->attcacheoff = 0;
4400 
4401  /* Note: we don't bother to set up a TupleConstr entry */
4402 
4403  MemoryContextSwitchTo(oldcxt);
4404 
4405  return result;
4406 }
4407 
4408 static TupleDesc
4410 {
4411  static TupleDesc pgclassdesc = NULL;
4412 
4413  /* Already done? */
4414  if (pgclassdesc == NULL)
4415  pgclassdesc = BuildHardcodedDescriptor(Natts_pg_class,
4416  Desc_pg_class);
4417 
4418  return pgclassdesc;
4419 }
4420 
4421 static TupleDesc
4423 {
4424  static TupleDesc pgindexdesc = NULL;
4425 
4426  /* Already done? */
4427  if (pgindexdesc == NULL)
4428  pgindexdesc = BuildHardcodedDescriptor(Natts_pg_index,
4429  Desc_pg_index);
4430 
4431  return pgindexdesc;
4432 }
4433 
4434 /*
4435  * Load any default attribute value definitions for the relation.
4436  *
4437  * ndef is the number of attributes that were marked atthasdef.
4438  *
4439  * Note: we don't make it a hard error to be missing some pg_attrdef records.
4440  * We can limp along as long as nothing needs to use the default value. Code
4441  * that fails to find an expected AttrDefault record should throw an error.
4442  */
4443 static void
4444 AttrDefaultFetch(Relation relation, int ndef)
4445 {
4446  AttrDefault *attrdef;
4447  Relation adrel;
4448  SysScanDesc adscan;
4449  ScanKeyData skey;
4450  HeapTuple htup;
4451  int found = 0;
4452 
4453  /* Allocate array with room for as many entries as expected */
4454  attrdef = (AttrDefault *)
4456  ndef * sizeof(AttrDefault));
4457 
4458  /* Search pg_attrdef for relevant entries */
4459  ScanKeyInit(&skey,
4460  Anum_pg_attrdef_adrelid,
4461  BTEqualStrategyNumber, F_OIDEQ,
4462  ObjectIdGetDatum(RelationGetRelid(relation)));
4463 
4464  adrel = table_open(AttrDefaultRelationId, AccessShareLock);
4465  adscan = systable_beginscan(adrel, AttrDefaultIndexId, true,
4466  NULL, 1, &skey);
4467 
4468  while (HeapTupleIsValid(htup = systable_getnext(adscan)))
4469  {
4470  Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup);
4471  Datum val;
4472  bool isnull;
4473 
4474  /* protect limited size of array */
4475  if (found >= ndef)
4476  {
4477  elog(WARNING, "unexpected pg_attrdef record found for attribute %d of relation \"%s\"",
4478  adform->adnum, RelationGetRelationName(relation));
4479  break;
4480  }
4481 
4482  val = fastgetattr(htup,
4483  Anum_pg_attrdef_adbin,
4484  adrel->rd_att, &isnull);
4485  if (isnull)
4486  elog(WARNING, "null adbin for attribute %d of relation \"%s\"",
4487  adform->adnum, RelationGetRelationName(relation));
4488  else
4489  {
4490  /* detoast and convert to cstring in caller's context */
4491  char *s = TextDatumGetCString(val);
4492 
4493  attrdef[found].adnum = adform->adnum;
4494  attrdef[found].adbin = MemoryContextStrdup(CacheMemoryContext, s);
4495  pfree(s);
4496  found++;
4497  }
4498  }
4499 
4500  systable_endscan(adscan);
4501  table_close(adrel, AccessShareLock);
4502 
4503  if (found != ndef)
4504  elog(WARNING, "%d pg_attrdef record(s) missing for relation \"%s\"",
4505  ndef - found, RelationGetRelationName(relation));
4506 
4507  /*
4508  * Sort the AttrDefault entries by adnum, for the convenience of
4509  * equalTupleDescs(). (Usually, they already will be in order, but this
4510  * might not be so if systable_getnext isn't using an index.)
4511  */
4512  if (found > 1)
4513  qsort(attrdef, found, sizeof(AttrDefault), AttrDefaultCmp);
4514 
4515  /* Install array only after it's fully valid */
4516  relation->rd_att->constr->defval = attrdef;
4517  relation->rd_att->constr->num_defval = found;
4518 }
4519 
4520 /*
4521  * qsort comparator to sort AttrDefault entries by adnum
4522  */
4523 static int
4524 AttrDefaultCmp(const void *a, const void *b)
4525 {
4526  const AttrDefault *ada = (const AttrDefault *) a;
4527  const AttrDefault *adb = (const AttrDefault *) b;
4528 
4529  return pg_cmp_s16(ada->adnum, adb->adnum);
4530 }
4531 
4532 /*
4533  * Load any check constraints for the relation.
4534  *
4535  * As with defaults, if we don't find the expected number of them, just warn
4536  * here. The executor should throw an error if an INSERT/UPDATE is attempted.
4537  */
4538 static void
4540 {
4541  ConstrCheck *check;
4542  int ncheck = relation->rd_rel->relchecks;
4543  Relation conrel;
4544  SysScanDesc conscan;
4545  ScanKeyData skey[1];
4546  HeapTuple htup;
4547  int found = 0;
4548 
4549  /* Allocate array with room for as many entries as expected */
4550  check = (ConstrCheck *)
4552  ncheck * sizeof(ConstrCheck));
4553 
4554  /* Search pg_constraint for relevant entries */
4555  ScanKeyInit(&skey[0],
4556  Anum_pg_constraint_conrelid,
4557  BTEqualStrategyNumber, F_OIDEQ,
4558  ObjectIdGetDatum(RelationGetRelid(relation)));
4559 
4560  conrel = table_open(ConstraintRelationId, AccessShareLock);
4561  conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
4562  NULL, 1, skey);
4563 
4564  while (HeapTupleIsValid(htup = systable_getnext(conscan)))
4565  {
4567  Datum val;
4568  bool isnull;
4569 
4570  /* We want check constraints only */
4571  if (conform->contype != CONSTRAINT_CHECK)
4572  continue;
4573 
4574  /* protect limited size of array */
4575  if (found >= ncheck)
4576  {
4577  elog(WARNING, "unexpected pg_constraint record found for relation \"%s\"",
4578  RelationGetRelationName(relation));
4579  break;
4580  }
4581 
4582  check[found].ccvalid = conform->convalidated;
4583  check[found].ccnoinherit = conform->connoinherit;
4585  NameStr(conform->conname));
4586 
4587  /* Grab and test conbin is actually set */
4588  val = fastgetattr(htup,
4589  Anum_pg_constraint_conbin,
4590  conrel->rd_att, &isnull);
4591  if (isnull)
4592  elog(WARNING, "null conbin for relation \"%s\"",
4593  RelationGetRelationName(relation));
4594  else
4595  {
4596  /* detoast and convert to cstring in caller's context */
4597  char *s = TextDatumGetCString(val);
4598 
4599  check[found].ccbin = MemoryContextStrdup(CacheMemoryContext, s);
4600  pfree(s);
4601  found++;
4602  }
4603  }
4604 
4605  systable_endscan(conscan);
4606  table_close(conrel, AccessShareLock);
4607 
4608  if (found != ncheck)
4609  elog(WARNING, "%d pg_constraint record(s) missing for relation \"%s\"",
4610  ncheck - found, RelationGetRelationName(relation));
4611 
4612  /*
4613  * Sort the records by name. This ensures that CHECKs are applied in a
4614  * deterministic order, and it also makes equalTupleDescs() faster.
4615  */
4616  if (found > 1)
4617  qsort(check, found, sizeof(ConstrCheck), CheckConstraintCmp);
4618 
4619  /* Install array only after it's fully valid */
4620  relation->rd_att->constr->check = check;
4621  relation->rd_att->constr->num_check = found;
4622 }
4623 
4624 /*
4625  * qsort comparator to sort ConstrCheck entries by name
4626  */
4627 static int
4628 CheckConstraintCmp(const void *a, const void *b)
4629 {
4630  const ConstrCheck *ca = (const ConstrCheck *) a;
4631  const ConstrCheck *cb = (const ConstrCheck *) b;
4632 
4633  return strcmp(ca->ccname, cb->ccname);
4634 }
4635 
4636 /*
4637  * RelationGetFKeyList -- get a list of foreign key info for the relation
4638  *
4639  * Returns a list of ForeignKeyCacheInfo structs, one per FK constraining
4640  * the given relation. This data is a direct copy of relevant fields from
4641  * pg_constraint. The list items are in no particular order.
4642  *
4643  * CAUTION: the returned list is part of the relcache's data, and could
4644  * vanish in a relcache entry reset. Callers must inspect or copy it
4645  * before doing anything that might trigger a cache flush, such as
4646  * system catalog accesses. copyObject() can be used if desired.
4647  * (We define it this way because current callers want to filter and
4648  * modify the list entries anyway, so copying would be a waste of time.)
4649  */
4650 List *
4652 {
4653  List *result;
4654  Relation conrel;
4655  SysScanDesc conscan;
4656  ScanKeyData skey;
4657  HeapTuple htup;
4658  List *oldlist;
4659  MemoryContext oldcxt;
4660 
4661  /* Quick exit if we already computed the list. */
4662  if (relation->rd_fkeyvalid)
4663  return relation->rd_fkeylist;
4664 
4665  /* Fast path: non-partitioned tables without triggers can't have FKs */
4666  if (!relation->rd_rel->relhastriggers &&
4667  relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
4668  return NIL;
4669 
4670  /*
4671  * We build the list we intend to return (in the caller's context) while
4672  * doing the scan. After successfully completing the scan, we copy that
4673  * list into the relcache entry. This avoids cache-context memory leakage
4674  * if we get some sort of error partway through.
4675  */
4676  result = NIL;
4677 
4678  /* Prepare to scan pg_constraint for entries having conrelid = this rel. */
4679  ScanKeyInit(&skey,
4680  Anum_pg_constraint_conrelid,
4681  BTEqualStrategyNumber, F_OIDEQ,
4682  ObjectIdGetDatum(RelationGetRelid(relation)));
4683 
4684  conrel = table_open(ConstraintRelationId, AccessShareLock);
4685  conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
4686  NULL, 1, &skey);
4687 
4688  while (HeapTupleIsValid(htup = systable_getnext(conscan)))
4689  {
4690  Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(htup);
4691  ForeignKeyCacheInfo *info;
4692 
4693  /* consider only foreign keys */
4694  if (constraint->contype != CONSTRAINT_FOREIGN)
4695  continue;
4696 
4697  info = makeNode(ForeignKeyCacheInfo);
4698  info->conoid = constraint->oid;
4699  info->conrelid = constraint->conrelid;
4700  info->confrelid = constraint->confrelid;
4701 
4702  DeconstructFkConstraintRow(htup, &info->nkeys,
4703  info->conkey,
4704  info->confkey,
4705  info->conpfeqop,
4706  NULL, NULL, NULL, NULL);
4707 
4708  /* Add FK's node to the result list */
4709  result = lappend(result, info);
4710  }
4711 
4712  systable_endscan(conscan);
4713  table_close(conrel, AccessShareLock);
4714 
4715  /* Now save a copy of the completed list in the relcache entry. */
4717  oldlist = relation->rd_fkeylist;
4718  relation->rd_fkeylist = copyObject(result);
4719  relation->rd_fkeyvalid = true;
4720  MemoryContextSwitchTo(oldcxt);
4721 
4722  /* Don't leak the old list, if there is one */
4723  list_free_deep(oldlist);
4724 
4725  return result;
4726 }
4727 
4728 /*
4729  * RelationGetIndexList -- get a list of OIDs of indexes on this relation
4730  *
4731  * The index list is created only if someone requests it. We scan pg_index
4732  * to find relevant indexes, and add the list to the relcache entry so that
4733  * we won't have to compute it again. Note that shared cache inval of a
4734  * relcache entry will delete the old list and set rd_indexvalid to false,
4735  * so that we must recompute the index list on next request. This handles
4736  * creation or deletion of an index.
4737  *
4738  * Indexes that are marked not indislive are omitted from the returned list.
4739  * Such indexes are expected to be dropped momentarily, and should not be
4740  * touched at all by any caller of this function.
4741  *
4742  * The returned list is guaranteed to be sorted in order by OID. This is
4743  * needed by the executor, since for index types that we obtain exclusive
4744  * locks on when updating the index, all backends must lock the indexes in
4745  * the same order or we will get deadlocks (see ExecOpenIndices()). Any
4746  * consistent ordering would do, but ordering by OID is easy.
4747  *
4748  * Since shared cache inval causes the relcache's copy of the list to go away,
4749  * we return a copy of the list palloc'd in the caller's context. The caller
4750  * may list_free() the returned list after scanning it. This is necessary
4751  * since the caller will typically be doing syscache lookups on the relevant
4752  * indexes, and syscache lookup could cause SI messages to be processed!
4753  *
4754  * In exactly the same way, we update rd_pkindex, which is the OID of the
4755  * relation's primary key index if any, else InvalidOid; and rd_replidindex,
4756  * which is the pg_class OID of an index to be used as the relation's
4757  * replication identity index, or InvalidOid if there is no such index.
4758  */
4759 List *
4761 {
4762  Relation indrel;
4763  SysScanDesc indscan;
4764  ScanKeyData skey;
4765  HeapTuple htup;
4766  List *result;
4767  List *oldlist;
4768  char replident = relation->rd_rel->relreplident;
4769  Oid pkeyIndex = InvalidOid;
4770  Oid candidateIndex = InvalidOid;
4771  bool pkdeferrable = false;
4772  MemoryContext oldcxt;
4773 
4774  /* Quick exit if we already computed the list. */
4775  if (relation->rd_indexvalid)
4776  return list_copy(relation->rd_indexlist);
4777 
4778  /*
4779  * We build the list we intend to return (in the caller's context) while
4780  * doing the scan. After successfully completing the scan, we copy that
4781  * list into the relcache entry. This avoids cache-context memory leakage
4782  * if we get some sort of error partway through.
4783  */
4784  result = NIL;
4785 
4786  /* Prepare to scan pg_index for entries having indrelid = this rel. */
4787  ScanKeyInit(&skey,
4788  Anum_pg_index_indrelid,
4789  BTEqualStrategyNumber, F_OIDEQ,
4790  ObjectIdGetDatum(RelationGetRelid(relation)));
4791 
4792  indrel = table_open(IndexRelationId, AccessShareLock);
4793  indscan = systable_beginscan(indrel, IndexIndrelidIndexId, true,
4794  NULL, 1, &skey);
4795 
4796  while (HeapTupleIsValid(htup = systable_getnext(indscan)))
4797  {
4799 
4800  /*
4801  * Ignore any indexes that are currently being dropped. This will
4802  * prevent them from being searched, inserted into, or considered in
4803  * HOT-safety decisions. It's unsafe to touch such an index at all
4804  * since its catalog entries could disappear at any instant.
4805  */
4806  if (!index->indislive)
4807  continue;
4808 
4809  /* add index's OID to result list */
4810  result = lappend_oid(result, index->indexrelid);
4811 
4812  /*
4813  * Non-unique or predicate indexes aren't interesting for either oid
4814  * indexes or replication identity indexes, so don't check them.
4815  * Deferred ones are not useful for replication identity either; but
4816  * we do include them if they are PKs.
4817  */
4818  if (!index->indisunique ||
4819  !heap_attisnull(htup, Anum_pg_index_indpred, NULL))
4820  continue;
4821 
4822  /*
4823  * Remember primary key index, if any. We do this only if the index
4824  * is valid; but if the table is partitioned, then we do it even if
4825  * it's invalid.
4826  *
4827  * The reason for returning invalid primary keys for foreign tables is
4828  * because of pg_dump of NOT NULL constraints, and the fact that PKs
4829  * remain marked invalid until the partitions' PKs are attached to it.
4830  * If we make rd_pkindex invalid, then the attnotnull flag is reset
4831  * after the PK is created, which causes the ALTER INDEX ATTACH
4832  * PARTITION to fail with 'column ... is not marked NOT NULL'. With
4833  * this, dropconstraint_internal() will believe that the columns must
4834  * not have attnotnull reset, so the PKs-on-partitions can be attached
4835  * correctly, until finally the PK-on-parent is marked valid.
4836  *
4837  * Also, this doesn't harm anything, because rd_pkindex is not a
4838  * "real" index anyway, but a RELKIND_PARTITIONED_INDEX.
4839  */
4840  if (index->indisprimary &&
4841  (index->indisvalid ||
4842  relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
4843  {
4844  pkeyIndex = index->indexrelid;
4845  pkdeferrable = !index->indimmediate;
4846  }
4847 
4848  if (!index->indimmediate)
4849  continue;
4850 
4851  if (!index->indisvalid)
4852  continue;
4853 
4854  /* remember explicitly chosen replica index */
4855  if (index->indisreplident)
4856  candidateIndex = index->indexrelid;
4857  }
4858 
4859  systable_endscan(indscan);
4860 
4861  table_close(indrel, AccessShareLock);
4862 
4863  /* Sort the result list into OID order, per API spec. */
4864  list_sort(result, list_oid_cmp);
4865 
4866  /* Now save a copy of the completed list in the relcache entry. */
4868  oldlist = relation->rd_indexlist;
4869  relation->rd_indexlist = list_copy(result);
4870  relation->rd_pkindex = pkeyIndex;
4871  relation->rd_ispkdeferrable = pkdeferrable;
4872  if (replident == REPLICA_IDENTITY_DEFAULT && OidIsValid(pkeyIndex) && !pkdeferrable)
4873  relation->rd_replidindex = pkeyIndex;
4874  else if (replident == REPLICA_IDENTITY_INDEX && OidIsValid(candidateIndex))
4875  relation->rd_replidindex = candidateIndex;
4876  else
4877  relation->rd_replidindex = InvalidOid;
4878  relation->rd_indexvalid = true;
4879  MemoryContextSwitchTo(oldcxt);
4880 
4881  /* Don't leak the old list, if there is one */
4882  list_free(oldlist);
4883 
4884  return result;
4885 }
4886 
4887 /*
4888  * RelationGetStatExtList
4889  * get a list of OIDs of statistics objects on this relation
4890  *
4891  * The statistics list is created only if someone requests it, in a way
4892  * similar to RelationGetIndexList(). We scan pg_statistic_ext to find
4893  * relevant statistics, and add the list to the relcache entry so that we
4894  * won't have to compute it again. Note that shared cache inval of a
4895  * relcache entry will delete the old list and set rd_statvalid to 0,
4896  * so that we must recompute the statistics list on next request. This
4897  * handles creation or deletion of a statistics object.
4898  *
4899  * The returned list is guaranteed to be sorted in order by OID, although
4900  * this is not currently needed.
4901  *
4902  * Since shared cache inval causes the relcache's copy of the list to go away,
4903  * we return a copy of the list palloc'd in the caller's context. The caller
4904  * may list_free() the returned list after scanning it. This is necessary
4905  * since the caller will typically be doing syscache lookups on the relevant
4906  * statistics, and syscache lookup could cause SI messages to be processed!
4907  */
4908 List *
4910 {
4911  Relation indrel;
4912  SysScanDesc indscan;
4913  ScanKeyData skey;
4914  HeapTuple htup;
4915  List *result;
4916  List *oldlist;
4917  MemoryContext oldcxt;
4918 
4919  /* Quick exit if we already computed the list. */
4920  if (relation->rd_statvalid != 0)
4921  return list_copy(relation->rd_statlist);
4922 
4923  /*
4924  * We build the list we intend to return (in the caller's context) while
4925  * doing the scan. After successfully completing the scan, we copy that
4926  * list into the relcache entry. This avoids cache-context memory leakage
4927  * if we get some sort of error partway through.
4928  */
4929  result = NIL;
4930 
4931  /*
4932  * Prepare to scan pg_statistic_ext for entries having stxrelid = this
4933  * rel.
4934  */
4935  ScanKeyInit(&skey,
4936  Anum_pg_statistic_ext_stxrelid,
4937  BTEqualStrategyNumber, F_OIDEQ,
4938  ObjectIdGetDatum(RelationGetRelid(relation)));
4939 
4940  indrel = table_open(StatisticExtRelationId, AccessShareLock);
4941  indscan = systable_beginscan(indrel, StatisticExtRelidIndexId, true,
4942  NULL, 1, &skey);
4943 
4944  while (HeapTupleIsValid(htup = systable_getnext(indscan)))
4945  {
4946  Oid oid = ((Form_pg_statistic_ext) GETSTRUCT(htup))->oid;
4947 
4948  result = lappend_oid(result, oid);
4949  }
4950 
4951  systable_endscan(indscan);
4952 
4953  table_close(indrel, AccessShareLock);
4954 
4955  /* Sort the result list into OID order, per API spec. */
4956  list_sort(result, list_oid_cmp);
4957 
4958  /* Now save a copy of the completed list in the relcache entry. */
4960  oldlist = relation->rd_statlist;
4961  relation->rd_statlist = list_copy(result);
4962 
4963  relation->rd_statvalid = true;
4964  MemoryContextSwitchTo(oldcxt);
4965 
4966  /* Don't leak the old list, if there is one */
4967  list_free(oldlist);
4968 
4969  return result;
4970 }
4971 
4972 /*
4973  * RelationGetPrimaryKeyIndex -- get OID of the relation's primary key index
4974  *
4975  * Returns InvalidOid if there is no such index, or if the primary key is
4976  * DEFERRABLE.
4977  */
4978 Oid
4980 {
4981  List *ilist;
4982 
4983  if (!relation->rd_indexvalid)
4984  {
4985  /* RelationGetIndexList does the heavy lifting. */
4986  ilist = RelationGetIndexList(relation);
4987  list_free(ilist);
4988  Assert(relation->rd_indexvalid);
4989  }
4990 
4991  return relation->rd_ispkdeferrable ? InvalidOid : relation->rd_pkindex;
4992 }
4993 
4994 /*
4995  * RelationGetReplicaIndex -- get OID of the relation's replica identity index
4996  *
4997  * Returns InvalidOid if there is no such index.
4998  */
4999 Oid
5001 {
5002  List *ilist;
5003 
5004  if (!relation->rd_indexvalid)
5005  {
5006  /* RelationGetIndexList does the heavy lifting. */
5007  ilist = RelationGetIndexList(relation);
5008  list_free(ilist);
5009  Assert(relation->rd_indexvalid);
5010  }
5011 
5012  return relation->rd_replidindex;
5013 }
5014 
5015 /*
5016  * RelationGetIndexExpressions -- get the index expressions for an index
5017  *
5018  * We cache the result of transforming pg_index.indexprs into a node tree.
5019  * If the rel is not an index or has no expressional columns, we return NIL.
5020  * Otherwise, the returned tree is copied into the caller's memory context.
5021  * (We don't want to return a pointer to the relcache copy, since it could
5022  * disappear due to relcache invalidation.)
5023  */
5024 List *
5026 {
5027  List *result;
5028  Datum exprsDatum;
5029  bool isnull;
5030  char *exprsString;
5031  MemoryContext oldcxt;
5032 
5033  /* Quick exit if we already computed the result. */
5034  if (relation->rd_indexprs)
5035  return copyObject(relation->rd_indexprs);
5036 
5037  /* Quick exit if there is nothing to do. */
5038  if (relation->rd_indextuple == NULL ||
5039  heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
5040  return NIL;
5041 
5042  /*
5043  * We build the tree we intend to return in the caller's context. After
5044  * successfully completing the work, we copy it into the relcache entry.
5045  * This avoids problems if we get some sort of error partway through.
5046  */
5047  exprsDatum = heap_getattr(relation->rd_indextuple,
5048  Anum_pg_index_indexprs,
5050  &isnull);
5051  Assert(!isnull);
5052  exprsString = TextDatumGetCString(exprsDatum);
5053  result = (List *) stringToNode(exprsString);
5054  pfree(exprsString);
5055 
5056  /*
5057  * Run the expressions through eval_const_expressions. This is not just an
5058  * optimization, but is necessary, because the planner will be comparing
5059  * them to similarly-processed qual clauses, and may fail to detect valid
5060  * matches without this. We must not use canonicalize_qual, however,
5061  * since these aren't qual expressions.
5062  */
5063  result = (List *) eval_const_expressions(NULL, (Node *) result);
5064 
5065  /* May as well fix opfuncids too */
5066  fix_opfuncids((Node *) result);
5067 
5068  /* Now save a copy of the completed tree in the relcache entry. */
5069  oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
5070  relation->rd_indexprs = copyObject(result);
5071  MemoryContextSwitchTo(oldcxt);
5072 
5073  return result;
5074 }
5075 
5076 /*
5077  * RelationGetDummyIndexExpressions -- get dummy expressions for an index
5078  *
5079  * Return a list of dummy expressions (just Const nodes) with the same
5080  * types/typmods/collations as the index's real expressions. This is
5081  * useful in situations where we don't want to run any user-defined code.
5082  */
5083 List *
5085 {
5086  List *result;
5087  Datum exprsDatum;
5088  bool isnull;
5089  char *exprsString;
5090  List *rawExprs;
5091  ListCell *lc;
5092 
5093  /* Quick exit if there is nothing to do. */
5094  if (relation->rd_indextuple == NULL ||
5095  heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
5096  return NIL;
5097 
5098  /* Extract raw node tree(s) from index tuple. */
5099  exprsDatum = heap_getattr(relation->rd_indextuple,
5100  Anum_pg_index_indexprs,
5102  &isnull);
5103  Assert(!isnull);
5104  exprsString = TextDatumGetCString(exprsDatum);
5105  rawExprs = (List *) stringToNode(exprsString);
5106  pfree(exprsString);
5107 
5108  /* Construct null Consts; the typlen and typbyval are arbitrary. */
5109  result = NIL;
5110  foreach(lc, rawExprs)
5111  {
5112  Node *rawExpr = (Node *) lfirst(lc);
5113 
5114  result = lappend(result,
5115  makeConst(exprType(rawExpr),
5116  exprTypmod(rawExpr),
5117  exprCollation(rawExpr),
5118  1,
5119  (Datum) 0,
5120  true,
5121  true));
5122  }
5123 
5124  return result;
5125 }
5126 
5127 /*
5128  * RelationGetIndexPredicate -- get the index predicate for an index
5129  *
5130  * We cache the result of transforming pg_index.indpred into an implicit-AND
5131  * node tree (suitable for use in planning).
5132  * If the rel is not an index or has no predicate, we return NIL.
5133  * Otherwise, the returned tree is copied into the caller's memory context.
5134  * (We don't want to return a pointer to the relcache copy, since it could
5135  * disappear due to relcache invalidation.)
5136  */
5137 List *
5139 {
5140  List *result;
5141  Datum predDatum;
5142  bool isnull;
5143  char *predString;
5144  MemoryContext oldcxt;
5145 
5146  /* Quick exit if we already computed the result. */
5147  if (relation->rd_indpred)
5148  return copyObject(relation->rd_indpred);
5149 
5150  /* Quick exit if there is nothing to do. */
5151  if (relation->rd_indextuple == NULL ||
5152  heap_attisnull(relation->rd_indextuple, Anum_pg_index_indpred, NULL))
5153  return NIL;
5154 
5155  /*
5156  * We build the tree we intend to return in the caller's context. After
5157  * successfully completing the work, we copy it into the relcache entry.
5158  * This avoids problems if we get some sort of error partway through.
5159  */
5160  predDatum = heap_getattr(relation->rd_indextuple,
5161  Anum_pg_index_indpred,
5163  &isnull);
5164  Assert(!isnull);
5165  predString = TextDatumGetCString(predDatum);
5166  result = (List *) stringToNode(predString);
5167  pfree(predString);
5168 
5169  /*
5170  * Run the expression through const-simplification and canonicalization.
5171  * This is not just an optimization, but is necessary, because the planner
5172  * will be comparing it to similarly-processed qual clauses, and may fail
5173  * to detect valid matches without this. This must match the processing
5174  * done to qual clauses in preprocess_expression()! (We can skip the
5175  * stuff involving subqueries, however, since we don't allow any in index
5176  * predicates.)
5177  */
5178  result = (List *) eval_const_expressions(NULL, (Node *) result);
5179 
5180  result = (List *) canonicalize_qual((Expr *) result, false);
5181 
5182  /* Also convert to implicit-AND format */
5183  result = make_ands_implicit((Expr *) result);
5184 
5185  /* May as well fix opfuncids too */
5186  fix_opfuncids((Node *) result);
5187 
5188  /* Now save a copy of the completed tree in the relcache entry. */
5189  oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
5190  relation->rd_indpred = copyObject(result);
5191  MemoryContextSwitchTo(oldcxt);
5192 
5193  return result;
5194 }
5195 
5196 /*
5197  * RelationGetIndexAttrBitmap -- get a bitmap of index attribute numbers
5198  *
5199  * The result has a bit set for each attribute used anywhere in the index
5200  * definitions of all the indexes on this relation. (This includes not only
5201  * simple index keys, but attributes used in expressions and partial-index
5202  * predicates.)
5203  *
5204  * Depending on attrKind, a bitmap covering attnums for certain columns is
5205  * returned:
5206  * INDEX_ATTR_BITMAP_KEY Columns in non-partial unique indexes not
5207  * in expressions (i.e., usable for FKs)
5208  * INDEX_ATTR_BITMAP_PRIMARY_KEY Columns in the table's primary key
5209  * (beware: even if PK is deferrable!)
5210  * INDEX_ATTR_BITMAP_IDENTITY_KEY Columns in the table's replica identity
5211  * index (empty if FULL)
5212  * INDEX_ATTR_BITMAP_HOT_BLOCKING Columns that block updates from being HOT
5213  * INDEX_ATTR_BITMAP_SUMMARIZED Columns included in summarizing indexes
5214  *
5215  * Attribute numbers are offset by FirstLowInvalidHeapAttributeNumber so that
5216  * we can include system attributes (e.g., OID) in the bitmap representation.
5217  *
5218  * Deferred indexes are considered for the primary key, but not for replica
5219  * identity.
5220  *
5221  * Caller had better hold at least RowExclusiveLock on the target relation
5222  * to ensure it is safe (deadlock-free) for us to take locks on the relation's
5223  * indexes. Note that since the introduction of CREATE INDEX CONCURRENTLY,
5224  * that lock level doesn't guarantee a stable set of indexes, so we have to
5225  * be prepared to retry here in case of a change in the set of indexes.
5226  *
5227  * The returned result is palloc'd in the caller's memory context and should
5228  * be bms_free'd when not needed anymore.
5229  */
5230 Bitmapset *
5232 {
5233  Bitmapset *uindexattrs; /* columns in unique indexes */
5234  Bitmapset *pkindexattrs; /* columns in the primary index */
5235  Bitmapset *idindexattrs; /* columns in the replica identity */
5236  Bitmapset *hotblockingattrs; /* columns with HOT blocking indexes */
5237  Bitmapset *summarizedattrs; /* columns with summarizing indexes */
5238  List *indexoidlist;
5239  List *newindexoidlist;
5240  Oid relpkindex;
5241  Oid relreplindex;
5242  ListCell *l;
5243  MemoryContext oldcxt;
5244 
5245  /* Quick exit if we already computed the result. */
5246  if (relation->rd_attrsvalid)
5247  {
5248  switch (attrKind)
5249  {
5250  case INDEX_ATTR_BITMAP_KEY:
5251  return bms_copy(relation->rd_keyattr);
5253  return bms_copy(relation->rd_pkattr);
5255  return bms_copy(relation->rd_idattr);
5257  return bms_copy(relation->rd_hotblockingattr);
5259  return bms_copy(relation->rd_summarizedattr);
5260  default:
5261  elog(ERROR, "unknown attrKind %u", attrKind);
5262  }
5263  }
5264 
5265  /* Fast path if definitely no indexes */
5266  if (!RelationGetForm(relation)->relhasindex)
5267  return NULL;
5268 
5269  /*
5270  * Get cached list of index OIDs. If we have to start over, we do so here.
5271  */
5272 restart:
5273  indexoidlist = RelationGetIndexList(relation);
5274 
5275  /* Fall out if no indexes (but relhasindex was set) */
5276  if (indexoidlist == NIL)
5277  return NULL;
5278 
5279  /*
5280  * Copy the rd_pkindex and rd_replidindex values computed by
5281  * RelationGetIndexList before proceeding. This is needed because a
5282  * relcache flush could occur inside index_open below, resetting the
5283  * fields managed by RelationGetIndexList. We need to do the work with
5284  * stable values of these fields.
5285  */
5286  relpkindex = relation->rd_pkindex;
5287  relreplindex = relation->rd_replidindex;
5288 
5289  /*
5290  * For each index, add referenced attributes to indexattrs.
5291  *
5292  * Note: we consider all indexes returned by RelationGetIndexList, even if
5293  * they are not indisready or indisvalid. This is important because an
5294  * index for which CREATE INDEX CONCURRENTLY has just started must be
5295  * included in HOT-safety decisions (see README.HOT). If a DROP INDEX
5296  * CONCURRENTLY is far enough along that we should ignore the index, it
5297  * won't be returned at all by RelationGetIndexList.
5298  */
5299  uindexattrs = NULL;
5300  pkindexattrs = NULL;
5301  idindexattrs = NULL;
5302  hotblockingattrs = NULL;
5303  summarizedattrs = NULL;
5304  foreach(l, indexoidlist)
5305  {
5306  Oid indexOid = lfirst_oid(l);
5307  Relation indexDesc;
5308  Datum datum;
5309  bool isnull;
5310  Node *indexExpressions;
5311  Node *indexPredicate;
5312  int i;
5313  bool isKey; /* candidate key */
5314  bool isPK; /* primary key */
5315  bool isIDKey; /* replica identity index */
5316  Bitmapset **attrs;
5317 
5318  indexDesc = index_open(indexOid, AccessShareLock);
5319 
5320  /*
5321  * Extract index expressions and index predicate. Note: Don't use
5322  * RelationGetIndexExpressions()/RelationGetIndexPredicate(), because
5323  * those might run constant expressions evaluation, which needs a
5324  * snapshot, which we might not have here. (Also, it's probably more
5325  * sound to collect the bitmaps before any transformations that might
5326  * eliminate columns, but the practical impact of this is limited.)
5327  */
5328 
5329  datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indexprs,
5330  GetPgIndexDescriptor(), &isnull);
5331  if (!isnull)
5332  indexExpressions = stringToNode(TextDatumGetCString(datum));
5333  else
5334  indexExpressions = NULL;
5335 
5336  datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indpred,
5337  GetPgIndexDescriptor(), &isnull);
5338  if (!isnull)
5339  indexPredicate = stringToNode(TextDatumGetCString(datum));
5340  else
5341  indexPredicate = NULL;
5342 
5343  /* Can this index be referenced by a foreign key? */
5344  isKey = indexDesc->rd_index->indisunique &&
5345  indexExpressions == NULL &&
5346  indexPredicate == NULL;
5347 
5348  /* Is this a primary key? */
5349  isPK = (indexOid == relpkindex);
5350 
5351  /* Is this index the configured (or default) replica identity? */
5352  isIDKey = (indexOid == relreplindex);
5353 
5354  /*
5355  * If the index is summarizing, it doesn't block HOT updates, but we
5356  * may still need to update it (if the attributes were modified). So
5357  * decide which bitmap we'll update in the following loop.
5358  */
5359  if (indexDesc->rd_indam->amsummarizing)
5360  attrs = &summarizedattrs;
5361  else
5362  attrs = &hotblockingattrs;
5363 
5364  /* Collect simple attribute references */
5365  for (i = 0; i < indexDesc->rd_index->indnatts; i++)
5366  {
5367  int attrnum = indexDesc->rd_index->indkey.values[i];
5368 
5369  /*
5370  * Since we have covering indexes with non-key columns, we must
5371  * handle them accurately here. non-key columns must be added into
5372  * hotblockingattrs or summarizedattrs, since they are in index,
5373  * and update shouldn't miss them.
5374  *
5375  * Summarizing indexes do not block HOT, but do need to be updated
5376  * when the column value changes, thus require a separate
5377  * attribute bitmapset.
5378  *
5379  * Obviously, non-key columns couldn't be referenced by foreign
5380  * key or identity key. Hence we do not include them into
5381  * uindexattrs, pkindexattrs and idindexattrs bitmaps.
5382  */
5383  if (attrnum != 0)
5384  {
5385  *attrs = bms_add_member(*attrs,
5387 
5388  if (isKey && i < indexDesc->rd_index->indnkeyatts)
5389  uindexattrs = bms_add_member(uindexattrs,
5391 
5392  if (isPK && i < indexDesc->rd_index->indnkeyatts)
5393  pkindexattrs = bms_add_member(pkindexattrs,
5395 
5396  if (isIDKey && i < indexDesc->rd_index->indnkeyatts)
5397  idindexattrs = bms_add_member(idindexattrs,
5399  }
5400  }
5401 
5402  /* Collect all attributes used in expressions, too */
5403  pull_varattnos(indexExpressions, 1, attrs);
5404 
5405  /* Collect all attributes in the index predicate, too */
5406  pull_varattnos(indexPredicate, 1, attrs);
5407 
5408  index_close(indexDesc, AccessShareLock);
5409  }
5410 
5411  /*
5412  * During one of the index_opens in the above loop, we might have received
5413  * a relcache flush event on this relcache entry, which might have been
5414  * signaling a change in the rel's index list. If so, we'd better start
5415  * over to ensure we deliver up-to-date attribute bitmaps.
5416  */
5417  newindexoidlist = RelationGetIndexList(relation);
5418  if (equal(indexoidlist, newindexoidlist) &&
5419  relpkindex == relation->rd_pkindex &&
5420  relreplindex == relation->rd_replidindex)
5421  {
5422  /* Still the same index set, so proceed */
5423  list_free(newindexoidlist);
5424  list_free(indexoidlist);
5425  }
5426  else
5427  {
5428  /* Gotta do it over ... might as well not leak memory */
5429  list_free(newindexoidlist);
5430  list_free(indexoidlist);
5431  bms_free(uindexattrs);
5432  bms_free(pkindexattrs);
5433  bms_free(idindexattrs);
5434  bms_free(hotblockingattrs);
5435  bms_free(summarizedattrs);
5436 
5437  goto restart;
5438  }
5439 
5440  /* Don't leak the old values of these bitmaps, if any */
5441  relation->rd_attrsvalid = false;
5442  bms_free(relation->rd_keyattr);
5443  relation->rd_keyattr = NULL;
5444  bms_free(relation->rd_pkattr);
5445  relation->rd_pkattr = NULL;
5446  bms_free(relation->rd_idattr);
5447  relation->rd_idattr = NULL;
5448  bms_free(relation->rd_hotblockingattr);
5449  relation->rd_hotblockingattr = NULL;
5450  bms_free(relation->rd_summarizedattr);
5451  relation->rd_summarizedattr = NULL;
5452 
5453  /*
5454  * Now save copies of the bitmaps in the relcache entry. We intentionally
5455  * set rd_attrsvalid last, because that's the one that signals validity of
5456  * the values; if we run out of memory before making that copy, we won't
5457  * leave the relcache entry looking like the other ones are valid but
5458  * empty.
5459  */
5461  relation->rd_keyattr = bms_copy(uindexattrs);
5462  relation->rd_pkattr = bms_copy(pkindexattrs);
5463  relation->rd_idattr = bms_copy(idindexattrs);
5464  relation->rd_hotblockingattr = bms_copy(hotblockingattrs);
5465  relation->rd_summarizedattr = bms_copy(summarizedattrs);
5466  relation->rd_attrsvalid = true;
5467  MemoryContextSwitchTo(oldcxt);
5468 
5469  /* We return our original working copy for caller to play with */
5470  switch (attrKind)
5471  {
5472  case INDEX_ATTR_BITMAP_KEY:
5473  return uindexattrs;
5475  return pkindexattrs;
5477  return idindexattrs;
5479  return hotblockingattrs;
5481  return summarizedattrs;
5482  default:
5483  elog(ERROR, "unknown attrKind %u", attrKind);
5484  return NULL;
5485  }
5486 }
5487 
5488 /*
5489  * RelationGetIdentityKeyBitmap -- get a bitmap of replica identity attribute
5490  * numbers
5491  *
5492  * A bitmap of index attribute numbers for the configured replica identity
5493  * index is returned.
5494  *
5495  * See also comments of RelationGetIndexAttrBitmap().
5496  *
5497  * This is a special purpose function used during logical replication. Here,
5498  * unlike RelationGetIndexAttrBitmap(), we don't acquire a lock on the required
5499  * index as we build the cache entry using a historic snapshot and all the
5500  * later changes are absorbed while decoding WAL. Due to this reason, we don't
5501  * need to retry here in case of a change in the set of indexes.
5502  */
5503 Bitmapset *
5505 {
5506  Bitmapset *idindexattrs = NULL; /* columns in the replica identity */
5507  Relation indexDesc;
5508  int i;
5509  Oid replidindex;
5510  MemoryContext oldcxt;
5511 
5512  /* Quick exit if we already computed the result */
5513  if (relation->rd_idattr != NULL)
5514  return bms_copy(relation->rd_idattr);
5515 
5516  /* Fast path if definitely no indexes */
5517  if (!RelationGetForm(relation)->relhasindex)
5518  return NULL;
5519 
5520  /* Historic snapshot must be set. */
5522 
5523  replidindex = RelationGetReplicaIndex(relation);
5524 
5525  /* Fall out if there is no replica identity index */
5526  if (!OidIsValid(replidindex))
5527  return NULL;
5528 
5529  /* Look up the description for the replica identity index */
5530  indexDesc = RelationIdGetRelation(replidindex);
5531 
5532  if (!RelationIsValid(indexDesc))
5533  elog(ERROR, "could not open relation with OID %u",
5534  relation->rd_replidindex);
5535 
5536  /* Add referenced attributes to idindexattrs */
5537  for (i = 0; i < indexDesc->rd_index->indnatts; i++)
5538  {
5539  int attrnum = indexDesc->rd_index->indkey.values[i];
5540 
5541  /*
5542  * We don't include non-key columns into idindexattrs bitmaps. See
5543  * RelationGetIndexAttrBitmap.
5544  */
5545  if (attrnum != 0)
5546  {
5547  if (i < indexDesc->rd_index->indnkeyatts)
5548  idindexattrs = bms_add_member(idindexattrs,
5550  }
5551  }
5552 
5553  RelationClose(indexDesc);
5554 
5555  /* Don't leak the old values of these bitmaps, if any */
5556  bms_free(relation->rd_idattr);
5557  relation->rd_idattr = NULL;
5558 
5559  /* Now save copy of the bitmap in the relcache entry */
5561  relation->rd_idattr = bms_copy(idindexattrs);
5562  MemoryContextSwitchTo(oldcxt);
5563 
5564  /* We return our original working copy for caller to play with */
5565  return idindexattrs;
5566 }
5567 
5568 /*
5569  * RelationGetExclusionInfo -- get info about index's exclusion constraint
5570  *
5571  * This should be called only for an index that is known to have an associated
5572  * exclusion constraint or primary key/unique constraint using WITHOUT
5573  * OVERLAPS.
5574 
5575  * It returns arrays (palloc'd in caller's context) of the exclusion operator
5576  * OIDs, their underlying functions' OIDs, and their strategy numbers in the
5577  * index's opclasses. We cache all this information since it requires a fair
5578  * amount of work to get.
5579  */
5580 void
5582  Oid **operators,
5583  Oid **procs,
5584  uint16 **strategies)
5585 {
5586  int indnkeyatts;
5587  Oid *ops;
5588  Oid *funcs;
5589  uint16 *strats;
5590  Relation conrel;
5591  SysScanDesc conscan;
5592  ScanKeyData skey[1];
5593  HeapTuple htup;
5594  bool found;
5595  MemoryContext oldcxt;
5596  int i;
5597 
5598  indnkeyatts = IndexRelationGetNumberOfKeyAttributes(indexRelation);
5599 
5600  /* Allocate result space in caller context */
5601  *operators = ops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
5602  *procs = funcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
5603  *strategies = strats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
5604 
5605  /* Quick exit if we have the data cached already */
5606  if (indexRelation->rd_exclstrats != NULL)
5607  {
5608  memcpy(ops, indexRelation->rd_exclops, sizeof(Oid) * indnkeyatts);
5609  memcpy(funcs, indexRelation->rd_exclprocs, sizeof(Oid) * indnkeyatts);
5610  memcpy(strats, indexRelation->rd_exclstrats, sizeof(uint16) * indnkeyatts);
5611  return;
5612  }
5613 
5614  /*
5615  * Search pg_constraint for the constraint associated with the index. To
5616  * make this not too painfully slow, we use the index on conrelid; that
5617  * will hold the parent relation's OID not the index's own OID.
5618  *
5619  * Note: if we wanted to rely on the constraint name matching the index's
5620  * name, we could just do a direct lookup using pg_constraint's unique
5621  * index. For the moment it doesn't seem worth requiring that.
5622  */
5623  ScanKeyInit(&skey[0],
5624  Anum_pg_constraint_conrelid,
5625  BTEqualStrategyNumber, F_OIDEQ,
5626  ObjectIdGetDatum(indexRelation->rd_index->indrelid));
5627 
5628  conrel = table_open(ConstraintRelationId, AccessShareLock);
5629  conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
5630  NULL, 1, skey);
5631  found = false;
5632 
5633  while (HeapTupleIsValid(htup = systable_getnext(conscan)))
5634  {
5636  Datum val;
5637  bool isnull;
5638  ArrayType *arr;
5639  int nelem;
5640 
5641  /* We want the exclusion constraint owning the index */
5642  if ((conform->contype != CONSTRAINT_EXCLUSION &&
5643  !(conform->conperiod && (
5644  conform->contype == CONSTRAINT_PRIMARY
5645  || conform->contype == CONSTRAINT_UNIQUE))) ||
5646  conform->conindid != RelationGetRelid(indexRelation))
5647  continue;
5648 
5649  /* There should be only one */
5650  if (found)
5651  elog(ERROR, "unexpected exclusion constraint record found for rel %s",
5652  RelationGetRelationName(indexRelation));
5653  found = true;
5654 
5655  /* Extract the operator OIDS from conexclop */
5656  val = fastgetattr(htup,
5657  Anum_pg_constraint_conexclop,
5658  conrel->rd_att, &isnull);
5659  if (isnull)
5660  elog(ERROR, "null conexclop for rel %s",
5661  RelationGetRelationName(indexRelation));
5662 
5663  arr = DatumGetArrayTypeP(val); /* ensure not toasted */
5664  nelem = ARR_DIMS(arr)[0];
5665  if (ARR_NDIM(arr) != 1 ||
5666  nelem != indnkeyatts ||
5667  ARR_HASNULL(arr) ||
5668  ARR_ELEMTYPE(arr) != OIDOID)
5669  elog(ERROR, "conexclop is not a 1-D Oid array");
5670 
5671  memcpy(ops, ARR_DATA_PTR(arr), sizeof(Oid) * indnkeyatts);
5672  }
5673 
5674  systable_endscan(conscan);
5675  table_close(conrel, AccessShareLock);
5676 
5677  if (!found)
5678  elog(ERROR, "exclusion constraint record missing for rel %s",
5679  RelationGetRelationName(indexRelation));
5680 
5681  /* We need the func OIDs and strategy numbers too */
5682  for (i = 0; i < indnkeyatts; i++)
5683  {
5684  funcs[i] = get_opcode(ops[i]);
5685  strats[i] = get_op_opfamily_strategy(ops[i],
5686  indexRelation->rd_opfamily[i]);
5687  /* shouldn't fail, since it was checked at index creation */
5688  if (strats[i] == InvalidStrategy)
5689  elog(ERROR, "could not find strategy for operator %u in family %u",
5690  ops[i], indexRelation->rd_opfamily[i]);
5691  }
5692 
5693  /* Save a copy of the results in the relcache entry. */
5694  oldcxt = MemoryContextSwitchTo(indexRelation->rd_indexcxt);
5695  indexRelation->rd_exclops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
5696  indexRelation->rd_exclprocs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
5697  indexRelation->rd_exclstrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
5698  memcpy(indexRelation->rd_exclops, ops, sizeof(Oid) * indnkeyatts);
5699  memcpy(indexRelation->rd_exclprocs, funcs, sizeof(Oid) * indnkeyatts);
5700  memcpy(indexRelation->rd_exclstrats, strats, sizeof(uint16) * indnkeyatts);
5701  MemoryContextSwitchTo(oldcxt);
5702 }
5703 
5704 /*
5705  * Get the publication information for the given relation.
5706  *
5707  * Traverse all the publications which the relation is in to get the
5708  * publication actions and validate the row filter expressions for such
5709  * publications if any. We consider the row filter expression as invalid if it
5710  * references any column which is not part of REPLICA IDENTITY.
5711  *
5712  * To avoid fetching the publication information repeatedly, we cache the
5713  * publication actions and row filter validation information.
5714  */
5715 void
5717 {
5718  List *puboids;
5719  ListCell *lc;
5720  MemoryContext oldcxt;
5721  Oid schemaid;
5722  List *ancestors = NIL;
5723  Oid relid = RelationGetRelid(relation);
5724 
5725  /*
5726  * If not publishable, it publishes no actions. (pgoutput_change() will
5727  * ignore it.)
5728  */
5729  if (!is_publishable_relation(relation))
5730  {
5731  memset(pubdesc, 0, sizeof(PublicationDesc));
5732  pubdesc->rf_valid_for_update = true;
5733  pubdesc->rf_valid_for_delete = true;
5734  pubdesc->cols_valid_for_update = true;
5735  pubdesc->cols_valid_for_delete = true;
5736  return;
5737  }
5738 
5739  if (relation->rd_pubdesc)
5740  {
5741  memcpy(pubdesc, relation->rd_pubdesc, sizeof(PublicationDesc));
5742  return;
5743  }
5744 
5745  memset(pubdesc, 0, sizeof(PublicationDesc));
5746  pubdesc->rf_valid_for_update = true;
5747  pubdesc->rf_valid_for_delete = true;
5748  pubdesc->cols_valid_for_update = true;
5749  pubdesc->cols_valid_for_delete = true;
5750 
5751  /* Fetch the publication membership info. */
5752  puboids = GetRelationPublications(relid);
5753  schemaid = RelationGetNamespace(relation);
5754  puboids = list_concat_unique_oid(puboids, GetSchemaPublications(schemaid));
5755 
5756  if (relation->rd_rel->relispartition)
5757  {
5758  /* Add publications that the ancestors are in too. */
5759  ancestors = get_partition_ancestors(relid);
5760 
5761  foreach(lc, ancestors)
5762  {
5763  Oid ancestor = lfirst_oid(lc);
5764 
5765  puboids = list_concat_unique_oid(puboids,
5766  GetRelationPublications(ancestor));
5767  schemaid = get_rel_namespace(ancestor);
5768  puboids = list_concat_unique_oid(puboids,
5769  GetSchemaPublications(schemaid));
5770  }
5771  }
5772  puboids = list_concat_unique_oid(puboids, GetAllTablesPublications());
5773 
5774  foreach(lc, puboids)
5775  {
5776  Oid pubid = lfirst_oid(lc);
5777  HeapTuple tup;
5778  Form_pg_publication pubform;
5779 
5780  tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
5781 
5782  if (!HeapTupleIsValid(tup))
5783  elog(ERROR, "cache lookup failed for publication %u", pubid);
5784 
5785  pubform = (Form_pg_publication) GETSTRUCT(tup);
5786 
5787  pubdesc->pubactions.pubinsert |= pubform->pubinsert;
5788  pubdesc->pubactions.pubupdate |= pubform->pubupdate;
5789  pubdesc->pubactions.pubdelete |= pubform->pubdelete;
5790  pubdesc->pubactions.pubtruncate |= pubform->pubtruncate;
5791 
5792  /*
5793  * Check if all columns referenced in the filter expression are part
5794  * of the REPLICA IDENTITY index or not.
5795  *
5796  * If the publication is FOR ALL TABLES then it means the table has no
5797  * row filters and we can skip the validation.
5798  */
5799  if (!pubform->puballtables &&
5800  (pubform->pubupdate || pubform->pubdelete) &&
5801  pub_rf_contains_invalid_column(pubid, relation, ancestors,
5802  pubform->pubviaroot))
5803  {
5804  if (pubform->pubupdate)
5805  pubdesc->rf_valid_for_update = false;
5806  if (pubform->pubdelete)
5807  pubdesc->rf_valid_for_delete = false;
5808  }
5809 
5810  /*
5811  * Check if all columns are part of the REPLICA IDENTITY index or not.
5812  *
5813  * If the publication is FOR ALL TABLES then it means the table has no
5814  * column list and we can skip the validation.
5815  */
5816  if (!pubform->puballtables &&
5817  (pubform->pubupdate || pubform->pubdelete) &&
5818  pub_collist_contains_invalid_column(pubid, relation, ancestors,
5819  pubform->pubviaroot))
5820  {
5821  if (pubform->pubupdate)
5822  pubdesc->cols_valid_for_update = false;
5823  if (pubform->pubdelete)
5824  pubdesc->cols_valid_for_delete = false;
5825  }
5826 
5827  ReleaseSysCache(tup);
5828 
5829  /*
5830  * If we know everything is replicated and the row filter is invalid
5831  * for update and delete, there is no point to check for other
5832  * publications.
5833  */
5834