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