/*-------------------------------------------------------------------------
 *
 * relcache.c
 *   POSTGRES relation descriptor cache code
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/utils/cache/relcache.c
 *
 *-------------------------------------------------------------------------
 */
/*
 * INTERFACE ROUTINES
 *  RelationCacheInitialize   - initialize relcache (to empty)
 *  RelationCacheInitializePhase2 - initialize shared-catalog entries
 *  RelationCacheInitializePhase3 - finish initializing relcache
 *  RelationIdGetRelation   - get a reldesc by relation id
 *  RelationClose     - close an open relation
 *
 * NOTES
 *  The following code contains many undocumented hacks.  Please be
 *  careful....
 */
#include "postgres.h"

#include <sys/file.h>
#include <fcntl.h>
#include <unistd.h>

#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/parallel.h"
#include "access/reloptions.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "access/tableam.h"
#include "access/tupdesc_details.h"
#include "access/xact.h"
#include "catalog/binary_upgrade.h"
#include "catalog/catalog.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/partition.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_auth_members.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_publication.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_shseclabel.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_subscription.h"
#include "catalog/pg_tablespace.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "catalog/schemapg.h"
#include "catalog/storage.h"
#include "commands/policy.h"
#include "commands/publicationcmds.h"
#include "commands/trigger.h"
#include "common/int.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "pgstat.h"
#include "rewrite/rewriteDefine.h"
#include "rewrite/rowsecurity.h"
#include "storage/lmgr.h"
#include "storage/smgr.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/relmapper.h"
#include "utils/resowner.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

#define RELCACHE_INIT_FILEMAGIC  0x573266 /* version ID value */

/*
 * Whether to bother checking if relation cache memory needs to be freed
 * eagerly.  See also RelationBuildDesc() and pg_config_manual.h.
 */
#if defined(RECOVER_RELATION_BUILD_MEMORY) && (RECOVER_RELATION_BUILD_MEMORY != 0)
#define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
#else
#define RECOVER_RELATION_BUILD_MEMORY 0
#ifdef DISCARD_CACHES_ENABLED
#define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
#endif
#endif

/*
 *  hardcoded tuple descriptors, contents generated by genbki.pl
 */
static const FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
static const FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
static const FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
static const FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
static const FormData_pg_attribute Desc_pg_database[Natts_pg_database] = {Schema_pg_database};
static const FormData_pg_attribute Desc_pg_authid[Natts_pg_authid] = {Schema_pg_authid};
static const FormData_pg_attribute Desc_pg_auth_members[Natts_pg_auth_members] = {Schema_pg_auth_members};
static const FormData_pg_attribute Desc_pg_index[Natts_pg_index] = {Schema_pg_index};
static const FormData_pg_attribute Desc_pg_shseclabel[Natts_pg_shseclabel] = {Schema_pg_shseclabel};
static const FormData_pg_attribute Desc_pg_subscription[Natts_pg_subscription] = {Schema_pg_subscription};

/*
 *  Hash tables that index the relation cache
 *
 *  We used to index the cache by both name and OID, but now there
 *  is only an index by OID.
 */
typedef struct relidcacheent
{
 Oid   reloid;
 Relation reldesc;
} RelIdCacheEnt;

static HTAB *RelationIdCache;

/*
 * This flag is false until we have prepared the critical relcache entries
 * that are needed to do indexscans on the tables read by relcache building.
 */
bool  criticalRelcachesBuilt = false;

/*
 * This flag is false until we have prepared the critical relcache entries
 * for shared catalogs (which are the tables needed for login).
 */
bool  criticalSharedRelcachesBuilt = false;

/*
 * This counter counts relcache inval events received since backend startup
 * (but only for rels that are actually in cache).  Presently, we use it only
 * to detect whether data about to be written by write_relcache_init_file()
 * might already be obsolete.
 */
static long relcacheInvalsReceived = 0L;

/*
 * in_progress_list is a stack of ongoing RelationBuildDesc() calls.  CREATE
 * INDEX CONCURRENTLY makes catalog changes under ShareUpdateExclusiveLock.
 * It critically relies on each backend absorbing those changes no later than
 * next transaction start.  Hence, RelationBuildDesc() loops until it finishes
 * without accepting a relevant invalidation.  (Most invalidation consumers
 * don't do this.)
 */
typedef struct inprogressent
{
 Oid   reloid;   /* OID of relation being built */
 bool  invalidated; /* whether an invalidation arrived for it */
} InProgressEnt;

static InProgressEnt *in_progress_list;
static int in_progress_list_len;
static int in_progress_list_maxlen;

/*
 * eoxact_list[] stores the OIDs of relations that (might) need AtEOXact
 * cleanup work.  This list intentionally has limited size; if it overflows,
 * we fall back to scanning the whole hashtable.  There is no value in a very
 * large list because (1) at some point, a hash_seq_search scan is faster than
 * retail lookups, and (2) the value of this is to reduce EOXact work for
 * short transactions, which can't have dirtied all that many tables anyway.
 * EOXactListAdd() does not bother to prevent duplicate list entries, so the
 * cleanup processing must be idempotent.
 */
#define MAX_EOXACT_LIST 32
static Oid eoxact_list[MAX_EOXACT_LIST];
static int eoxact_list_len = 0;
static bool eoxact_list_overflowed = false;

#define EOXactListAdd(rel) \
 do { \
  if (eoxact_list_len < MAX_EOXACT_LIST) \
   eoxact_list[eoxact_list_len++] = (rel)->rd_id; \
  else \
   eoxact_list_overflowed = true; \
 } while (0)

/*
 * EOXactTupleDescArray stores TupleDescs that (might) need AtEOXact
 * cleanup work.  The array expands as needed; there is no hashtable because
 * we don't need to access individual items except at EOXact.
 */
static TupleDesc *EOXactTupleDescArray;
static int NextEOXactTupleDescNum = 0;
static int EOXactTupleDescArrayLen = 0;

/*
 *  macros to manipulate the lookup hashtable
 */
#define RelationCacheInsert(RELATION, replace_allowed) \
do { \
 RelIdCacheEnt *hentry; bool found; \
 hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
             &((RELATION)->rd_id), \
             HASH_ENTER, &found); \
 if (found) \
 { \
  /* see comments in RelationBuildDesc and RelationBuildLocalRelation */ \
  Relation _old_rel = hentry->reldesc; \
  Assert(replace_allowed); \
  hentry->reldesc = (RELATION); \
  if (RelationHasReferenceCountZero(_old_rel)) \
   RelationDestroyRelation(_old_rel, false); \
  else if (!IsBootstrapProcessingMode()) \
   elog(WARNING, "leaking still-referenced relcache entry for \"%s\"", \
     RelationGetRelationName(_old_rel)); \
 } \
 else \
  hentry->reldesc = (RELATION); \
} while(0)

#define RelationIdCacheLookup(ID, RELATION) \
do { \
 RelIdCacheEnt *hentry; \
 hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
             &(ID), \
             HASH_FIND, NULL); \
 if (hentry) \
  RELATION = hentry->reldesc; \
 else \
  RELATION = NULL; \
} while(0)

#define RelationCacheDelete(RELATION) \
do { \
 RelIdCacheEnt *hentry; \
 hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
             &((RELATION)->rd_id), \
             HASH_REMOVE, NULL); \
 if (hentry == NULL) \
  elog(WARNING, "failed to delete relcache entry for OID %u", \
    (RELATION)->rd_id); \
} while(0)


/*
 * Special cache for opclass-related information
 *
 * Note: only default support procs get cached, ie, those with
 * lefttype = righttype = opcintype.
 */
typedef struct opclasscacheent
{
 Oid   opclassoid;  /* lookup key: OID of opclass */
 bool  valid;   /* set true after successful fill-in */
 StrategyNumber numSupport; /* max # of support procs (from pg_am) */
 Oid   opcfamily;  /* OID of opclass's family */
 Oid   opcintype;  /* OID of opclass's declared input type */
 RegProcedure *supportProcs; /* OIDs of support procedures */
} OpClassCacheEnt;

static HTAB *OpClassCache = NULL;


/* non-export function prototypes */

static void RelationCloseCleanup(Relation relation);
static void RelationDestroyRelation(Relation relation, bool remember_tupdesc);
static void RelationInvalidateRelation(Relation relation);
static void RelationClearRelation(Relation relation);
static void RelationRebuildRelation(Relation relation);

static void RelationReloadIndexInfo(Relation relation);
static void RelationReloadNailed(Relation relation);
static void RelationFlushRelation(Relation relation);
static void RememberToFreeTupleDescAtEOX(TupleDesc td);
#ifdef USE_ASSERT_CHECKING
static void AssertPendingSyncConsistency(Relation relation);
#endif
static void AtEOXact_cleanup(Relation relation, bool isCommit);
static void AtEOSubXact_cleanup(Relation relation, bool isCommit,
        SubTransactionId mySubid, SubTransactionId parentSubid);
static bool load_relcache_init_file(bool shared);
static void write_relcache_init_file(bool shared);
static void write_item(const void *data, Size len, FILE *fp);

static void formrdesc(const char *relationName, Oid relationReltype,
       bool isshared, int natts, const FormData_pg_attribute *attrs);

static HeapTuple ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic);
static Relation AllocateRelationDesc(Form_pg_class relp);
static void RelationParseRelOptions(Relation relation, HeapTuple tuple);
static void RelationBuildTupleDesc(Relation relation);
static Relation RelationBuildDesc(Oid targetRelId, bool insertIt);
static void RelationInitPhysicalAddr(Relation relation);
static void load_critical_index(Oid indexoid, Oid heapoid);
static TupleDesc GetPgClassDescriptor(void);
static TupleDesc GetPgIndexDescriptor(void);
static void AttrDefaultFetch(Relation relation, int ndef);
static int AttrDefaultCmp(const void *a, const void *b);
static void CheckNNConstraintFetch(Relation relation);
static int CheckConstraintCmp(const void *a, const void *b);
static void InitIndexAmRoutine(Relation relation);
static void IndexSupportInitialize(oidvector *indclass,
           RegProcedure *indexSupport,
           Oid *opFamily,
           Oid *opcInType,
           StrategyNumber maxSupportNumber,
           AttrNumber maxAttributeNumber);
static OpClassCacheEnt *LookupOpclassInfo(Oid operatorClassOid,
            StrategyNumber numSupport);
static void RelationCacheInitFileRemoveInDir(const char *tblspcpath);
static void unlink_initfile(const char *initfilename, int elevel);


/*
 *  ScanPgRelation
 *
 *  This is used by RelationBuildDesc to find a pg_class
 *  tuple matching targetRelId.  The caller must hold at least
 *  AccessShareLock on the target relid to prevent concurrent-update
 *  scenarios; it isn't guaranteed that all scans used to build the
 *  relcache entry will use the same snapshot.  If, for example,
 *  an attribute were to be added after scanning pg_class and before
 *  scanning pg_attribute, relnatts wouldn't match.
 *
 *  NB: the returned tuple has been copied into palloc'd storage
 *  and must eventually be freed with heap_freetuple.
 */
static HeapTuple
ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic)
{
 HeapTuple pg_class_tuple;
 Relation pg_class_desc;
 SysScanDesc pg_class_scan;
 ScanKeyData key[1];
 Snapshot snapshot = NULL;

 /*
  * If something goes wrong during backend startup, we might find ourselves
  * trying to read pg_class before we've selected a database.  That ain't
  * gonna work, so bail out with a useful error message.  If this happens,
  * it probably means a relcache entry that needs to be nailed isn't.
 */
 if (!OidIsValid(MyDatabaseId))
  elog(FATAL, "cannot read pg_class without having selected a database");

 /*
  * form a scan key
 */
 ScanKeyInit(&key[0],
    Anum_pg_class_oid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(targetRelId));

 /*
  * Open pg_class and fetch a tuple.  Force heap scan if we haven't yet
  * built the critical relcache entries (this includes initdb and startup
  * without a pg_internal.init file).  The caller can also force a heap
  * scan by setting indexOK == false.
 */
 pg_class_desc = table_open(RelationRelationId, AccessShareLock);

 /*
  * The caller might need a tuple that's newer than what's visible to the
  * historic snapshot; currently the only case requiring to do so is
  * looking up the relfilenumber of non mapped system relations during
  * decoding.
 */
 if (force_non_historic)
  snapshot = RegisterSnapshot(GetNonHistoricCatalogSnapshot(RelationRelationId));

 pg_class_scan = systable_beginscan(pg_class_desc, ClassOidIndexId,
            indexOK && criticalRelcachesBuilt,
            snapshot,
            1, key);

 pg_class_tuple = systable_getnext(pg_class_scan);

 /*
  * Must copy tuple before releasing buffer.
 */
 if (HeapTupleIsValid(pg_class_tuple))
  pg_class_tuple = heap_copytuple(pg_class_tuple);

 /* all done */
 systable_endscan(pg_class_scan);

 if (snapshot)
  UnregisterSnapshot(snapshot);

 table_close(pg_class_desc, AccessShareLock);

 return pg_class_tuple;
}

/*
 *  AllocateRelationDesc
 *
 *  This is used to allocate memory for a new relation descriptor
 *  and initialize the rd_rel field from the given pg_class tuple.
 */
static Relation
AllocateRelationDesc(Form_pg_class relp)
{
 Relation relation;
 MemoryContext oldcxt;
 Form_pg_class relationForm;

 /* Relcache entries must live in CacheMemoryContext */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

 /*
  * allocate and zero space for new relation descriptor
 */
 relation = (Relation) palloc0(sizeof(RelationData));

 /* make sure relation is marked as having no open file yet */
 relation->rd_smgr = NULL;

 /*
  * Copy the relation tuple form
  *
  * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. The
  * variable-length fields (relacl, reloptions) are NOT stored in the
  * relcache --- there'd be little point in it, since we don't copy the
  * tuple's nulls bitmap and hence wouldn't know if the values are valid.
  * Bottom line is that relacl *cannot* be retrieved from the relcache. Get
  * it from the syscache if you need it.  The same goes for the original
  * form of reloptions (however, we do store the parsed form of reloptions
  * in rd_options).
 */
 relationForm = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);

 memcpy(relationForm, relp, CLASS_TUPLE_SIZE);

 /* initialize relation tuple form */
 relation->rd_rel = relationForm;

 /* and allocate attribute tuple form storage */
 relation->rd_att = CreateTemplateTupleDesc(relationForm->relnatts);
 /* which we mark as a reference-counted tupdesc */
 relation->rd_att->tdrefcount = 1;

 MemoryContextSwitchTo(oldcxt);

 return relation;
}

/*
 * RelationParseRelOptions
 *  Convert pg_class.reloptions into pre-parsed rd_options
 *
 * tuple is the real pg_class tuple (not rd_rel!) for relation
 *
 * Note: rd_rel and (if an index) rd_indam must be valid already
 */
static void
RelationParseRelOptions(Relation relation, HeapTuple tuple)
{
 bytea    *options;
 amoptions_function amoptsfn;

 relation->rd_options = NULL;

 /*
  * Look up any AM-specific parse function; fall out if relkind should not
  * have options.
 */
 switch (relation->rd_rel->relkind)
 {
  case RELKIND_RELATION:
  case RELKIND_TOASTVALUE:
  case RELKIND_VIEW:
  case RELKIND_MATVIEW:
  case RELKIND_PARTITIONED_TABLE:
   amoptsfn = NULL;
   break;
  case RELKIND_INDEX:
  case RELKIND_PARTITIONED_INDEX:
   amoptsfn = relation->rd_indam->amoptions;
   break;
  default:
   return;
 }

 /*
  * Fetch reloptions from tuple; have to use a hardwired descriptor because
  * we might not have any other for pg_class yet (consider executing this
  * code for pg_class itself)
 */
 options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn);

 /*
  * Copy parsed data into CacheMemoryContext.  To guard against the
  * possibility of leaks in the reloptions code, we want to do the actual
  * parsing in the caller's memory context and copy the results into
  * CacheMemoryContext after the fact.
 */
 if (options)
 {
  relation->rd_options = MemoryContextAlloc(CacheMemoryContext,
              VARSIZE(options));
  memcpy(relation->rd_options, options, VARSIZE(options));
  pfree(options);
 }
}

/*
 *  RelationBuildTupleDesc
 *
 *  Form the relation's tuple descriptor from information in
 *  the pg_attribute, pg_attrdef & pg_constraint system catalogs.
 */
static void
RelationBuildTupleDesc(Relation relation)
{
 HeapTuple pg_attribute_tuple;
 Relation pg_attribute_desc;
 SysScanDesc pg_attribute_scan;
 ScanKeyData skey[2];
 int   need;
 TupleConstr *constr;
 AttrMissing *attrmiss = NULL;
 int   ndef = 0;

 /* fill rd_att's type ID fields (compare heap.c's AddNewRelationTuple) */
 relation->rd_att->tdtypeid =
  relation->rd_rel->reltype ? relation->rd_rel->reltype : RECORDOID;
 relation->rd_att->tdtypmod = -1; /* just to be sure */

 constr = (TupleConstr *) MemoryContextAllocZero(CacheMemoryContext,
             sizeof(TupleConstr));

 /*
  * Form a scan key that selects only user attributes (attnum > 0).
  * (Eliminating system attribute rows at the index level is lots faster
  * than fetching them.)
 */
 ScanKeyInit(&skey[0],
    Anum_pg_attribute_attrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));
 ScanKeyInit(&skey[1],
    Anum_pg_attribute_attnum,
    BTGreaterStrategyNumber, F_INT2GT,
    Int16GetDatum(0));

 /*
  * Open pg_attribute and begin a scan.  Force heap scan if we haven't yet
  * built the critical relcache entries (this includes initdb and startup
  * without a pg_internal.init file).
 */
 pg_attribute_desc = table_open(AttributeRelationId, AccessShareLock);
 pg_attribute_scan = systable_beginscan(pg_attribute_desc,
             AttributeRelidNumIndexId,
             criticalRelcachesBuilt,
             NULL,
             2, skey);

 /*
  * add attribute data to relation->rd_att
 */
 need = RelationGetNumberOfAttributes(relation);

 while (HeapTupleIsValid(pg_attribute_tuple = systable_getnext(pg_attribute_scan)))
 {
  Form_pg_attribute attp;
  int   attnum;

  attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);

  attnum = attp->attnum;
  if (attnum <= 0 || attnum > RelationGetNumberOfAttributes(relation))
   elog(ERROR, "invalid attribute number %d for relation \"%s\"",
     attp->attnum, RelationGetRelationName(relation));

  memcpy(TupleDescAttr(relation->rd_att, attnum - 1),
      attp,
      ATTRIBUTE_FIXED_PART_SIZE);

  populate_compact_attribute(relation->rd_att, attnum - 1);

  /* Update constraint/default info */
  if (attp->attnotnull)
   constr->has_not_null = true;
  if (attp->attgenerated == ATTRIBUTE_GENERATED_STORED)
   constr->has_generated_stored = true;
  if (attp->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
   constr->has_generated_virtual = true;
  if (attp->atthasdef)
   ndef++;

  /* If the column has a "missing" value, put it in the attrmiss array */
  if (attp->atthasmissing)
  {
   Datum  missingval;
   bool  missingNull;

   /* Do we have a missing value? */
   missingval = heap_getattr(pg_attribute_tuple,
           Anum_pg_attribute_attmissingval,
           pg_attribute_desc->rd_att,
           &missingNull);
   if (!missingNull)
   {
    /* Yes, fetch from the array */
    MemoryContext oldcxt;
    bool  is_null;
    int   one = 1;
    Datum  missval;

    if (attrmiss == NULL)
     attrmiss = (AttrMissing *)
      MemoryContextAllocZero(CacheMemoryContext,
              relation->rd_rel->relnatts *
              sizeof(AttrMissing));

    missval = array_get_element(missingval,
           1,
           &one,
           -1,
           attp->attlen,
           attp->attbyval,
           attp->attalign,
           &is_null);
    Assert(!is_null);
    if (attp->attbyval)
    {
     /* for copy by val just copy the datum direct */
     attrmiss[attnum - 1].am_value = missval;
    }
    else
    {
     /* otherwise copy in the correct context */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     attrmiss[attnum - 1].am_value = datumCopy(missval,
                 attp->attbyval,
                 attp->attlen);
     MemoryContextSwitchTo(oldcxt);
    }
    attrmiss[attnum - 1].am_present = true;
   }
  }
  need--;
  if (need == 0)
   break;
 }

 /*
  * end the scan and close the attribute relation
 */
 systable_endscan(pg_attribute_scan);
 table_close(pg_attribute_desc, AccessShareLock);

 if (need != 0)
  elog(ERROR, "pg_attribute catalog is missing %d attribute(s) for relation OID %u",
    need, RelationGetRelid(relation));

 /*
  * We can easily set the attcacheoff value for the first attribute: it
  * must be zero.  This eliminates the need for special cases for attnum=1
  * that used to exist in fastgetattr() and index_getattr().
 */
 if (RelationGetNumberOfAttributes(relation) > 0)
  TupleDescCompactAttr(relation->rd_att, 0)->attcacheoff = 0;

 /*
  * Set up constraint/default info
 */
 if (constr->has_not_null ||
  constr->has_generated_stored ||
  constr->has_generated_virtual ||
  ndef > 0 ||
  attrmiss ||
  relation->rd_rel->relchecks > 0)
 {
  bool  is_catalog = IsCatalogRelation(relation);

  relation->rd_att->constr = constr;

  if (ndef > 0)   /* DEFAULTs */
   AttrDefaultFetch(relation, ndef);
  else
   constr->num_defval = 0;

  constr->missing = attrmiss;

  /* CHECK and NOT NULLs */
  if (relation->rd_rel->relchecks > 0 ||
   (!is_catalog && constr->has_not_null))
   CheckNNConstraintFetch(relation);

  /*
   * Any not-null constraint that wasn't marked invalid by
   * CheckNNConstraintFetch must necessarily be valid; make it so in the
   * CompactAttribute array.
 */
  if (!is_catalog)
  {
   for (int i = 0; i < relation->rd_rel->relnatts; i++)
   {
    CompactAttribute *attr;

    attr = TupleDescCompactAttr(relation->rd_att, i);

    if (attr->attnullability == ATTNULLABLE_UNKNOWN)
     attr->attnullability = ATTNULLABLE_VALID;
    else
     Assert(attr->attnullability == ATTNULLABLE_INVALID ||
         attr->attnullability == ATTNULLABLE_UNRESTRICTED);
   }
  }

  if (relation->rd_rel->relchecks == 0)
   constr->num_check = 0;
 }
 else
 {
  pfree(constr);
  relation->rd_att->constr = NULL;
 }
}

/*
 *  RelationBuildRuleLock
 *
 *  Form the relation's rewrite rules from information in
 *  the pg_rewrite system catalog.
 *
 * Note: The rule parsetrees are potentially very complex node structures.
 * To allow these trees to be freed when the relcache entry is flushed,
 * we make a private memory context to hold the RuleLock information for
 * each relcache entry that has associated rules.  The context is used
 * just for rule info, not for any other subsidiary data of the relcache
 * entry, because that keeps the update logic in RelationRebuildRelation()
 * manageable.  The other subsidiary data structures are simple enough
 * to be easy to free explicitly, anyway.
 *
 * Note: The relation's reloptions must have been extracted first.
 */
static void
RelationBuildRuleLock(Relation relation)
{
 MemoryContext rulescxt;
 MemoryContext oldcxt;
 HeapTuple rewrite_tuple;
 Relation rewrite_desc;
 TupleDesc rewrite_tupdesc;
 SysScanDesc rewrite_scan;
 ScanKeyData key;
 RuleLock   *rulelock;
 int   numlocks;
 RewriteRule **rules;
 int   maxlocks;

 /*
  * Make the private context.  Assume it'll not contain much data.
 */
 rulescxt = AllocSetContextCreate(CacheMemoryContext,
          "relation rules",
          ALLOCSET_SMALL_SIZES);
 relation->rd_rulescxt = rulescxt;
 MemoryContextCopyAndSetIdentifier(rulescxt,
           RelationGetRelationName(relation));

 /*
  * allocate an array to hold the rewrite rules (the array is extended if
  * necessary)
 */
 maxlocks = 4;
 rules = (RewriteRule **)
  MemoryContextAlloc(rulescxt, sizeof(RewriteRule *) * maxlocks);
 numlocks = 0;

 /*
  * form a scan key
 */
 ScanKeyInit(&key,
    Anum_pg_rewrite_ev_class,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));

 /*
  * open pg_rewrite and begin a scan
  *
  * Note: since we scan the rules using RewriteRelRulenameIndexId, we will
  * be reading the rules in name order, except possibly during
  * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
  * ensures that rules will be fired in name order.
 */
 rewrite_desc = table_open(RewriteRelationId, AccessShareLock);
 rewrite_tupdesc = RelationGetDescr(rewrite_desc);
 rewrite_scan = systable_beginscan(rewrite_desc,
           RewriteRelRulenameIndexId,
           true, NULL,
           1, &key);

 while (HeapTupleIsValid(rewrite_tuple = systable_getnext(rewrite_scan)))
 {
  Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple);
  bool  isnull;
  Datum  rule_datum;
  char    *rule_str;
  RewriteRule *rule;
  Oid   check_as_user;

  rule = (RewriteRule *) MemoryContextAlloc(rulescxt,
              sizeof(RewriteRule));

  rule->ruleId = rewrite_form->oid;

  rule->event = rewrite_form->ev_type - '0';
  rule->enabled = rewrite_form->ev_enabled;
  rule->isInstead = rewrite_form->is_instead;

  /*
   * Must use heap_getattr to fetch ev_action and ev_qual.  Also, the
   * rule strings are often large enough to be toasted.  To avoid
   * leaking memory in the caller's context, do the detoasting here so
   * we can free the detoasted version.
 */
  rule_datum = heap_getattr(rewrite_tuple,
          Anum_pg_rewrite_ev_action,
          rewrite_tupdesc,
          &isnull);
  Assert(!isnull);
  rule_str = TextDatumGetCString(rule_datum);
  oldcxt = MemoryContextSwitchTo(rulescxt);
  rule->actions = (List *) stringToNode(rule_str);
  MemoryContextSwitchTo(oldcxt);
  pfree(rule_str);

  rule_datum = heap_getattr(rewrite_tuple,
          Anum_pg_rewrite_ev_qual,
          rewrite_tupdesc,
          &isnull);
  Assert(!isnull);
  rule_str = TextDatumGetCString(rule_datum);
  oldcxt = MemoryContextSwitchTo(rulescxt);
  rule->qual = (Node *) stringToNode(rule_str);
  MemoryContextSwitchTo(oldcxt);
  pfree(rule_str);

  /*
   * If this is a SELECT rule defining a view, and the view has
   * "security_invoker" set, we must perform all permissions checks on
   * relations referred to by the rule as the invoking user.
   *
   * In all other cases (including non-SELECT rules on security invoker
   * views), perform the permissions checks as the relation owner.
 */
  if (rule->event == CMD_SELECT &&
   relation->rd_rel->relkind == RELKIND_VIEW &&
   RelationHasSecurityInvoker(relation))
   check_as_user = InvalidOid;
  else
   check_as_user = relation->rd_rel->relowner;

  /*
   * Scan through the rule's actions and set the checkAsUser field on
   * all RTEPermissionInfos. We have to look at the qual as well, in
   * case it contains sublinks.
   *
   * The reason for doing this when the rule is loaded, rather than when
   * it is stored, is that otherwise ALTER TABLE OWNER would have to
   * grovel through stored rules to update checkAsUser fields. Scanning
   * the rule tree during load is relatively cheap (compared to
   * constructing it in the first place), so we do it here.
 */
  setRuleCheckAsUser((Node *) rule->actions, check_as_user);
  setRuleCheckAsUser(rule->qual, check_as_user);

  if (numlocks >= maxlocks)
  {
   maxlocks *= 2;
   rules = (RewriteRule **)
    repalloc(rules, sizeof(RewriteRule *) * maxlocks);
  }
  rules[numlocks++] = rule;
 }

 /*
  * end the scan and close the attribute relation
 */
 systable_endscan(rewrite_scan);
 table_close(rewrite_desc, AccessShareLock);

 /*
  * there might not be any rules (if relhasrules is out-of-date)
 */
 if (numlocks == 0)
 {
  relation->rd_rules = NULL;
  relation->rd_rulescxt = NULL;
  MemoryContextDelete(rulescxt);
  return;
 }

 /*
  * form a RuleLock and insert into relation
 */
 rulelock = (RuleLock *) MemoryContextAlloc(rulescxt, sizeof(RuleLock));
 rulelock->numLocks = numlocks;
 rulelock->rules = rules;

 relation->rd_rules = rulelock;
}

/*
 *  equalRuleLocks
 *
 *  Determine whether two RuleLocks are equivalent
 *
 *  Probably this should be in the rules code someplace...
 */
static bool
equalRuleLocks(RuleLock *rlock1, RuleLock *rlock2)
{
 int   i;

 /*
  * As of 7.3 we assume the rule ordering is repeatable, because
  * RelationBuildRuleLock should read 'em in a consistent order.  So just
  * compare corresponding slots.
 */
 if (rlock1 != NULL)
 {
  if (rlock2 == NULL)
   return false;
  if (rlock1->numLocks != rlock2->numLocks)
   return false;
  for (i = 0; i < rlock1->numLocks; i++)
  {
   RewriteRule *rule1 = rlock1->rules[i];
   RewriteRule *rule2 = rlock2->rules[i];

   if (rule1->ruleId != rule2->ruleId)
    return false;
   if (rule1->event != rule2->event)
    return false;
   if (rule1->enabled != rule2->enabled)
    return false;
   if (rule1->isInstead != rule2->isInstead)
    return false;
   if (!equal(rule1->qual, rule2->qual))
    return false;
   if (!equal(rule1->actions, rule2->actions))
    return false;
  }
 }
 else if (rlock2 != NULL)
  return false;
 return true;
}

/*
 *  equalPolicy
 *
 *  Determine whether two policies are equivalent
 */
static bool
equalPolicy(RowSecurityPolicy *policy1, RowSecurityPolicy *policy2)
{
 int   i;
 Oid     *r1,
      *r2;

 if (policy1 != NULL)
 {
  if (policy2 == NULL)
   return false;

  if (policy1->polcmd != policy2->polcmd)
   return false;
  if (policy1->hassublinks != policy2->hassublinks)
   return false;
  if (strcmp(policy1->policy_name, policy2->policy_name) != 0)
   return false;
  if (ARR_DIMS(policy1->roles)[0] != ARR_DIMS(policy2->roles)[0])
   return false;

  r1 = (Oid *) ARR_DATA_PTR(policy1->roles);
  r2 = (Oid *) ARR_DATA_PTR(policy2->roles);

  for (i = 0; i < ARR_DIMS(policy1->roles)[0]; i++)
  {
   if (r1[i] != r2[i])
    return false;
  }

  if (!equal(policy1->qual, policy2->qual))
   return false;
  if (!equal(policy1->with_check_qual, policy2->with_check_qual))
   return false;
 }
 else if (policy2 != NULL)
  return false;

 return true;
}

/*
 *  equalRSDesc
 *
 *  Determine whether two RowSecurityDesc's are equivalent
 */
static bool
equalRSDesc(RowSecurityDesc *rsdesc1, RowSecurityDesc *rsdesc2)
{
 ListCell   *lc,
      *rc;

 if (rsdesc1 == NULL && rsdesc2 == NULL)
  return true;

 if ((rsdesc1 != NULL && rsdesc2 == NULL) ||
  (rsdesc1 == NULL && rsdesc2 != NULL))
  return false;

 if (list_length(rsdesc1->policies) != list_length(rsdesc2->policies))
  return false;

 /* RelationBuildRowSecurity should build policies in order */
 forboth(lc, rsdesc1->policies, rc, rsdesc2->policies)
 {
  RowSecurityPolicy *l = (RowSecurityPolicy *) lfirst(lc);
  RowSecurityPolicy *r = (RowSecurityPolicy *) lfirst(rc);

  if (!equalPolicy(l, r))
   return false;
 }

 return true;
}

/*
 *  RelationBuildDesc
 *
 *  Build a relation descriptor.  The caller must hold at least
 *  AccessShareLock on the target relid.
 *
 *  The new descriptor is inserted into the hash table if insertIt is true.
 *
 *  Returns NULL if no pg_class row could be found for the given relid
 *  (suggesting we are trying to access a just-deleted relation).
 *  Any other error is reported via elog.
 */
static Relation
RelationBuildDesc(Oid targetRelId, bool insertIt)
{
 int   in_progress_offset;
 Relation relation;
 Oid   relid;
 HeapTuple pg_class_tuple;
 Form_pg_class relp;

 /*
  * This function and its subroutines can allocate a good deal of transient
  * data in CurrentMemoryContext.  Traditionally we've just leaked that
  * data, reasoning that the caller's context is at worst of transaction
  * scope, and relcache loads shouldn't happen so often that it's essential
  * to recover transient data before end of statement/transaction.  However
  * that's definitely not true when debug_discard_caches is active, and
  * perhaps it's not true in other cases.
  *
  * When debug_discard_caches is active or when forced to by
  * RECOVER_RELATION_BUILD_MEMORY=1, arrange to allocate the junk in a
  * temporary context that we'll free before returning.  Make it a child of
  * caller's context so that it will get cleaned up appropriately if we
  * error out partway through.
 */
#ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
 MemoryContext tmpcxt = NULL;
 MemoryContext oldcxt = NULL;

 if (RECOVER_RELATION_BUILD_MEMORY || debug_discard_caches > 0)
 {
  tmpcxt = AllocSetContextCreate(CurrentMemoryContext,
            "RelationBuildDesc workspace",
            ALLOCSET_DEFAULT_SIZES);
  oldcxt = MemoryContextSwitchTo(tmpcxt);
 }
#endif

 /* Register to catch invalidation messages */
 if (in_progress_list_len >= in_progress_list_maxlen)
 {
  int   allocsize;

  allocsize = in_progress_list_maxlen * 2;
  in_progress_list = repalloc(in_progress_list,
         allocsize * sizeof(*in_progress_list));
  in_progress_list_maxlen = allocsize;
 }
 in_progress_offset = in_progress_list_len++;
 in_progress_list[in_progress_offset].reloid = targetRelId;
retry:
 in_progress_list[in_progress_offset].invalidated = false;

 /*
  * find the tuple in pg_class corresponding to the given relation id
 */
 pg_class_tuple = ScanPgRelation(targetRelId, true, false);

 /*
  * if no such tuple exists, return NULL
 */
 if (!HeapTupleIsValid(pg_class_tuple))
 {
#ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
  if (tmpcxt)
  {
   /* Return to caller's context, and blow away the temporary context */
   MemoryContextSwitchTo(oldcxt);
   MemoryContextDelete(tmpcxt);
  }
#endif
  Assert(in_progress_offset + 1 == in_progress_list_len);
  in_progress_list_len--;
  return NULL;
 }

 /*
  * get information from the pg_class_tuple
 */
 relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
 relid = relp->oid;
 Assert(relid == targetRelId);

 /*
  * allocate storage for the relation descriptor, and copy pg_class_tuple
  * to relation->rd_rel.
 */
 relation = AllocateRelationDesc(relp);

 /*
  * initialize the relation's relation id (relation->rd_id)
 */
 RelationGetRelid(relation) = relid;

 /*
  * Normal relations are not nailed into the cache.  Since we don't flush
  * new relations, it won't be new.  It could be temp though.
 */
 relation->rd_refcnt = 0;
 relation->rd_isnailed = false;
 relation->rd_createSubid = InvalidSubTransactionId;
 relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
 relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
 relation->rd_droppedSubid = InvalidSubTransactionId;
 switch (relation->rd_rel->relpersistence)
 {
  case RELPERSISTENCE_UNLOGGED:
  case RELPERSISTENCE_PERMANENT:
   relation->rd_backend = INVALID_PROC_NUMBER;
   relation->rd_islocaltemp = false;
   break;
  case RELPERSISTENCE_TEMP:
   if (isTempOrTempToastNamespace(relation->rd_rel->relnamespace))
   {
    relation->rd_backend = ProcNumberForTempRelations();
    relation->rd_islocaltemp = true;
   }
   else
   {
    /*
     * If it's a temp table, but not one of ours, we have to use
     * the slow, grotty method to figure out the owning backend.
     *
     * Note: it's possible that rd_backend gets set to
     * MyProcNumber here, in case we are looking at a pg_class
     * entry left over from a crashed backend that coincidentally
     * had the same ProcNumber we're using.  We should *not*
     * consider such a table to be "ours"; this is why we need the
     * separate rd_islocaltemp flag.  The pg_class entry will get
     * flushed if/when we clean out the corresponding temp table
     * namespace in preparation for using it.
 */
    relation->rd_backend =
     GetTempNamespaceProcNumber(relation->rd_rel->relnamespace);
    Assert(relation->rd_backend != INVALID_PROC_NUMBER);
    relation->rd_islocaltemp = false;
   }
   break;
  default:
   elog(ERROR, "invalid relpersistence: %c",
     relation->rd_rel->relpersistence);
   break;
 }

 /*
  * initialize the tuple descriptor (relation->rd_att).
 */
 RelationBuildTupleDesc(relation);

 /* foreign key data is not loaded till asked for */
 relation->rd_fkeylist = NIL;
 relation->rd_fkeyvalid = false;

 /* partitioning data is not loaded till asked for */
 relation->rd_partkey = NULL;
 relation->rd_partkeycxt = NULL;
 relation->rd_partdesc = NULL;
 relation->rd_partdesc_nodetached = NULL;
 relation->rd_partdesc_nodetached_xmin = InvalidTransactionId;
 relation->rd_pdcxt = NULL;
 relation->rd_pddcxt = NULL;
 relation->rd_partcheck = NIL;
 relation->rd_partcheckvalid = false;
 relation->rd_partcheckcxt = NULL;

 /*
  * initialize access method information
 */
 if (relation->rd_rel->relkind == RELKIND_INDEX ||
  relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
  RelationInitIndexAccessInfo(relation);
 else if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) ||
    relation->rd_rel->relkind == RELKIND_SEQUENCE)
  RelationInitTableAccessMethod(relation);
 else if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
 {
  /*
   * Do nothing: access methods are a setting that partitions can
   * inherit.
 */
 }
 else
  Assert(relation->rd_rel->relam == InvalidOid);

 /* extract reloptions if any */
 RelationParseRelOptions(relation, pg_class_tuple);

 /*
  * Fetch rules and triggers that affect this relation.
  *
  * Note that RelationBuildRuleLock() relies on this being done after
  * extracting the relation's reloptions.
 */
 if (relation->rd_rel->relhasrules)
  RelationBuildRuleLock(relation);
 else
 {
  relation->rd_rules = NULL;
  relation->rd_rulescxt = NULL;
 }

 if (relation->rd_rel->relhastriggers)
  RelationBuildTriggers(relation);
 else
  relation->trigdesc = NULL;

 if (relation->rd_rel->relrowsecurity)
  RelationBuildRowSecurity(relation);
 else
  relation->rd_rsdesc = NULL;

 /*
  * initialize the relation lock manager information
 */
 RelationInitLockInfo(relation); /* see lmgr.c */

 /*
  * initialize physical addressing information for the relation
 */
 RelationInitPhysicalAddr(relation);

 /* make sure relation is marked as having no open file yet */
 relation->rd_smgr = NULL;

 /*
  * now we can free the memory allocated for pg_class_tuple
 */
 heap_freetuple(pg_class_tuple);

 /*
  * If an invalidation arrived mid-build, start over.  Between here and the
  * end of this function, don't add code that does or reasonably could read
  * system catalogs.  That range must be free from invalidation processing
  * for the !insertIt case.  For the insertIt case, RelationCacheInsert()
  * will enroll this relation in ordinary relcache invalidation processing,
 */
 if (in_progress_list[in_progress_offset].invalidated)
 {
  RelationDestroyRelation(relation, false);
  goto retry;
 }
 Assert(in_progress_offset + 1 == in_progress_list_len);
 in_progress_list_len--;

 /*
  * Insert newly created relation into relcache hash table, if requested.
  *
  * There is one scenario in which we might find a hashtable entry already
  * present, even though our caller failed to find it: if the relation is a
  * system catalog or index that's used during relcache load, we might have
  * recursively created the same relcache entry during the preceding steps.
  * So allow RelationCacheInsert to delete any already-present relcache
  * entry for the same OID.  The already-present entry should have refcount
  * zero (else somebody forgot to close it); in the event that it doesn't,
  * we'll elog a WARNING and leak the already-present entry.
 */
 if (insertIt)
  RelationCacheInsert(relation, true);

 /* It's fully valid */
 relation->rd_isvalid = true;

#ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
 if (tmpcxt)
 {
  /* Return to caller's context, and blow away the temporary context */
  MemoryContextSwitchTo(oldcxt);
  MemoryContextDelete(tmpcxt);
 }
#endif

 return relation;
}

/*
 * Initialize the physical addressing info (RelFileLocator) for a relcache entry
 *
 * Note: at the physical level, relations in the pg_global tablespace must
 * be treated as shared, even if relisshared isn't set.  Hence we do not
 * look at relisshared here.
 */
static void
RelationInitPhysicalAddr(Relation relation)
{
 RelFileNumber oldnumber = relation->rd_locator.relNumber;

 /* these relations kinds never have storage */
 if (!RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
  return;

 if (relation->rd_rel->reltablespace)
  relation->rd_locator.spcOid = relation->rd_rel->reltablespace;
 else
  relation->rd_locator.spcOid = MyDatabaseTableSpace;
 if (relation->rd_locator.spcOid == GLOBALTABLESPACE_OID)
  relation->rd_locator.dbOid = InvalidOid;
 else
  relation->rd_locator.dbOid = MyDatabaseId;

 if (relation->rd_rel->relfilenode)
 {
  /*
   * Even if we are using a decoding snapshot that doesn't represent the
   * current state of the catalog we need to make sure the filenode
   * points to the current file since the older file will be gone (or
   * truncated). The new file will still contain older rows so lookups
   * in them will work correctly. This wouldn't work correctly if
   * rewrites were allowed to change the schema in an incompatible way,
   * but those are prevented both on catalog tables and on user tables
   * declared as additional catalog tables.
 */
  if (HistoricSnapshotActive()
   && RelationIsAccessibleInLogicalDecoding(relation)
   && IsTransactionState())
  {
   HeapTuple phys_tuple;
   Form_pg_class physrel;

   phys_tuple = ScanPgRelation(RelationGetRelid(relation),
          RelationGetRelid(relation) != ClassOidIndexId,
          true);
   if (!HeapTupleIsValid(phys_tuple))
    elog(ERROR, "could not find pg_class entry for %u",
      RelationGetRelid(relation));
   physrel = (Form_pg_class) GETSTRUCT(phys_tuple);

   relation->rd_rel->reltablespace = physrel->reltablespace;
   relation->rd_rel->relfilenode = physrel->relfilenode;
   heap_freetuple(phys_tuple);
  }

  relation->rd_locator.relNumber = relation->rd_rel->relfilenode;
 }
 else
 {
  /* Consult the relation mapper */
  relation->rd_locator.relNumber =
   RelationMapOidToFilenumber(relation->rd_id,
            relation->rd_rel->relisshared);
  if (!RelFileNumberIsValid(relation->rd_locator.relNumber))
   elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u",
     RelationGetRelationName(relation), relation->rd_id);
 }

 /*
  * For RelationNeedsWAL() to answer correctly on parallel workers, restore
  * rd_firstRelfilelocatorSubid.  No subtransactions start or end while in
  * parallel mode, so the specific SubTransactionId does not matter.
 */
 if (IsParallelWorker() && oldnumber != relation->rd_locator.relNumber)
 {
  if (RelFileLocatorSkippingWAL(relation->rd_locator))
   relation->rd_firstRelfilelocatorSubid = TopSubTransactionId;
  else
   relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
 }
}

/*
 * Fill in the IndexAmRoutine for an index relation.
 *
 * relation's rd_amhandler and rd_indexcxt must be valid already.
 */
static void
InitIndexAmRoutine(Relation relation)
{
 IndexAmRoutine *cached,
      *tmp;

 /*
  * Call the amhandler in current, short-lived memory context, just in case
  * it leaks anything (it probably won't, but let's be paranoid).
 */
 tmp = GetIndexAmRoutine(relation->rd_amhandler);

 /* OK, now transfer the data into relation's rd_indexcxt. */
 cached = (IndexAmRoutine *) MemoryContextAlloc(relation->rd_indexcxt,
               sizeof(IndexAmRoutine));
 memcpy(cached, tmp, sizeof(IndexAmRoutine));
 relation->rd_indam = cached;

 pfree(tmp);
}

/*
 * Initialize index-access-method support data for an index relation
 */
void
RelationInitIndexAccessInfo(Relation relation)
{
 HeapTuple tuple;
 Form_pg_am aform;
 Datum  indcollDatum;
 Datum  indclassDatum;
 Datum  indoptionDatum;
 bool  isnull;
 oidvector  *indcoll;
 oidvector  *indclass;
 int2vector *indoption;
 MemoryContext indexcxt;
 MemoryContext oldcontext;
 int   indnatts;
 int   indnkeyatts;
 uint16  amsupport;

 /*
  * Make a copy of the pg_index entry for the index.  Since pg_index
  * contains variable-length and possibly-null fields, we have to do this
  * honestly rather than just treating it as a Form_pg_index struct.
 */
 tuple = SearchSysCache1(INDEXRELID,
       ObjectIdGetDatum(RelationGetRelid(relation)));
 if (!HeapTupleIsValid(tuple))
  elog(ERROR, "cache lookup failed for index %u",
    RelationGetRelid(relation));
 oldcontext = MemoryContextSwitchTo(CacheMemoryContext);
 relation->rd_indextuple = heap_copytuple(tuple);
 relation->rd_index = (Form_pg_index) GETSTRUCT(relation->rd_indextuple);
 MemoryContextSwitchTo(oldcontext);
 ReleaseSysCache(tuple);

 /*
  * Look up the index's access method, save the OID of its handler function
 */
 Assert(relation->rd_rel->relam != InvalidOid);
 tuple = SearchSysCache1(AMOID, ObjectIdGetDatum(relation->rd_rel->relam));
 if (!HeapTupleIsValid(tuple))
  elog(ERROR, "cache lookup failed for access method %u",
    relation->rd_rel->relam);
 aform = (Form_pg_am) GETSTRUCT(tuple);
 relation->rd_amhandler = aform->amhandler;
 ReleaseSysCache(tuple);

 indnatts = RelationGetNumberOfAttributes(relation);
 if (indnatts != IndexRelationGetNumberOfAttributes(relation))
  elog(ERROR, "relnatts disagrees with indnatts for index %u",
    RelationGetRelid(relation));
 indnkeyatts = IndexRelationGetNumberOfKeyAttributes(relation);

 /*
  * Make the private context to hold index access info.  The reason we need
  * a context, and not just a couple of pallocs, is so that we won't leak
  * any subsidiary info attached to fmgr lookup records.
 */
 indexcxt = AllocSetContextCreate(CacheMemoryContext,
          "index info",
          ALLOCSET_SMALL_SIZES);
 relation->rd_indexcxt = indexcxt;
 MemoryContextCopyAndSetIdentifier(indexcxt,
           RelationGetRelationName(relation));

 /*
  * Now we can fetch the index AM's API struct
 */
 InitIndexAmRoutine(relation);

 /*
  * Allocate arrays to hold data. Opclasses are not used for included
  * columns, so allocate them for indnkeyatts only.
 */
 relation->rd_opfamily = (Oid *)
  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
 relation->rd_opcintype = (Oid *)
  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));

 amsupport = relation->rd_indam->amsupport;
 if (amsupport > 0)
 {
  int   nsupport = indnatts * amsupport;

  relation->rd_support = (RegProcedure *)
   MemoryContextAllocZero(indexcxt, nsupport * sizeof(RegProcedure));
  relation->rd_supportinfo = (FmgrInfo *)
   MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
 }
 else
 {
  relation->rd_support = NULL;
  relation->rd_supportinfo = NULL;
 }

 relation->rd_indcollation = (Oid *)
  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));

 relation->rd_indoption = (int16 *)
  MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(int16));

 /*
  * indcollation cannot be referenced directly through the C struct,
  * because it comes after the variable-width indkey field.  Must extract
  * the datum the hard way...
 */
 indcollDatum = fastgetattr(relation->rd_indextuple,
          Anum_pg_index_indcollation,
          GetPgIndexDescriptor(),
          &isnull);
 Assert(!isnull);
 indcoll = (oidvector *) DatumGetPointer(indcollDatum);
 memcpy(relation->rd_indcollation, indcoll->values, indnkeyatts * sizeof(Oid));

 /*
  * indclass cannot be referenced directly through the C struct, because it
  * comes after the variable-width indkey field.  Must extract the datum
  * the hard way...
 */
 indclassDatum = fastgetattr(relation->rd_indextuple,
        Anum_pg_index_indclass,
        GetPgIndexDescriptor(),
        &isnull);
 Assert(!isnull);
 indclass = (oidvector *) DatumGetPointer(indclassDatum);

 /*
  * Fill the support procedure OID array, as well as the info about
  * opfamilies and opclass input types.  (aminfo and supportinfo are left
  * as zeroes, and are filled on-the-fly when used)
 */
 IndexSupportInitialize(indclass, relation->rd_support,
         relation->rd_opfamily, relation->rd_opcintype,
         amsupport, indnkeyatts);

 /*
  * Similarly extract indoption and copy it to the cache entry
 */
 indoptionDatum = fastgetattr(relation->rd_indextuple,
         Anum_pg_index_indoption,
         GetPgIndexDescriptor(),
         &isnull);
 Assert(!isnull);
 indoption = (int2vector *) DatumGetPointer(indoptionDatum);
 memcpy(relation->rd_indoption, indoption->values, indnkeyatts * sizeof(int16));

 (void) RelationGetIndexAttOptions(relation, false);

 /*
  * expressions, predicate, exclusion caches will be filled later
 */
 relation->rd_indexprs = NIL;
 relation->rd_indpred = NIL;
 relation->rd_exclops = NULL;
 relation->rd_exclprocs = NULL;
 relation->rd_exclstrats = NULL;
 relation->rd_amcache = NULL;
}

/*
 * IndexSupportInitialize
 *  Initializes an index's cached opclass information,
 *  given the index's pg_index.indclass entry.
 *
 * Data is returned into *indexSupport, *opFamily, and *opcInType,
 * which are arrays allocated by the caller.
 *
 * The caller also passes maxSupportNumber and maxAttributeNumber, since these
 * indicate the size of the arrays it has allocated --- but in practice these
 * numbers must always match those obtainable from the system catalog entries
 * for the index and access method.
 */
static void
IndexSupportInitialize(oidvector *indclass,
        RegProcedure *indexSupport,
        Oid *opFamily,
        Oid *opcInType,
        StrategyNumber maxSupportNumber,
        AttrNumber maxAttributeNumber)
{
 int   attIndex;

 for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
 {
  OpClassCacheEnt *opcentry;

  if (!OidIsValid(indclass->values[attIndex]))
   elog(ERROR, "bogus pg_index tuple");

  /* look up the info for this opclass, using a cache */
  opcentry = LookupOpclassInfo(indclass->values[attIndex],
          maxSupportNumber);

  /* copy cached data into relcache entry */
  opFamily[attIndex] = opcentry->opcfamily;
  opcInType[attIndex] = opcentry->opcintype;
  if (maxSupportNumber > 0)
   memcpy(&indexSupport[attIndex * maxSupportNumber],
       opcentry->supportProcs,
       maxSupportNumber * sizeof(RegProcedure));
 }
}

/*
 * LookupOpclassInfo
 *
 * This routine maintains a per-opclass cache of the information needed
 * by IndexSupportInitialize().  This is more efficient than relying on
 * the catalog cache, because we can load all the info about a particular
 * opclass in a single indexscan of pg_amproc.
 *
 * The information from pg_am about expected range of support function
 * numbers is passed in, rather than being looked up, mainly because the
 * caller will have it already.
 *
 * Note there is no provision for flushing the cache.  This is OK at the
 * moment because there is no way to ALTER any interesting properties of an
 * existing opclass --- all you can do is drop it, which will result in
 * a useless but harmless dead entry in the cache.  To support altering
 * opclass membership (not the same as opfamily membership!), we'd need to
 * be able to flush this cache as well as the contents of relcache entries
 * for indexes.
 */
static OpClassCacheEnt *
LookupOpclassInfo(Oid operatorClassOid,
      StrategyNumber numSupport)
{
 OpClassCacheEnt *opcentry;
 bool  found;
 Relation rel;
 SysScanDesc scan;
 ScanKeyData skey[3];
 HeapTuple htup;
 bool  indexOK;

 if (OpClassCache == NULL)
 {
  /* First time through: initialize the opclass cache */
  HASHCTL  ctl;

  /* Also make sure CacheMemoryContext exists */
  if (!CacheMemoryContext)
   CreateCacheMemoryContext();

  ctl.keysize = sizeof(Oid);
  ctl.entrysize = sizeof(OpClassCacheEnt);
  OpClassCache = hash_create("Operator class cache", 64,
           &ctl, HASH_ELEM | HASH_BLOBS);
 }

 opcentry = (OpClassCacheEnt *) hash_search(OpClassCache,
              &operatorClassOid,
              HASH_ENTER, &found);

 if (!found)
 {
  /* Initialize new entry */
  opcentry->valid = false; /* until known OK */
  opcentry->numSupport = numSupport;
  opcentry->supportProcs = NULL; /* filled below */
 }
 else
 {
  Assert(numSupport == opcentry->numSupport);
 }

 /*
  * When aggressively testing cache-flush hazards, we disable the operator
  * class cache and force reloading of the info on each call.  This models
  * no real-world behavior, since the cache entries are never invalidated
  * otherwise.  However it can be helpful for detecting bugs in the cache
  * loading logic itself, such as reliance on a non-nailed index.  Given
  * the limited use-case and the fact that this adds a great deal of
  * expense, we enable it only for high values of debug_discard_caches.
 */
#ifdef DISCARD_CACHES_ENABLED
 if (debug_discard_caches > 2)
  opcentry->valid = false;
#endif

 if (opcentry->valid)
  return opcentry;

 /*
  * Need to fill in new entry.  First allocate space, unless we already did
  * so in some previous attempt.
 */
 if (opcentry->supportProcs == NULL && numSupport > 0)
  opcentry->supportProcs = (RegProcedure *)
   MemoryContextAllocZero(CacheMemoryContext,
           numSupport * sizeof(RegProcedure));

 /*
  * To avoid infinite recursion during startup, force heap scans if we're
  * looking up info for the opclasses used by the indexes we would like to
  * reference here.
 */
 indexOK = criticalRelcachesBuilt ||
  (operatorClassOid != OID_BTREE_OPS_OID &&
   operatorClassOid != INT2_BTREE_OPS_OID);

 /*
  * We have to fetch the pg_opclass row to determine its opfamily and
  * opcintype, which are needed to look up related operators and functions.
  * It'd be convenient to use the syscache here, but that probably doesn't
  * work while bootstrapping.
 */
 ScanKeyInit(&skey[0],
    Anum_pg_opclass_oid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(operatorClassOid));
 rel = table_open(OperatorClassRelationId, AccessShareLock);
 scan = systable_beginscan(rel, OpclassOidIndexId, indexOK,
         NULL, 1, skey);

 if (HeapTupleIsValid(htup = systable_getnext(scan)))
 {
  Form_pg_opclass opclassform = (Form_pg_opclass) GETSTRUCT(htup);

  opcentry->opcfamily = opclassform->opcfamily;
  opcentry->opcintype = opclassform->opcintype;
 }
 else
  elog(ERROR, "could not find tuple for opclass %u", operatorClassOid);

 systable_endscan(scan);
 table_close(rel, AccessShareLock);

 /*
  * Scan pg_amproc to obtain support procs for the opclass.  We only fetch
  * the default ones (those with lefttype = righttype = opcintype).
 */
 if (numSupport > 0)
 {
  ScanKeyInit(&skey[0],
     Anum_pg_amproc_amprocfamily,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(opcentry->opcfamily));
  ScanKeyInit(&skey[1],
     Anum_pg_amproc_amproclefttype,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(opcentry->opcintype));
  ScanKeyInit(&skey[2],
     Anum_pg_amproc_amprocrighttype,
     BTEqualStrategyNumber, F_OIDEQ,
     ObjectIdGetDatum(opcentry->opcintype));
  rel = table_open(AccessMethodProcedureRelationId, AccessShareLock);
  scan = systable_beginscan(rel, AccessMethodProcedureIndexId, indexOK,
          NULL, 3, skey);

  while (HeapTupleIsValid(htup = systable_getnext(scan)))
  {
   Form_pg_amproc amprocform = (Form_pg_amproc) GETSTRUCT(htup);

   if (amprocform->amprocnum <= 0 ||
    (StrategyNumber) amprocform->amprocnum > numSupport)
    elog(ERROR, "invalid amproc number %d for opclass %u",
      amprocform->amprocnum, operatorClassOid);

   opcentry->supportProcs[amprocform->amprocnum - 1] =
    amprocform->amproc;
  }

  systable_endscan(scan);
  table_close(rel, AccessShareLock);
 }

 opcentry->valid = true;
 return opcentry;
}

/*
 * Fill in the TableAmRoutine for a relation
 *
 * relation's rd_amhandler must be valid already.
 */
static void
InitTableAmRoutine(Relation relation)
{
 relation->rd_tableam = GetTableAmRoutine(relation->rd_amhandler);
}

/*
 * Initialize table access method support for a table like relation
 */
void
RelationInitTableAccessMethod(Relation relation)
{
 HeapTuple tuple;
 Form_pg_am aform;

 if (relation->rd_rel->relkind == RELKIND_SEQUENCE)
 {
  /*
   * Sequences are currently accessed like heap tables, but it doesn't
   * seem prudent to show that in the catalog. So just overwrite it
   * here.
 */
  Assert(relation->rd_rel->relam == InvalidOid);
  relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
 }
 else if (IsCatalogRelation(relation))
 {
  /*
   * Avoid doing a syscache lookup for catalog tables.
 */
  Assert(relation->rd_rel->relam == HEAP_TABLE_AM_OID);
  relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
 }
 else
 {
  /*
   * Look up the table access method, save the OID of its handler
   * function.
 */
  Assert(relation->rd_rel->relam != InvalidOid);
  tuple = SearchSysCache1(AMOID,
        ObjectIdGetDatum(relation->rd_rel->relam));
  if (!HeapTupleIsValid(tuple))
   elog(ERROR, "cache lookup failed for access method %u",
     relation->rd_rel->relam);
  aform = (Form_pg_am) GETSTRUCT(tuple);
  relation->rd_amhandler = aform->amhandler;
  ReleaseSysCache(tuple);
 }

 /*
  * Now we can fetch the table AM's API struct
 */
 InitTableAmRoutine(relation);
}

/*
 *  formrdesc
 *
 *  This is a special cut-down version of RelationBuildDesc(),
 *  used while initializing the relcache.
 *  The relation descriptor is built just from the supplied parameters,
 *  without actually looking at any system table entries.  We cheat
 *  quite a lot since we only need to work for a few basic system
 *  catalogs.
 *
 * The catalogs this is used for can't have constraints (except attnotnull),
 * default values, rules, or triggers, since we don't cope with any of that.
 * (Well, actually, this only matters for properties that need to be valid
 * during bootstrap or before RelationCacheInitializePhase3 runs, and none of
 * these properties matter then...)
 *
 * NOTE: we assume we are already switched into CacheMemoryContext.
 */
static void
formrdesc(const char *relationName, Oid relationReltype,
    bool isshared,
    int natts, const FormData_pg_attribute *attrs)
{
 Relation relation;
 int   i;
 bool  has_not_null;

 /*
  * allocate new relation desc, clear all fields of reldesc
 */
 relation = (Relation) palloc0(sizeof(RelationData));

 /* make sure relation is marked as having no open file yet */
 relation->rd_smgr = NULL;

 /*
  * initialize reference count: 1 because it is nailed in cache
 */
 relation->rd_refcnt = 1;

 /*
  * all entries built with this routine are nailed-in-cache; none are for
  * new or temp relations.
 */
 relation->rd_isnailed = true;
 relation->rd_createSubid = InvalidSubTransactionId;
 relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
 relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
 relation->rd_droppedSubid = InvalidSubTransactionId;
 relation->rd_backend = INVALID_PROC_NUMBER;
 relation->rd_islocaltemp = false;

 /*
  * initialize relation tuple form
  *
  * The data we insert here is pretty incomplete/bogus, but it'll serve to
  * get us launched.  RelationCacheInitializePhase3() will read the real
  * data from pg_class and replace what we've done here.  Note in
  * particular that relowner is left as zero; this cues
  * RelationCacheInitializePhase3 that the real data isn't there yet.
 */
 relation->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);

 namestrcpy(&relation->rd_rel->relname, relationName);
 relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
 relation->rd_rel->reltype = relationReltype;

 /*
  * It's important to distinguish between shared and non-shared relations,
  * even at bootstrap time, to make sure we know where they are stored.
 */
 relation->rd_rel->relisshared = isshared;
 if (isshared)
  relation->rd_rel->reltablespace = GLOBALTABLESPACE_OID;

 /* formrdesc is used only for permanent relations */
 relation->rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;

 /* ... and they're always populated, too */
 relation->rd_rel->relispopulated = true;

 relation->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
 relation->rd_rel->relpages = 0;
 relation->rd_rel->reltuples = -1;
 relation->rd_rel->relallvisible = 0;
 relation->rd_rel->relallfrozen = 0;
 relation->rd_rel->relkind = RELKIND_RELATION;
 relation->rd_rel->relnatts = (int16) natts;

 /*
  * initialize attribute tuple form
  *
  * Unlike the case with the relation tuple, this data had better be right
  * because it will never be replaced.  The data comes from
  * src/include/catalog/ headers via genbki.pl.
 */
 relation->rd_att = CreateTemplateTupleDesc(natts);
 relation->rd_att->tdrefcount = 1; /* mark as refcounted */

 relation->rd_att->tdtypeid = relationReltype;
 relation->rd_att->tdtypmod = -1; /* just to be sure */

 /*
  * initialize tuple desc info
 */
 has_not_null = false;
 for (i = 0; i < natts; i++)
 {
  memcpy(TupleDescAttr(relation->rd_att, i),
      &attrs[i],
      ATTRIBUTE_FIXED_PART_SIZE);
  has_not_null |= attrs[i].attnotnull;

  populate_compact_attribute(relation->rd_att, i);
 }

 /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
 TupleDescCompactAttr(relation->rd_att, 0)->attcacheoff = 0;

 /* mark not-null status */
 if (has_not_null)
 {
  TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));

  constr->has_not_null = true;
  relation->rd_att->constr = constr;
 }

 /*
  * initialize relation id from info in att array (my, this is ugly)
 */
 RelationGetRelid(relation) = TupleDescAttr(relation->rd_att, 0)->attrelid;

 /*
  * All relations made with formrdesc are mapped.  This is necessarily so
  * because there is no other way to know what filenumber they currently
  * have.  In bootstrap mode, add them to the initial relation mapper data,
  * specifying that the initial filenumber is the same as the OID.
 */
 relation->rd_rel->relfilenode = InvalidRelFileNumber;
 if (IsBootstrapProcessingMode())
  RelationMapUpdateMap(RelationGetRelid(relation),
        RelationGetRelid(relation),
        isshared, true);

 /*
  * initialize the relation lock manager information
 */
 RelationInitLockInfo(relation); /* see lmgr.c */

 /*
  * initialize physical addressing information for the relation
 */
 RelationInitPhysicalAddr(relation);

 /*
  * initialize the table am handler
 */
 relation->rd_rel->relam = HEAP_TABLE_AM_OID;
 relation->rd_tableam = GetHeapamTableAmRoutine();

 /*
  * initialize the rel-has-index flag, using hardwired knowledge
 */
 if (IsBootstrapProcessingMode())
 {
  /* In bootstrap mode, we have no indexes */
  relation->rd_rel->relhasindex = false;
 }
 else
 {
  /* Otherwise, all the rels formrdesc is used for have indexes */
  relation->rd_rel->relhasindex = true;
 }

 /*
  * add new reldesc to relcache
 */
 RelationCacheInsert(relation, false);

 /* It's fully valid */
 relation->rd_isvalid = true;
}

#ifdef USE_ASSERT_CHECKING
/*
 *  AssertCouldGetRelation
 *
 *  Check safety of calling RelationIdGetRelation().
 *
 *  In code that reads catalogs in the event of a cache miss, call this
 *  before checking the cache.
 */
void
AssertCouldGetRelation(void)
{
 Assert(IsTransactionState());
 AssertBufferLocksPermitCatalogRead();
}
#endif


/* ----------------------------------------------------------------
 *     Relation Descriptor Lookup Interface
 * ----------------------------------------------------------------
 */

/*
 *  RelationIdGetRelation
 *
 *  Lookup a reldesc by OID; make one if not already in cache.
 *
 *  Returns NULL if no pg_class row could be found for the given relid
 *  (suggesting we are trying to access a just-deleted relation).
 *  Any other error is reported via elog.
 *
 *  NB: caller should already have at least AccessShareLock on the
 *  relation ID, else there are nasty race conditions.
 *
 *  NB: relation ref count is incremented, or set to 1 if new entry.
 *  Caller should eventually decrement count.  (Usually,
 *  that happens by calling RelationClose().)
 */
Relation
RelationIdGetRelation(Oid relationId)
{
 Relation rd;

 AssertCouldGetRelation();

 /*
  * first try to find reldesc in the cache
 */
 RelationIdCacheLookup(relationId, rd);

 if (RelationIsValid(rd))
 {
  /* return NULL for dropped relations */
  if (rd->rd_droppedSubid != InvalidSubTransactionId)
  {
   Assert(!rd->rd_isvalid);
   return NULL;
  }

  RelationIncrementReferenceCount(rd);
  /* revalidate cache entry if necessary */
  if (!rd->rd_isvalid)
  {
   RelationRebuildRelation(rd);

   /*
    * Normally entries need to be valid here, but before the relcache
    * has been initialized, not enough infrastructure exists to
    * perform pg_class lookups. The structure of such entries doesn't
    * change, but we still want to update the rd_rel entry. So
    * rd_isvalid = false is left in place for a later lookup.
 */
   Assert(rd->rd_isvalid ||
       (rd->rd_isnailed && !criticalRelcachesBuilt));
  }
  return rd;
 }

 /*
  * no reldesc in the cache, so have RelationBuildDesc() build one and add
  * it.
 */
 rd = RelationBuildDesc(relationId, true);
 if (RelationIsValid(rd))
  RelationIncrementReferenceCount(rd);
 return rd;
}

/* ----------------------------------------------------------------
 *    cache invalidation support routines
 * ----------------------------------------------------------------
 */

/* ResourceOwner callbacks to track relcache references */
static void ResOwnerReleaseRelation(Datum res);
static char *ResOwnerPrintRelCache(Datum res);

static const ResourceOwnerDesc relref_resowner_desc =
{
 .name = "relcache reference",
 .release_phase = RESOURCE_RELEASE_BEFORE_LOCKS,
 .release_priority = RELEASE_PRIO_RELCACHE_REFS,
 .ReleaseResource = ResOwnerReleaseRelation,
 .DebugPrint = ResOwnerPrintRelCache
};

/* Convenience wrappers over ResourceOwnerRemember/Forget */
static inline void
ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel)
{
 ResourceOwnerRemember(owner, PointerGetDatum(rel), &relref_resowner_desc);
}
static inline void
ResourceOwnerForgetRelationRef(ResourceOwner owner, Relation rel)
{
 ResourceOwnerForget(owner, PointerGetDatum(rel), &relref_resowner_desc);
}

/*
 * RelationIncrementReferenceCount
 *  Increments relation reference count.
 *
 * Note: bootstrap mode has its own weird ideas about relation refcount
 * behavior; we ought to fix it someday, but for now, just disable
 * reference count ownership tracking in bootstrap mode.
 */
void
RelationIncrementReferenceCount(Relation rel)
{
 ResourceOwnerEnlarge(CurrentResourceOwner);
 rel->rd_refcnt += 1;
 if (!IsBootstrapProcessingMode())
  ResourceOwnerRememberRelationRef(CurrentResourceOwner, rel);
}

/*
 * RelationDecrementReferenceCount
 *  Decrements relation reference count.
 */
void
RelationDecrementReferenceCount(Relation rel)
{
 Assert(rel->rd_refcnt > 0);
 rel->rd_refcnt -= 1;
 if (!IsBootstrapProcessingMode())
  ResourceOwnerForgetRelationRef(CurrentResourceOwner, rel);
}

/*
 * RelationClose - close an open relation
 *
 * Actually, we just decrement the refcount.
 *
 * NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries
 * will be freed as soon as their refcount goes to zero.  In combination
 * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
 * to catch references to already-released relcache entries.  It slows
 * things down quite a bit, however.
 */
void
RelationClose(Relation relation)
{
 /* Note: no locking manipulations needed */
 RelationDecrementReferenceCount(relation);

 RelationCloseCleanup(relation);
}

static void
RelationCloseCleanup(Relation relation)
{
 /*
  * If the relation is no longer open in this session, we can clean up any
  * stale partition descriptors it has.  This is unlikely, so check to see
  * if there are child contexts before expending a call to mcxt.c.
 */
 if (RelationHasReferenceCountZero(relation))
 {
  if (relation->rd_pdcxt != NULL &&
   relation->rd_pdcxt->firstchild != NULL)
   MemoryContextDeleteChildren(relation->rd_pdcxt);

  if (relation->rd_pddcxt != NULL &&
   relation->rd_pddcxt->firstchild != NULL)
   MemoryContextDeleteChildren(relation->rd_pddcxt);
 }

#ifdef RELCACHE_FORCE_RELEASE
 if (RelationHasReferenceCountZero(relation) &&
  relation->rd_createSubid == InvalidSubTransactionId &&
  relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)
  RelationClearRelation(relation);
#endif
}

/*
 * RelationReloadIndexInfo - reload minimal information for an open index
 *
 * This function is used only for indexes.  A relcache inval on an index
 * can mean that its pg_class or pg_index row changed.  There are only
 * very limited changes that are allowed to an existing index's schema,
 * so we can update the relcache entry without a complete rebuild; which
 * is fortunate because we can't rebuild an index entry that is "nailed"
 * and/or in active use.  We support full replacement of the pg_class row,
 * as well as updates of a few simple fields of the pg_index row.
 *
 * We assume that at the time we are called, we have at least AccessShareLock
 * on the target index.
 *
 * If the target index is an index on pg_class or pg_index, we'd better have
 * previously gotten at least AccessShareLock on its underlying catalog,
 * else we are at risk of deadlock against someone trying to exclusive-lock
 * the heap and index in that order.  This is ensured in current usage by
 * only applying this to indexes being opened or having positive refcount.
 */
static void
RelationReloadIndexInfo(Relation relation)
{
 bool  indexOK;
 HeapTuple pg_class_tuple;
 Form_pg_class relp;

 /* Should be called only for invalidated, live indexes */
 Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
   relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
     !relation->rd_isvalid &&
     relation->rd_droppedSubid == InvalidSubTransactionId);

 /*
  * If it's a shared index, we might be called before backend startup has
  * finished selecting a database, in which case we have no way to read
  * pg_class yet.  However, a shared index can never have any significant
  * schema updates, so it's okay to mostly ignore the invalidation signal.
  * Its physical relfilenumber might've changed, but that's all.  Update
  * the physical relfilenumber, mark it valid and return without doing
  * anything more.
 */
 if (relation->rd_rel->relisshared && !criticalRelcachesBuilt)
 {
  RelationInitPhysicalAddr(relation);
  relation->rd_isvalid = true;
  return;
 }

 /*
  * Read the pg_class row
  *
  * Don't try to use an indexscan of pg_class_oid_index to reload the info
  * for pg_class_oid_index ...
  */
 indexOK = (RelationGetRelid(relation) != ClassOidIndexId);
 pg_class_tuple = ScanPgRelation(RelationGetRelid(relation), indexOK, false);
 if (!HeapTupleIsValid(pg_class_tuple))
  elog(ERROR, "could not find pg_class tuple for index %u",
    RelationGetRelid(relation));
 relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
 memcpy(relation->rd_rel, relp, CLASS_TUPLE_SIZE);
  /* Reload reloptions in case they changed */
 if (relation->rd_options)
  pfree(relation->rd_options);
 RelationParseRelOptions(relation, pg_class_tuple);
 /* done with pg_class tuple */
 heap_freetuple(pg_class_tuple);
 /* We must recalculate physical address in case it changed */
 RelationInitPhysicalAddr(relation);

 /*
  * For a non-system index, there are fields of the pg_index row that are
  * allowed to change, so re-read that row and update the relcache entry.
  * Most of the info derived from pg_index (such as support function lookup
  * info) cannot change, and indeed the whole point of this routine is to
  * update the relcache entry without clobbering that data; so wholesale
  * replacement is not appropriate.
 */
 if (!IsSystemRelation(relation))
 {
  HeapTuple tuple;
  Form_pg_index index;

  tuple = SearchSysCache1(INDEXRELID,
        ObjectIdGetDatum(RelationGetRelid(relation)));
  if (!HeapTupleIsValid(tuple))
   elog(ERROR, "cache lookup failed for index %u",
     RelationGetRelid(relation));
  index = (Form_pg_index) GETSTRUCT(tuple);

  /*
   * Basically, let's just copy all the bool fields.  There are one or
   * two of these that can't actually change in the current code, but
   * it's not worth it to track exactly which ones they are.  None of
   * the array fields are allowed to change, though.
 */
  relation->rd_index->indisunique = index->indisunique;
  relation->rd_index->indnullsnotdistinct = index->indnullsnotdistinct;
  relation->rd_index->indisprimary = index->indisprimary;
  relation->rd_index->indisexclusion = index->indisexclusion;
  relation->rd_index->indimmediate = index->indimmediate;
  relation->rd_index->indisclustered = index->indisclustered;
  relation->rd_index->indisvalid = index->indisvalid;
  relation->rd_index->indcheckxmin = index->indcheckxmin;
  relation->rd_index->indisready = index->indisready;
  relation->rd_index->indislive = index->indislive;
  relation->rd_index->indisreplident = index->indisreplident;

  /* Copy xmin too, as that is needed to make sense of indcheckxmin */
  HeapTupleHeaderSetXmin(relation->rd_indextuple->t_data,
          HeapTupleHeaderGetXmin(tuple->t_data));

  ReleaseSysCache(tuple);
 }

 /* Okay, now it's valid again */
 relation->rd_isvalid = true;
}

/*
 * RelationReloadNailed - reload minimal information for nailed relations.
 *
 * The structure of a nailed relation can never change (which is good, because
 * we rely on knowing their structure to be able to read catalog content). But
 * some parts, e.g. pg_class.relfrozenxid, are still important to have
 * accurate content for. Therefore those need to be reloaded after the arrival
 * of invalidations.
 */
static void
RelationReloadNailed(Relation relation)
{
 /* Should be called only for invalidated, nailed relations */
 Assert(!relation->rd_isvalid);
 Assert(relation->rd_isnailed);
 /* nailed indexes are handled by RelationReloadIndexInfo() */
 Assert(relation->rd_rel->relkind == RELKIND_RELATION);
 AssertCouldGetRelation();

 /*
  * Redo RelationInitPhysicalAddr in case it is a mapped relation whose
  * mapping changed.
 */
 RelationInitPhysicalAddr(relation);

 /*
  * Reload a non-index entry.  We can't easily do so if relcaches aren't
  * yet built, but that's fine because at that stage the attributes that
  * need to be current (like relfrozenxid) aren't yet accessed.  To ensure
  * the entry will later be revalidated, we leave it in invalid state, but
  * allow use (cf. RelationIdGetRelation()).
 */
 if (criticalRelcachesBuilt)
 {
  HeapTuple pg_class_tuple;
  Form_pg_class relp;

  /*
   * NB: Mark the entry as valid before starting to scan, to avoid
   * self-recursion when re-building pg_class.
 */
  relation->rd_isvalid = true;

  pg_class_tuple = ScanPgRelation(RelationGetRelid(relation),
          true, false);
  relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
  memcpy(relation->rd_rel, relp, CLASS_TUPLE_SIZE);
  heap_freetuple(pg_class_tuple);

  /*
   * Again mark as valid, to protect against concurrently arriving
   * invalidations.
 */
  relation->rd_isvalid = true;
 }
}

/*
 * RelationDestroyRelation
 *
 * Physically delete a relation cache entry and all subsidiary data.
 * Caller must already have unhooked the entry from the hash table.
 */
static void
RelationDestroyRelation(Relation relation, bool remember_tupdesc)
{
 Assert(RelationHasReferenceCountZero(relation));

 /*
  * Make sure smgr and lower levels close the relation's files, if they
  * weren't closed already.  (This was probably done by caller, but let's
  * just be real sure.)
 */
 RelationCloseSmgr(relation);

 /* break mutual link with stats entry */
 pgstat_unlink_relation(relation);

 /*
  * Free all the subsidiary data structures of the relcache entry, then the
  * entry itself.
 */
 if (relation->rd_rel)
  pfree(relation->rd_rel);
 /* can't use DecrTupleDescRefCount here */
 Assert(relation->rd_att->tdrefcount > 0);
 if (--relation->rd_att->tdrefcount == 0)
 {
  /*
   * If we Rebuilt a relcache entry during a transaction then its
   * possible we did that because the TupDesc changed as the result of
   * an ALTER TABLE that ran at less than AccessExclusiveLock. It's
   * possible someone copied that TupDesc, in which case the copy would
   * point to free'd memory. So if we rebuild an entry we keep the
   * TupDesc around until end of transaction, to be safe.
 */
  if (remember_tupdesc)
   RememberToFreeTupleDescAtEOX(relation->rd_att);
  else
   FreeTupleDesc(relation->rd_att);
 }
 FreeTriggerDesc(relation->trigdesc);
 list_free_deep(relation->rd_fkeylist);
 list_free(relation->rd_indexlist);
 list_free(relation->rd_statlist);
 bms_free(relation->rd_keyattr);
 bms_free(relation->rd_pkattr);
 bms_free(relation->rd_idattr);
 bms_free(relation->rd_hotblockingattr);
 bms_free(relation->rd_summarizedattr);
 if (relation->rd_pubdesc)
  pfree(relation->rd_pubdesc);
 if (relation->rd_options)
  pfree(relation->rd_options);
 if (relation->rd_indextuple)
  pfree(relation->rd_indextuple);
 if (relation->rd_amcache)
  pfree(relation->rd_amcache);
 if (relation->rd_fdwroutine)
  pfree(relation->rd_fdwroutine);
 if (relation->rd_indexcxt)
  MemoryContextDelete(relation->rd_indexcxt);
 if (relation->rd_rulescxt)
  MemoryContextDelete(relation->rd_rulescxt);
 if (relation->rd_rsdesc)
  MemoryContextDelete(relation->rd_rsdesc->rscxt);
 if (relation->rd_partkeycxt)
  MemoryContextDelete(relation->rd_partkeycxt);
 if (relation->rd_pdcxt)
  MemoryContextDelete(relation->rd_pdcxt);
 if (relation->rd_pddcxt)
  MemoryContextDelete(relation->rd_pddcxt);
 if (relation->rd_partcheckcxt)
  MemoryContextDelete(relation->rd_partcheckcxt);
 pfree(relation);
}

/*
 * RelationInvalidateRelation - mark a relation cache entry as invalid
 *
 * An entry that's marked as invalid will be reloaded on next access.
 */
static void
RelationInvalidateRelation(Relation relation)
{
 /*
  * Make sure smgr and lower levels close the relation's files, if they
  * weren't closed already.  If the relation is not getting deleted, the
  * next smgr access should reopen the files automatically.  This ensures
  * that the low-level file access state is updated after, say, a vacuum
  * truncation.
 */
 RelationCloseSmgr(relation);

 /* Free AM cached data, if any */
 if (relation->rd_amcache)
  pfree(relation->rd_amcache);
 relation->rd_amcache = NULL;

 relation->rd_isvalid = false;
}

/*
 * RelationClearRelation - physically blow away a relation cache entry
 *
 * The caller must ensure that the entry is no longer needed, i.e. its
 * reference count is zero.  Also, the rel or its storage must not be created
 * in the current transaction (rd_createSubid and rd_firstRelfilelocatorSubid
 * must not be set).
 */
static void
RelationClearRelation(Relation relation)
{
 Assert(RelationHasReferenceCountZero(relation));
 Assert(!relation->rd_isnailed);

 /*
  * Relations created in the same transaction must never be removed, see
  * RelationFlushRelation.
 */
 Assert(relation->rd_createSubid == InvalidSubTransactionId);
 Assert(relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId);
 Assert(relation->rd_droppedSubid == InvalidSubTransactionId);

 /* first mark it as invalid */
 RelationInvalidateRelation(relation);

 /* Remove it from the hash table */
 RelationCacheDelete(relation);

 /* And release storage */
 RelationDestroyRelation(relation, false);
}

/*
 * RelationRebuildRelation - rebuild a relation cache entry in place
 *
 * Reset and rebuild a relation cache entry from scratch (that is, from
 * catalog entries).  This is used when we are notified of a change to an open
 * relation (one with refcount > 0).  The entry is reconstructed without
 * moving the physical RelationData record, so that the refcount holder's
 * pointer is still valid.
 *
 * NB: when rebuilding, we'd better hold some lock on the relation, else the
 * catalog data we need to read could be changing under us.  Also, a rel to be
 * rebuilt had better have refcnt > 0.  This is because a sinval reset could
 * happen while we're accessing the catalogs, and the rel would get blown away
 * underneath us by RelationCacheInvalidate if it has zero refcnt.
 */
static void
RelationRebuildRelation(Relation relation)
{
 Assert(!RelationHasReferenceCountZero(relation));
 AssertCouldGetRelation();
 /* there is no reason to ever rebuild a dropped relation */
 Assert(relation->rd_droppedSubid == InvalidSubTransactionId);

 /* Close and mark it as invalid until we've finished the rebuild */
 RelationInvalidateRelation(relation);

 /*
  * Indexes only have a limited number of possible schema changes, and we
  * don't want to use the full-blown procedure because it's a headache for
  * indexes that reload itself depends on.
  *
  * As an exception, use the full procedure if the index access info hasn't
  * been initialized yet.  Index creation relies on that: it first builds
  * the relcache entry with RelationBuildLocalRelation(), creates the
  * pg_index tuple only after that, and then relies on
  * CommandCounterIncrement to load the pg_index contents.
 */
 if ((relation->rd_rel->relkind == RELKIND_INDEX ||
   relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
  relation->rd_indexcxt != NULL)
 {
  RelationReloadIndexInfo(relation);
  return;
 }
 /* Nailed relations are handled separately. */
 else if (relation->rd_isnailed)
 {
  RelationReloadNailed(relation);
  return;
 }
 else
 {
  /*
   * Our strategy for rebuilding an open relcache entry is to build a
   * new entry from scratch, swap its contents with the old entry, and
   * finally delete the new entry (along with any infrastructure swapped
   * over from the old entry).  This is to avoid trouble in case an
   * error causes us to lose control partway through.  The old entry
   * will still be marked !rd_isvalid, so we'll try to rebuild it again
   * on next access.  Meanwhile it's not any less valid than it was
   * before, so any code that might expect to continue accessing it
   * isn't hurt by the rebuild failure.  (Consider for example a
   * subtransaction that ALTERs a table and then gets canceled partway
   * through the cache entry rebuild.  The outer transaction should
   * still see the not-modified cache entry as valid.)  The worst
   * consequence of an error is leaking the necessarily-unreferenced new
   * entry, and this shouldn't happen often enough for that to be a big
   * problem.
   *
   * When rebuilding an open relcache entry, we must preserve ref count,
   * rd_*Subid, and rd_toastoid state.  Also attempt to preserve the
   * pg_class entry (rd_rel), tupledesc, rewrite-rule, partition key,
   * and partition descriptor substructures in place, because various
   * places assume that these structures won't move while they are
   * working with an open relcache entry.  (Note:  the refcount
   * mechanism for tupledescs might someday allow us to remove this hack
   * for the tupledesc.)
   *
   * Note that this process does not touch CurrentResourceOwner; which
   * is good because whatever ref counts the entry may have do not
   * necessarily belong to that resource owner.
 */
  Relation newrel;
  Oid   save_relid = RelationGetRelid(relation);
  bool  keep_tupdesc;
  bool  keep_rules;
  bool  keep_policies;
  bool  keep_partkey;

  /* Build temporary entry, but don't link it into hashtable */
  newrel = RelationBuildDesc(save_relid, false);

  /*
   * Between here and the end of the swap, don't add code that does or
   * reasonably could read system catalogs.  That range must be free
   * from invalidation processing.  See RelationBuildDesc() manipulation
   * of in_progress_list.
 */

  if (newrel == NULL)
  {
   /*
    * We can validly get here, if we're using a historic snapshot in
    * which a relation, accessed from outside logical decoding, is
    * still invisible. In that case it's fine to just mark the
    * relation as invalid and return - it'll fully get reloaded by
    * the cache reset at the end of logical decoding (or at the next
    * access).  During normal processing we don't want to ignore this
    * case as it shouldn't happen there, as explained below.
 */
   if (HistoricSnapshotActive())
    return;

   /*
    * This shouldn't happen as dropping a relation is intended to be
    * impossible if still referenced (cf. CheckTableNotInUse()). But
    * if we get here anyway, we can't just delete the relcache entry,
    * as it possibly could get accessed later (as e.g. the error
    * might get trapped and handled via a subtransaction rollback).
 */
   elog(ERROR, "relation %u deleted while still in use", save_relid);
  }

  /*
   * If we were to, again, have cases of the relkind of a relcache entry
   * changing, we would need to ensure that pgstats does not get
   * confused.
 */
  Assert(relation->rd_rel->relkind == newrel->rd_rel->relkind);

  keep_tupdesc = equalTupleDescs(relation->rd_att, newrel->rd_att);
  keep_rules = equalRuleLocks(relation->rd_rules, newrel->rd_rules);
  keep_policies = equalRSDesc(relation->rd_rsdesc, newrel->rd_rsdesc);
  /* partkey is immutable once set up, so we can always keep it */
  keep_partkey = (relation->rd_partkey != NULL);

  /*
   * Perform swapping of the relcache entry contents.  Within this
   * process the old entry is momentarily invalid, so there *must* be no
   * possibility of CHECK_FOR_INTERRUPTS within this sequence. Do it in
   * all-in-line code for safety.
   *
   * Since the vast majority of fields should be swapped, our method is
   * to swap the whole structures and then re-swap those few fields we
   * didn't want swapped.
 */
#define SWAPFIELD(fldtype, fldname) \
  do { \
   fldtype _tmp = newrel->fldname; \
   newrel->fldname = relation->fldname; \
   relation->fldname = _tmp; \
  } while (0)

  /* swap all Relation struct fields */
  {
   RelationData tmpstruct;

   memcpy(&tmpstruct, newrel, sizeof(RelationData));
   memcpy(newrel, relation, sizeof(RelationData));
   memcpy(relation, &tmpstruct, sizeof(RelationData));
  }

  /* rd_smgr must not be swapped, due to back-links from smgr level */
  SWAPFIELD(SMgrRelation, rd_smgr);
  /* rd_refcnt must be preserved */
  SWAPFIELD(int, rd_refcnt);
  /* isnailed shouldn't change */
  Assert(newrel->rd_isnailed == relation->rd_isnailed);
  /* creation sub-XIDs must be preserved */
  SWAPFIELD(SubTransactionId, rd_createSubid);
  SWAPFIELD(SubTransactionId, rd_newRelfilelocatorSubid);
  SWAPFIELD(SubTransactionId, rd_firstRelfilelocatorSubid);
  SWAPFIELD(SubTransactionId, rd_droppedSubid);
  /* un-swap rd_rel pointers, swap contents instead */
  SWAPFIELD(Form_pg_class, rd_rel);
  /* ... but actually, we don't have to update newrel->rd_rel */
  memcpy(relation->rd_rel, newrel->rd_rel, CLASS_TUPLE_SIZE);
  /* preserve old tupledesc, rules, policies if no logical change */
  if (keep_tupdesc)
   SWAPFIELD(TupleDesc, rd_att);
  if (keep_rules)
  {
   SWAPFIELD(RuleLock *, rd_rules);
   SWAPFIELD(MemoryContext, rd_rulescxt);
  }
  if (keep_policies)
   SWAPFIELD(RowSecurityDesc *, rd_rsdesc);
  /* toast OID override must be preserved */
  SWAPFIELD(Oid, rd_toastoid);
  /* pgstat_info / enabled must be preserved */
  SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
  SWAPFIELD(bool, pgstat_enabled);
  /* preserve old partition key if we have one */
  if (keep_partkey)
  {
   SWAPFIELD(PartitionKey, rd_partkey);
   SWAPFIELD(MemoryContext, rd_partkeycxt);
  }
  if (newrel->rd_pdcxt != NULL || newrel->rd_pddcxt != NULL)
  {
   /*
    * We are rebuilding a partitioned relation with a non-zero
    * reference count, so we must keep the old partition descriptor
    * around, in case there's a PartitionDirectory with a pointer to
    * it.  This means we can't free the old rd_pdcxt yet.  (This is
    * necessary because RelationGetPartitionDesc hands out direct
    * pointers to the relcache's data structure, unlike our usual
    * practice which is to hand out copies.  We'd have the same
    * problem with rd_partkey, except that we always preserve that
    * once created.)
    *
    * To ensure that it's not leaked completely, re-attach it to the
    * new reldesc, or make it a child of the new reldesc's rd_pdcxt
    * in the unlikely event that there is one already.  (Compare hack
    * in RelationBuildPartitionDesc.)  RelationClose will clean up
    * any such contexts once the reference count reaches zero.
    *
    * In the case where the reference count is zero, this code is not
    * reached, which should be OK because in that case there should
    * be no PartitionDirectory with a pointer to the old entry.
    *
    * Note that newrel and relation have already been swapped, so the
    * "old" partition descriptor is actually the one hanging off of
    * newrel.
 */
   relation->rd_partdesc = NULL; /* ensure rd_partdesc is invalid */
   relation->rd_partdesc_nodetached = NULL;
   relation->rd_partdesc_nodetached_xmin = InvalidTransactionId;
   if (relation->rd_pdcxt != NULL) /* probably never happens */
    MemoryContextSetParent(newrel->rd_pdcxt, relation->rd_pdcxt);
   else
    relation->rd_pdcxt = newrel->rd_pdcxt;
   if (relation->rd_pddcxt != NULL)
    MemoryContextSetParent(newrel->rd_pddcxt, relation->rd_pddcxt);
   else
    relation->rd_pddcxt = newrel->rd_pddcxt;
   /* drop newrel's pointers so we don't destroy it below */
   newrel->rd_partdesc = NULL;
   newrel->rd_partdesc_nodetached = NULL;
   newrel->rd_partdesc_nodetached_xmin = InvalidTransactionId;
   newrel->rd_pdcxt = NULL;
   newrel->rd_pddcxt = NULL;
  }

#undef SWAPFIELD

  /* And now we can throw away the temporary entry */
  RelationDestroyRelation(newrel, !keep_tupdesc);
 }
}

/*
 * RelationFlushRelation
 *
 *  Rebuild the relation if it is open (refcount > 0), else blow it away.
 *  This is used when we receive a cache invalidation event for the rel.
 */
static void
RelationFlushRelation(Relation relation)
{
 if (relation->rd_createSubid != InvalidSubTransactionId ||
  relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
 {
  /*
   * New relcache entries are always rebuilt, not flushed; else we'd
   * forget the "new" status of the relation.  Ditto for the
   * new-relfilenumber status.
 */
  if (IsTransactionState() && relation->rd_droppedSubid == InvalidSubTransactionId)
  {
   /*
    * The rel could have zero refcnt here, so temporarily increment
    * the refcnt to ensure it's safe to rebuild it.  We can assume
    * that the current transaction has some lock on the rel already.
 */
   RelationIncrementReferenceCount(relation);
   RelationRebuildRelation(relation);
   RelationDecrementReferenceCount(relation);
  }
  else
   RelationInvalidateRelation(relation);
 }
 else
 {
  /*
   * Pre-existing rels can be dropped from the relcache if not open.
   *
   * If the entry is in use, rebuild it if possible.  If we're not
   * inside a valid transaction, we can't do any catalog access so it's
   * not possible to rebuild yet.  Just mark it as invalid in that case,
   * so that the rebuild will occur when the entry is next opened.
   *
   * Note: it's possible that we come here during subtransaction abort,
   * and the reason for wanting to rebuild is that the rel is open in
   * the outer transaction.  In that case it might seem unsafe to not
   * rebuild immediately, since whatever code has the rel already open
   * will keep on using the relcache entry as-is.  However, in such a
   * case the outer transaction should be holding a lock that's
   * sufficient to prevent any significant change in the rel's schema,
   * so the existing entry contents should be good enough for its
   * purposes; at worst we might be behind on statistics updates or the
   * like.  (See also CheckTableNotInUse() and its callers.)
 */
  if (RelationHasReferenceCountZero(relation))
   RelationClearRelation(relation);
  else if (!IsTransactionState())
   RelationInvalidateRelation(relation);
  else if (relation->rd_isnailed && relation->rd_refcnt == 1)
  {
   /*
    * A nailed relation with refcnt == 1 is unused.  We cannot clear
    * it, but there's also no need no need to rebuild it immediately.
 */
   RelationInvalidateRelation(relation);
  }
  else
   RelationRebuildRelation(relation);
 }
}

/*
 * RelationForgetRelation - caller reports that it dropped the relation
 */
void
RelationForgetRelation(Oid rid)
{
 Relation relation;

 RelationIdCacheLookup(rid, relation);

 if (!PointerIsValid(relation))
  return;     /* not in cache, nothing to do */

 if (!RelationHasReferenceCountZero(relation))
  elog(ERROR, "relation %u is still open", rid);

 Assert(relation->rd_droppedSubid == InvalidSubTransactionId);
 if (relation->rd_createSubid != InvalidSubTransactionId ||
  relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
 {
  /*
   * In the event of subtransaction rollback, we must not forget
   * rd_*Subid.  Mark the entry "dropped" and invalidate it, instead of
   * destroying it right away.  (If we're in a top transaction, we could
   * opt to destroy the entry.)
 */
  relation->rd_droppedSubid = GetCurrentSubTransactionId();
  RelationInvalidateRelation(relation);
 }
 else
  RelationClearRelation(relation);
}

/*
 *  RelationCacheInvalidateEntry
 *
 *  This routine is invoked for SI cache flush messages.
 *
 * Any relcache entry matching the relid must be flushed.  (Note: caller has
 * already determined that the relid belongs to our database or is a shared
 * relation.)
 *
 * We used to skip local relations, on the grounds that they could
 * not be targets of cross-backend SI update messages; but it seems
 * safer to process them, so that our *own* SI update messages will
 * have the same effects during CommandCounterIncrement for both
 * local and nonlocal relations.
 */
void
RelationCacheInvalidateEntry(Oid relationId)
{
 Relation relation;

 RelationIdCacheLookup(relationId, relation);

 if (PointerIsValid(relation))
 {
  relcacheInvalsReceived++;
  RelationFlushRelation(relation);
 }
 else
 {
  int   i;

  for (i = 0; i < in_progress_list_len; i++)
   if (in_progress_list[i].reloid == relationId)
    in_progress_list[i].invalidated = true;
 }
}

/*
 * RelationCacheInvalidate
 *  Blow away cached relation descriptors that have zero reference counts,
 *  and rebuild those with positive reference counts.  Also reset the smgr
 *  relation cache and re-read relation mapping data.
 *
 *  Apart from debug_discard_caches, this is currently used only to recover
 *  from SI message buffer overflow, so we do not touch relations having
 *  new-in-transaction relfilenumbers; they cannot be targets of cross-backend
 *  SI updates (and our own updates now go through a separate linked list
 *  that isn't limited by the SI message buffer size).
 *
 *  We do this in two phases: the first pass deletes deletable items, and
 *  the second one rebuilds the rebuildable items.  This is essential for
 *  safety, because hash_seq_search only copes with concurrent deletion of
 *  the element it is currently visiting.  If a second SI overflow were to
 *  occur while we are walking the table, resulting in recursive entry to
 *  this routine, we could crash because the inner invocation blows away
 *  the entry next to be visited by the outer scan.  But this way is OK,
 *  because (a) during the first pass we won't process any more SI messages,
 *  so hash_seq_search will complete safely; (b) during the second pass we
 *  only hold onto pointers to nondeletable entries.
 *
 *  The two-phase approach also makes it easy to update relfilenumbers for
 *  mapped relations before we do anything else, and to ensure that the
 *  second pass processes nailed-in-cache items before other nondeletable
 *  items.  This should ensure that system catalogs are up to date before
 *  we attempt to use them to reload information about other open relations.
 *
 *  After those two phases of work having immediate effects, we normally
 *  signal any RelationBuildDesc() on the stack to start over.  However, we
 *  don't do this if called as part of debug_discard_caches.  Otherwise,
 *  RelationBuildDesc() would become an infinite loop.
 */
void
RelationCacheInvalidate(bool debug_discard)
{
 HASH_SEQ_STATUS status;
 RelIdCacheEnt *idhentry;
 Relation relation;
 List    *rebuildFirstList = NIL;
 List    *rebuildList = NIL;
 ListCell   *l;
 int   i;

 /*
  * Reload relation mapping data before starting to reconstruct cache.
 */
 RelationMapInvalidateAll();

 /* Phase 1 */
 hash_seq_init(&status, RelationIdCache);

 while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
 {
  relation = idhentry->reldesc;

  /*
   * Ignore new relations; no other backend will manipulate them before
   * we commit.  Likewise, before replacing a relation's relfilelocator,
   * we shall have acquired AccessExclusiveLock and drained any
   * applicable pending invalidations.
 */
  if (relation->rd_createSubid != InvalidSubTransactionId ||
   relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
   continue;

  relcacheInvalsReceived++;

  if (RelationHasReferenceCountZero(relation))
  {
   /* Delete this entry immediately */
   RelationClearRelation(relation);
  }
  else
  {
   /*
    * If it's a mapped relation, immediately update its rd_locator in
    * case its relfilenumber changed.  We must do this during phase 1
    * in case the relation is consulted during rebuild of other
    * relcache entries in phase 2.  It's safe since consulting the
    * map doesn't involve any access to relcache entries.
 */
   if (RelationIsMapped(relation))
   {
    RelationCloseSmgr(relation);
    RelationInitPhysicalAddr(relation);
   }

   /*
    * Add this entry to list of stuff to rebuild in second pass.
    * pg_class goes to the front of rebuildFirstList while
    * pg_class_oid_index goes to the back of rebuildFirstList, so
    * they are done first and second respectively.  Other nailed
    * relations go to the front of rebuildList, so they'll be done
    * next in no particular order; and everything else goes to the
    * back of rebuildList.
 */
   if (RelationGetRelid(relation) == RelationRelationId)
    rebuildFirstList = lcons(relation, rebuildFirstList);
   else if (RelationGetRelid(relation) == ClassOidIndexId)
    rebuildFirstList = lappend(rebuildFirstList, relation);
   else if (relation->rd_isnailed)
    rebuildList = lcons(relation, rebuildList);
   else
    rebuildList = lappend(rebuildList, relation);
  }
 }

 /*
  * We cannot destroy the SMgrRelations as there might still be references
  * to them, but close the underlying file descriptors.
 */
 smgrreleaseall();

 /*
  * Phase 2: rebuild (or invalidate) the items found to need rebuild in
  * phase 1
 */
 foreach(l, rebuildFirstList)
 {
  relation = (Relation) lfirst(l);
  if (!IsTransactionState() || (relation->rd_isnailed && relation->rd_refcnt == 1))
   RelationInvalidateRelation(relation);
  else
   RelationRebuildRelation(relation);
 }
 list_free(rebuildFirstList);
 foreach(l, rebuildList)
 {
  relation = (Relation) lfirst(l);
  if (!IsTransactionState() || (relation->rd_isnailed && relation->rd_refcnt == 1))
   RelationInvalidateRelation(relation);
  else
   RelationRebuildRelation(relation);
 }
 list_free(rebuildList);

 if (!debug_discard)
  /* Any RelationBuildDesc() on the stack must start over. */
  for (i = 0; i < in_progress_list_len; i++)
   in_progress_list[i].invalidated = true;
}

static void
RememberToFreeTupleDescAtEOX(TupleDesc td)
{
 if (EOXactTupleDescArray == NULL)
 {
  MemoryContext oldcxt;

  oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

  EOXactTupleDescArray = (TupleDesc *) palloc(16 * sizeof(TupleDesc));
  EOXactTupleDescArrayLen = 16;
  NextEOXactTupleDescNum = 0;
  MemoryContextSwitchTo(oldcxt);
 }
 else if (NextEOXactTupleDescNum >= EOXactTupleDescArrayLen)
 {
  int32  newlen = EOXactTupleDescArrayLen * 2;

  Assert(EOXactTupleDescArrayLen > 0);

  EOXactTupleDescArray = (TupleDesc *) repalloc(EOXactTupleDescArray,
               newlen * sizeof(TupleDesc));
  EOXactTupleDescArrayLen = newlen;
 }

 EOXactTupleDescArray[NextEOXactTupleDescNum++] = td;
}

#ifdef USE_ASSERT_CHECKING
static void
AssertPendingSyncConsistency(Relation relation)
{
 bool  relcache_verdict =
  RelationIsPermanent(relation) &&
  ((relation->rd_createSubid != InvalidSubTransactionId &&
    RELKIND_HAS_STORAGE(relation->rd_rel->relkind)) ||
   relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId);

 Assert(relcache_verdict == RelFileLocatorSkippingWAL(relation->rd_locator));

 if (relation->rd_droppedSubid != InvalidSubTransactionId)
  Assert(!relation->rd_isvalid &&
      (relation->rd_createSubid != InvalidSubTransactionId ||
    relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId));
}

/*
 * AssertPendingSyncs_RelationCache
 *
 * Assert that relcache.c and storage.c agree on whether to skip WAL.
 */
void
AssertPendingSyncs_RelationCache(void)
{
 HASH_SEQ_STATUS status;
 LOCALLOCK  *locallock;
 Relation   *rels;
 int   maxrels;
 int   nrels;
 RelIdCacheEnt *idhentry;
 int   i;

 /*
  * Open every relation that this transaction has locked.  If, for some
  * relation, storage.c is skipping WAL and relcache.c is not skipping WAL,
  * a CommandCounterIncrement() typically yields a local invalidation
  * message that destroys the relcache entry.  By recreating such entries
  * here, we detect the problem.
 */
 PushActiveSnapshot(GetTransactionSnapshot());
 maxrels = 1;
 rels = palloc(maxrels * sizeof(*rels));
 nrels = 0;
 hash_seq_init(&status, GetLockMethodLocalHash());
 while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
 {
  Oid   relid;
  Relation r;

  if (locallock->nLocks <= 0)
   continue;
  if ((LockTagType) locallock->tag.lock.locktag_type !=
   LOCKTAG_RELATION)
   continue;
  relid = ObjectIdGetDatum(locallock->tag.lock.locktag_field2);
  r = RelationIdGetRelation(relid);
  if (!RelationIsValid(r))
   continue;
  if (nrels >= maxrels)
  {
   maxrels *= 2;
   rels = repalloc(rels, maxrels * sizeof(*rels));
  }
  rels[nrels++] = r;
 }

 hash_seq_init(&status, RelationIdCache);
 while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
  AssertPendingSyncConsistency(idhentry->reldesc);

 for (i = 0; i < nrels; i++)
  RelationClose(rels[i]);
 PopActiveSnapshot();
}
#endif

/*
 * AtEOXact_RelationCache
 *
 * Clean up the relcache at main-transaction commit or abort.
 *
 * Note: this must be called *before* processing invalidation messages.
 * In the case of abort, we don't want to try to rebuild any invalidated
 * cache entries (since we can't safely do database accesses).  Therefore
 * we must reset refcnts before handling pending invalidations.
 *
 * As of PostgreSQL 8.1, relcache refcnts should get released by the
 * ResourceOwner mechanism.  This routine just does a debugging
 * cross-check that no pins remain.  However, we also need to do special
 * cleanup when the current transaction created any relations or made use
 * of forced index lists.
 */
void
AtEOXact_RelationCache(bool isCommit)
{
 HASH_SEQ_STATUS status;
 RelIdCacheEnt *idhentry;
 int   i;

 /*
  * Forget in_progress_list.  This is relevant when we're aborting due to
  * an error during RelationBuildDesc().
 */
 Assert(in_progress_list_len == 0 || !isCommit);
 in_progress_list_len = 0;

 /*
  * Unless the eoxact_list[] overflowed, we only need to examine the rels
  * listed in it.  Otherwise fall back on a hash_seq_search scan.
  *
  * For simplicity, eoxact_list[] entries are not deleted till end of
  * top-level transaction, even though we could remove them at
  * subtransaction end in some cases, or remove relations from the list if
  * they are cleared for other reasons.  Therefore we should expect the
  * case that list entries are not found in the hashtable; if not, there's
  * nothing to do for them.
 */
 if (eoxact_list_overflowed)
 {
  hash_seq_init(&status, RelationIdCache);
  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
  {
   AtEOXact_cleanup(idhentry->reldesc, isCommit);
  }
 }
 else
 {
  for (i = 0; i < eoxact_list_len; i++)
  {
   idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
              &eoxact_list[i],
              HASH_FIND,
              NULL);
   if (idhentry != NULL)
    AtEOXact_cleanup(idhentry->reldesc, isCommit);
  }
 }

 if (EOXactTupleDescArrayLen > 0)
 {
  Assert(EOXactTupleDescArray != NULL);
  for (i = 0; i < NextEOXactTupleDescNum; i++)
   FreeTupleDesc(EOXactTupleDescArray[i]);
  pfree(EOXactTupleDescArray);
  EOXactTupleDescArray = NULL;
 }

 /* Now we're out of the transaction and can clear the lists */
 eoxact_list_len = 0;
 eoxact_list_overflowed = false;
 NextEOXactTupleDescNum = 0;
 EOXactTupleDescArrayLen = 0;
}

/*
 * AtEOXact_cleanup
 *
 * Clean up a single rel at main-transaction commit or abort
 *
 * NB: this processing must be idempotent, because EOXactListAdd() doesn't
 * bother to prevent duplicate entries in eoxact_list[].
 */
static void
AtEOXact_cleanup(Relation relation, bool isCommit)
{
 bool  clear_relcache = false;

 /*
  * The relcache entry's ref count should be back to its normal
  * not-in-a-transaction state: 0 unless it's nailed in cache.
  *
  * In bootstrap mode, this is NOT true, so don't check it --- the
  * bootstrap code expects relations to stay open across start/commit
  * transaction calls.  (That seems bogus, but it's not worth fixing.)
  *
  * Note: ideally this check would be applied to every relcache entry, not
  * just those that have eoxact work to do.  But it's not worth forcing a
  * scan of the whole relcache just for this.  (Moreover, doing so would
  * mean that assert-enabled testing never tests the hash_search code path
  * above, which seems a bad idea.)
 */
#ifdef USE_ASSERT_CHECKING
 if (!IsBootstrapProcessingMode())
 {
  int   expected_refcnt;

  expected_refcnt = relation->rd_isnailed ? 1 : 0;
  Assert(relation->rd_refcnt == expected_refcnt);
 }
#endif

 /*
  * Is the relation live after this transaction ends?
  *
  * During commit, clear the relcache entry if it is preserved after
  * relation drop, in order not to orphan the entry.  During rollback,
  * clear the relcache entry if the relation is created in the current
  * transaction since it isn't interesting any longer once we are out of
  * the transaction.
 */
 clear_relcache =
  (isCommit ?
   relation->rd_droppedSubid != InvalidSubTransactionId :
   relation->rd_createSubid != InvalidSubTransactionId);

 /*
  * Since we are now out of the transaction, reset the subids to zero. That
  * also lets RelationClearRelation() drop the relcache entry.
 */
 relation->rd_createSubid = InvalidSubTransactionId;
 relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
 relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
 relation->rd_droppedSubid = InvalidSubTransactionId;

 if (clear_relcache)
 {
  if (RelationHasReferenceCountZero(relation))
  {
   RelationClearRelation(relation);
   return;
  }
  else
  {
   /*
    * Hmm, somewhere there's a (leaked?) reference to the relation.
    * We daren't remove the entry for fear of dereferencing a
    * dangling pointer later.  Bleat, and mark it as not belonging to
    * the current transaction.  Hopefully it'll get cleaned up
    * eventually.  This must be just a WARNING to avoid
    * error-during-error-recovery loops.
 */
   elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
     RelationGetRelationName(relation));
  }
 }
}

/*
 * AtEOSubXact_RelationCache
 *
 * Clean up the relcache at sub-transaction commit or abort.
 *
 * Note: this must be called *before* processing invalidation messages.
 */
void
AtEOSubXact_RelationCache(bool isCommit, SubTransactionId mySubid,
        SubTransactionId parentSubid)
{
 HASH_SEQ_STATUS status;
 RelIdCacheEnt *idhentry;
 int   i;

 /*
  * Forget in_progress_list.  This is relevant when we're aborting due to
  * an error during RelationBuildDesc().  We don't commit subtransactions
  * during RelationBuildDesc().
 */
 Assert(in_progress_list_len == 0 || !isCommit);
 in_progress_list_len = 0;

 /*
  * Unless the eoxact_list[] overflowed, we only need to examine the rels
  * listed in it.  Otherwise fall back on a hash_seq_search scan.  Same
  * logic as in AtEOXact_RelationCache.
 */
 if (eoxact_list_overflowed)
 {
  hash_seq_init(&status, RelationIdCache);
  while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
  {
   AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
        mySubid, parentSubid);
  }
 }
 else
 {
  for (i = 0; i < eoxact_list_len; i++)
  {
   idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
              &eoxact_list[i],
              HASH_FIND,
              NULL);
   if (idhentry != NULL)
    AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
         mySubid, parentSubid);
  }
 }

 /* Don't reset the list; we still need more cleanup later */
}

/*
 * AtEOSubXact_cleanup
 *
 * Clean up a single rel at subtransaction commit or abort
 *
 * NB: this processing must be idempotent, because EOXactListAdd() doesn't
 * bother to prevent duplicate entries in eoxact_list[].
 */
static void
AtEOSubXact_cleanup(Relation relation, bool isCommit,
     SubTransactionId mySubid, SubTransactionId parentSubid)
{
 /*
  * Is it a relation created in the current subtransaction?
  *
  * During subcommit, mark it as belonging to the parent, instead, as long
  * as it has not been dropped. Otherwise simply delete the relcache entry.
  * --- it isn't interesting any longer.
 */
 if (relation->rd_createSubid == mySubid)
 {
  /*
   * Valid rd_droppedSubid means the corresponding relation is dropped
   * but the relcache entry is preserved for at-commit pending sync. We
   * need to drop it explicitly here not to make the entry orphan.
 */
  Assert(relation->rd_droppedSubid == mySubid ||
      relation->rd_droppedSubid == InvalidSubTransactionId);
  if (isCommit && relation->rd_droppedSubid == InvalidSubTransactionId)
   relation->rd_createSubid = parentSubid;
  else if (RelationHasReferenceCountZero(relation))
  {
   /* allow the entry to be removed */
   relation->rd_createSubid = InvalidSubTransactionId;
   relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
   relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
   relation->rd_droppedSubid = InvalidSubTransactionId;
   RelationClearRelation(relation);
   return;
  }
  else
  {
   /*
    * Hmm, somewhere there's a (leaked?) reference to the relation.
    * We daren't remove the entry for fear of dereferencing a
    * dangling pointer later.  Bleat, and transfer it to the parent
    * subtransaction so we can try again later.  This must be just a
    * WARNING to avoid error-during-error-recovery loops.
 */
   relation->rd_createSubid = parentSubid;
   elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
     RelationGetRelationName(relation));
  }
 }

 /*
  * Likewise, update or drop any new-relfilenumber-in-subtransaction record
  * or drop record.
 */
 if (relation->rd_newRelfilelocatorSubid == mySubid)
 {
  if (isCommit)
   relation->rd_newRelfilelocatorSubid = parentSubid;
  else
   relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
 }

 if (relation->rd_firstRelfilelocatorSubid == mySubid)
 {
  if (isCommit)
   relation->rd_firstRelfilelocatorSubid = parentSubid;
  else
   relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
 }

 if (relation->rd_droppedSubid == mySubid)
 {
  if (isCommit)
   relation->rd_droppedSubid = parentSubid;
  else
   relation->rd_droppedSubid = InvalidSubTransactionId;
 }
}


/*
 *  RelationBuildLocalRelation
 *   Build a relcache entry for an about-to-be-created relation,
 *   and enter it into the relcache.
 */
Relation
RelationBuildLocalRelation(const char *relname,
         Oid relnamespace,
         TupleDesc tupDesc,
         Oid relid,
         Oid accessmtd,
         RelFileNumber relfilenumber,
         Oid reltablespace,
         bool shared_relation,
         bool mapped_relation,
         char relpersistence,
         char relkind)
{
 Relation rel;
 MemoryContext oldcxt;
 int   natts = tupDesc->natts;
 int   i;
 bool  has_not_null;
 bool  nailit;

 Assert(natts >= 0);

 /*
  * check for creation of a rel that must be nailed in cache.
  *
  * XXX this list had better match the relations specially handled in
  * RelationCacheInitializePhase2/3.
 */
 switch (relid)
 {
  case DatabaseRelationId:
  case AuthIdRelationId:
  case AuthMemRelationId:
  case RelationRelationId:
  case AttributeRelationId:
  case ProcedureRelationId:
  case TypeRelationId:
   nailit = true;
   break;
  default:
   nailit = false;
   break;
 }

 /*
  * check that hardwired list of shared rels matches what's in the
  * bootstrap .bki file.  If you get a failure here during initdb, you
  * probably need to fix IsSharedRelation() to match whatever you've done
  * to the set of shared relations.
 */
 if (shared_relation != IsSharedRelation(relid))
  elog(ERROR, "shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
    relname, relid);

 /* Shared relations had better be mapped, too */
 Assert(mapped_relation || !shared_relation);

 /*
  * switch to the cache context to create the relcache entry.
 */
 if (!CacheMemoryContext)
  CreateCacheMemoryContext();

 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

 /*
  * allocate a new relation descriptor and fill in basic state fields.
 */
 rel = (Relation) palloc0(sizeof(RelationData));

 /* make sure relation is marked as having no open file yet */
 rel->rd_smgr = NULL;

 /* mark it nailed if appropriate */
 rel->rd_isnailed = nailit;

 rel->rd_refcnt = nailit ? 1 : 0;

 /* it's being created in this transaction */
 rel->rd_createSubid = GetCurrentSubTransactionId();
 rel->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
 rel->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
 rel->rd_droppedSubid = InvalidSubTransactionId;

 /*
  * create a new tuple descriptor from the one passed in.  We do this
  * partly to copy it into the cache context, and partly because the new
  * relation can't have any defaults or constraints yet; they have to be
  * added in later steps, because they require additions to multiple system
  * catalogs.  We can copy attnotnull constraints here, however.
 */
 rel->rd_att = CreateTupleDescCopy(tupDesc);
 rel->rd_att->tdrefcount = 1; /* mark as refcounted */
 has_not_null = false;
 for (i = 0; i < natts; i++)
 {
  Form_pg_attribute satt = TupleDescAttr(tupDesc, i);
  Form_pg_attribute datt = TupleDescAttr(rel->rd_att, i);

  datt->attidentity = satt->attidentity;
  datt->attgenerated = satt->attgenerated;
  datt->attnotnull = satt->attnotnull;
  has_not_null |= satt->attnotnull;
  populate_compact_attribute(rel->rd_att, i);

  if (satt->attnotnull)
  {
   CompactAttribute *scatt = TupleDescCompactAttr(tupDesc, i);
   CompactAttribute *dcatt = TupleDescCompactAttr(rel->rd_att, i);

   dcatt->attnullability = scatt->attnullability;
  }
 }

 if (has_not_null)
 {
  TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));

  constr->has_not_null = true;
  rel->rd_att->constr = constr;
 }

 /*
  * initialize relation tuple form (caller may add/override data later)
 */
 rel->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);

 namestrcpy(&rel->rd_rel->relname, relname);
 rel->rd_rel->relnamespace = relnamespace;

 rel->rd_rel->relkind = relkind;
 rel->rd_rel->relnatts = natts;
 rel->rd_rel->reltype = InvalidOid;
 /* needed when bootstrapping: */
 rel->rd_rel->relowner = BOOTSTRAP_SUPERUSERID;

 /* set up persistence and relcache fields dependent on it */
 rel->rd_rel->relpersistence = relpersistence;
 switch (relpersistence)
 {
  case RELPERSISTENCE_UNLOGGED:
  case RELPERSISTENCE_PERMANENT:
   rel->rd_backend = INVALID_PROC_NUMBER;
   rel->rd_islocaltemp = false;
   break;
  case RELPERSISTENCE_TEMP:
   Assert(isTempOrTempToastNamespace(relnamespace));
   rel->rd_backend = ProcNumberForTempRelations();
   rel->rd_islocaltemp = true;
   break;
  default:
   elog(ERROR, "invalid relpersistence: %c", relpersistence);
   break;
 }

 /* if it's a materialized view, it's not populated initially */
 if (relkind == RELKIND_MATVIEW)
  rel->rd_rel->relispopulated = false;
 else
  rel->rd_rel->relispopulated = true;

 /* set replica identity -- system catalogs and non-tables don't have one */
 if (!IsCatalogNamespace(relnamespace) &&
  (relkind == RELKIND_RELATION ||
   relkind == RELKIND_MATVIEW ||
   relkind == RELKIND_PARTITIONED_TABLE))
  rel->rd_rel->relreplident = REPLICA_IDENTITY_DEFAULT;
 else
  rel->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;

 /*
  * Insert relation physical and logical identifiers (OIDs) into the right
  * places.  For a mapped relation, we set relfilenumber to zero and rely
  * on RelationInitPhysicalAddr to consult the map.
 */
 rel->rd_rel->relisshared = shared_relation;

 RelationGetRelid(rel) = relid;

 for (i = 0; i < natts; i++)
  TupleDescAttr(rel->rd_att, i)->attrelid = relid;

 rel->rd_rel->reltablespace = reltablespace;

 if (mapped_relation)
 {
  rel->rd_rel->relfilenode = InvalidRelFileNumber;
  /* Add it to the active mapping information */
  RelationMapUpdateMap(relid, relfilenumber, shared_relation, true);
 }
 else
  rel->rd_rel->relfilenode = relfilenumber;

 RelationInitLockInfo(rel); /* see lmgr.c */

 RelationInitPhysicalAddr(rel);

 rel->rd_rel->relam = accessmtd;

 /*
  * RelationInitTableAccessMethod will do syscache lookups, so we mustn't
  * run it in CacheMemoryContext.  Fortunately, the remaining steps don't
  * require a long-lived current context.
 */
 MemoryContextSwitchTo(oldcxt);

 if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_SEQUENCE)
  RelationInitTableAccessMethod(rel);

 /*
  * Leave index access method uninitialized, because the pg_index row has
  * not been inserted at this stage of index creation yet.  The cache
  * invalidation after pg_index row has been inserted will initialize it.
 */

 /*
  * Okay to insert into the relcache hash table.
  *
  * Ordinarily, there should certainly not be an existing hash entry for
  * the same OID; but during bootstrap, when we create a "real" relcache
  * entry for one of the bootstrap relations, we'll be overwriting the
  * phony one created with formrdesc.  So allow that to happen for nailed
  * rels.
 */
 RelationCacheInsert(rel, nailit);

 /*
  * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
  * can't do this before storing relid in it.
 */
 EOXactListAdd(rel);

 /* It's fully valid */
 rel->rd_isvalid = true;

 /*
  * Caller expects us to pin the returned entry.
 */
 RelationIncrementReferenceCount(rel);

 return rel;
}


/*
 * RelationSetNewRelfilenumber
 *
 * Assign a new relfilenumber (physical file name), and possibly a new
 * persistence setting, to the relation.
 *
 * This allows a full rewrite of the relation to be done with transactional
 * safety (since the filenumber assignment can be rolled back).  Note however
 * that there is no simple way to access the relation's old data for the
 * remainder of the current transaction.  This limits the usefulness to cases
 * such as TRUNCATE or rebuilding an index from scratch.
 *
 * Caller must already hold exclusive lock on the relation.
 */
void
RelationSetNewRelfilenumber(Relation relation, char persistence)
{
 RelFileNumber newrelfilenumber;
 Relation pg_class;
 ItemPointerData otid;
 HeapTuple tuple;
 Form_pg_class classform;
 MultiXactId minmulti = InvalidMultiXactId;
 TransactionId freezeXid = InvalidTransactionId;
 RelFileLocator newrlocator;

 if (!IsBinaryUpgrade)
 {
  /* Allocate a new relfilenumber */
  newrelfilenumber = GetNewRelFileNumber(relation->rd_rel->reltablespace,
              NULL, persistence);
 }
 else if (relation->rd_rel->relkind == RELKIND_INDEX)
 {
  if (!OidIsValid(binary_upgrade_next_index_pg_class_relfilenumber))
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      errmsg("index relfilenumber value not set when in binary upgrade mode")));

  newrelfilenumber = binary_upgrade_next_index_pg_class_relfilenumber;
  binary_upgrade_next_index_pg_class_relfilenumber = InvalidOid;
 }
 else if (relation->rd_rel->relkind == RELKIND_RELATION)
 {
  if (!OidIsValid(binary_upgrade_next_heap_pg_class_relfilenumber))
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      errmsg("heap relfilenumber value not set when in binary upgrade mode")));

  newrelfilenumber = binary_upgrade_next_heap_pg_class_relfilenumber;
  binary_upgrade_next_heap_pg_class_relfilenumber = InvalidOid;
 }
 else
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("unexpected request for new relfilenumber in binary upgrade mode")));

 /*
  * Get a writable copy of the pg_class tuple for the given relation.
 */
 pg_class = table_open(RelationRelationId, RowExclusiveLock);

 tuple = SearchSysCacheLockedCopy1(RELOID,
           ObjectIdGetDatum(RelationGetRelid(relation)));
 if (!HeapTupleIsValid(tuple))
  elog(ERROR, "could not find tuple for relation %u",
    RelationGetRelid(relation));
 otid = tuple->t_self;
 classform = (Form_pg_class) GETSTRUCT(tuple);

 /*
  * Schedule unlinking of the old storage at transaction commit, except
  * when performing a binary upgrade, when we must do it immediately.
 */
 if (IsBinaryUpgrade)
 {
  SMgrRelation srel;

  /*
   * During a binary upgrade, we use this code path to ensure that
   * pg_largeobject and its index have the same relfilenumbers as in the
   * old cluster. This is necessary because pg_upgrade treats
   * pg_largeobject like a user table, not a system table. It is however
   * possible that a table or index may need to end up with the same
   * relfilenumber in the new cluster as what it had in the old cluster.
   * Hence, we can't wait until commit time to remove the old storage.
   *
   * In general, this function needs to have transactional semantics,
   * and removing the old storage before commit time surely isn't.
   * However, it doesn't really matter, because if a binary upgrade
   * fails at this stage, the new cluster will need to be recreated
   * anyway.
 */
  srel = smgropen(relation->rd_locator, relation->rd_backend);
  smgrdounlinkall(&srel, 1, false);
  smgrclose(srel);
 }
 else
 {
  /* Not a binary upgrade, so just schedule it to happen later. */
  RelationDropStorage(relation);
 }

 /*
  * Create storage for the main fork of the new relfilenumber.  If it's a
  * table-like object, call into the table AM to do so, which'll also
  * create the table's init fork if needed.
  *
  * NOTE: If relevant for the AM, any conflict in relfilenumber value will
  * be caught here, if GetNewRelFileNumber messes up for any reason.
 */
 newrlocator = relation->rd_locator;
 newrlocator.relNumber = newrelfilenumber;

 if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind))
 {
  table_relation_set_new_filelocator(relation, &newrlocator,
             persistence,
             &freezeXid, &minmulti);
 }
 else if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
 {
  /* handle these directly, at least for now */
  SMgrRelation srel;

  srel = RelationCreateStorage(newrlocator, persistence, true);
  smgrclose(srel);
 }
 else
 {
  /* we shouldn't be called for anything else */
  elog(ERROR, "relation \"%s\" does not have storage",
    RelationGetRelationName(relation));
 }

 /*
  * If we're dealing with a mapped index, pg_class.relfilenode doesn't
  * change; instead we have to send the update to the relation mapper.
  *
  * For mapped indexes, we don't actually change the pg_class entry at all;
  * this is essential when reindexing pg_class itself.  That leaves us with
  * possibly-inaccurate values of relpages etc, but those will be fixed up
  * later.
 */
 if (RelationIsMapped(relation))
 {
  /* This case is only supported for indexes */
  Assert(relation->rd_rel->relkind == RELKIND_INDEX);

  /* Since we're not updating pg_class, these had better not change */
  Assert(classform->relfrozenxid == freezeXid);
  Assert(classform->relminmxid == minmulti);
  Assert(classform->relpersistence == persistence);

  /*
   * In some code paths it's possible that the tuple update we'd
   * otherwise do here is the only thing that would assign an XID for
   * the current transaction.  However, we must have an XID to delete
   * files, so make sure one is assigned.
 */
  (void) GetCurrentTransactionId();

  /* Do the deed */
  RelationMapUpdateMap(RelationGetRelid(relation),
        newrelfilenumber,
        relation->rd_rel->relisshared,
        false);

  /* Since we're not updating pg_class, must trigger inval manually */
  CacheInvalidateRelcache(relation);
 }
 else
 {
  /* Normal case, update the pg_class entry */
  classform->relfilenode = newrelfilenumber;

  /* relpages etc. never change for sequences */
  if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
  {
   classform->relpages = 0; /* it's empty until further notice */
   classform->reltuples = -1;
   classform->relallvisible = 0;
   classform->relallfrozen = 0;
  }
  classform->relfrozenxid = freezeXid;
  classform->relminmxid = minmulti;
  classform->relpersistence = persistence;

  CatalogTupleUpdate(pg_class, &otid, tuple);
 }

 UnlockTuple(pg_class, &otid, InplaceUpdateTupleLock);
 heap_freetuple(tuple);

 table_close(pg_class, RowExclusiveLock);

 /*
  * Make the pg_class row change or relation map change visible.  This will
  * cause the relcache entry to get updated, too.
 */
 CommandCounterIncrement();

 RelationAssumeNewRelfilelocator(relation);
}

/*
 * RelationAssumeNewRelfilelocator
 *
 * Code that modifies pg_class.reltablespace or pg_class.relfilenode must call
 * this.  The call shall precede any code that might insert WAL records whose
 * replay would modify bytes in the new RelFileLocator, and the call shall follow
 * any WAL modifying bytes in the prior RelFileLocator.  See struct RelationData.
 * Ideally, call this as near as possible to the CommandCounterIncrement()
 * that makes the pg_class change visible (before it or after it); that
 * minimizes the chance of future development adding a forbidden WAL insertion
 * between RelationAssumeNewRelfilelocator() and CommandCounterIncrement().
 */
void
RelationAssumeNewRelfilelocator(Relation relation)
{
 relation->rd_newRelfilelocatorSubid = GetCurrentSubTransactionId();
 if (relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)
  relation->rd_firstRelfilelocatorSubid = relation->rd_newRelfilelocatorSubid;

 /* Flag relation as needing eoxact cleanup (to clear these fields) */
 EOXactListAdd(relation);
}


/*
 *  RelationCacheInitialize
 *
 *  This initializes the relation descriptor cache.  At the time
 *  that this is invoked, we can't do database access yet (mainly
 *  because the transaction subsystem is not up); all we are doing
 *  is making an empty cache hashtable.  This must be done before
 *  starting the initialization transaction, because otherwise
 *  AtEOXact_RelationCache would crash if that transaction aborts
 *  before we can get the relcache set up.
 */

#define INITRELCACHESIZE  400

void
RelationCacheInitialize(void)
{
 HASHCTL  ctl;
 int   allocsize;

 /*
  * make sure cache memory context exists
 */
 if (!CacheMemoryContext)
  CreateCacheMemoryContext();

 /*
  * create hashtable that indexes the relcache
 */
 ctl.keysize = sizeof(Oid);
 ctl.entrysize = sizeof(RelIdCacheEnt);
 RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
          &ctl, HASH_ELEM | HASH_BLOBS);

 /*
  * reserve enough in_progress_list slots for many cases
 */
 allocsize = 4;
 in_progress_list =
  MemoryContextAlloc(CacheMemoryContext,
         allocsize * sizeof(*in_progress_list));
 in_progress_list_maxlen = allocsize;

 /*
  * relation mapper needs to be initialized too
 */
 RelationMapInitialize();
}

/*
 *  RelationCacheInitializePhase2
 *
 *  This is called to prepare for access to shared catalogs during startup.
 *  We must at least set up nailed reldescs for pg_database, pg_authid,
 *  pg_auth_members, and pg_shseclabel. Ideally we'd like to have reldescs
 *  for their indexes, too.  We attempt to load this information from the
 *  shared relcache init file.  If that's missing or broken, just make
 *  phony entries for the catalogs themselves.
 *  RelationCacheInitializePhase3 will clean up as needed.
 */
void
RelationCacheInitializePhase2(void)
{
 MemoryContext oldcxt;

 /*
  * relation mapper needs initialized too
 */
 RelationMapInitializePhase2();

 /*
  * In bootstrap mode, the shared catalogs aren't there yet anyway, so do
  * nothing.
 */
 if (IsBootstrapProcessingMode())
  return;

 /*
  * switch to cache memory context
 */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

 /*
  * Try to load the shared relcache cache file.  If unsuccessful, bootstrap
  * the cache with pre-made descriptors for the critical shared catalogs.
 */
 if (!load_relcache_init_file(true))
 {
  formrdesc("pg_database", DatabaseRelation_Rowtype_Id, true,
      Natts_pg_database, Desc_pg_database);
  formrdesc("pg_authid", AuthIdRelation_Rowtype_Id, true,
      Natts_pg_authid, Desc_pg_authid);
  formrdesc("pg_auth_members", AuthMemRelation_Rowtype_Id, true,
      Natts_pg_auth_members, Desc_pg_auth_members);
  formrdesc("pg_shseclabel", SharedSecLabelRelation_Rowtype_Id, true,
      Natts_pg_shseclabel, Desc_pg_shseclabel);
  formrdesc("pg_subscription", SubscriptionRelation_Rowtype_Id, true,
      Natts_pg_subscription, Desc_pg_subscription);

#define NUM_CRITICAL_SHARED_RELS 5 /* fix if you change list above */
 }

 MemoryContextSwitchTo(oldcxt);
}

/*
 *  RelationCacheInitializePhase3
 *
 *  This is called as soon as the catcache and transaction system
 *  are functional and we have determined MyDatabaseId.  At this point
 *  we can actually read data from the database's system catalogs.
 *  We first try to read pre-computed relcache entries from the local
 *  relcache init file.  If that's missing or broken, make phony entries
 *  for the minimum set of nailed-in-cache relations.  Then (unless
 *  bootstrapping) make sure we have entries for the critical system
 *  indexes.  Once we've done all this, we have enough infrastructure to
 *  open any system catalog or use any catcache.  The last step is to
 *  rewrite the cache files if needed.
 */
void
RelationCacheInitializePhase3(void)
{
 HASH_SEQ_STATUS status;
 RelIdCacheEnt *idhentry;
 MemoryContext oldcxt;
 bool  needNewCacheFile = !criticalSharedRelcachesBuilt;

 /*
  * relation mapper needs initialized too
 */
 RelationMapInitializePhase3();

 /*
  * switch to cache memory context
 */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

 /*
  * Try to load the local relcache cache file.  If unsuccessful, bootstrap
  * the cache with pre-made descriptors for the critical "nailed-in" system
  * catalogs.
 */
 if (IsBootstrapProcessingMode() ||
  !load_relcache_init_file(false))
 {
  needNewCacheFile = true;

  formrdesc("pg_class", RelationRelation_Rowtype_Id, false,
      Natts_pg_class, Desc_pg_class);
  formrdesc("pg_attribute", AttributeRelation_Rowtype_Id, false,
      Natts_pg_attribute, Desc_pg_attribute);
  formrdesc("pg_proc", ProcedureRelation_Rowtype_Id, false,
      Natts_pg_proc, Desc_pg_proc);
  formrdesc("pg_type", TypeRelation_Rowtype_Id, false,
      Natts_pg_type, Desc_pg_type);

#define NUM_CRITICAL_LOCAL_RELS 4 /* fix if you change list above */
 }

 MemoryContextSwitchTo(oldcxt);

 /* In bootstrap mode, the faked-up formrdesc info is all we'll have */
 if (IsBootstrapProcessingMode())
  return;

 /*
  * If we didn't get the critical system indexes loaded into relcache, do
  * so now.  These are critical because the catcache and/or opclass cache
  * depend on them for fetches done during relcache load.  Thus, we have an
  * infinite-recursion problem.  We can break the recursion by doing
  * heapscans instead of indexscans at certain key spots. To avoid hobbling
  * performance, we only want to do that until we have the critical indexes
  * loaded into relcache.  Thus, the flag criticalRelcachesBuilt is used to
  * decide whether to do heapscan or indexscan at the key spots, and we set
  * it true after we've loaded the critical indexes.
  *
  * The critical indexes are marked as "nailed in cache", partly to make it
  * easy for load_relcache_init_file to count them, but mainly because we
  * cannot flush and rebuild them once we've set criticalRelcachesBuilt to
  * true.  (NOTE: perhaps it would be possible to reload them by
  * temporarily setting criticalRelcachesBuilt to false again.  For now,
  * though, we just nail 'em in.)
  *
  * RewriteRelRulenameIndexId and TriggerRelidNameIndexId are not critical
  * in the same way as the others, because the critical catalogs don't
  * (currently) have any rules or triggers, and so these indexes can be
  * rebuilt without inducing recursion.  However they are used during
  * relcache load when a rel does have rules or triggers, so we choose to
  * nail them for performance reasons.
 */
 if (!criticalRelcachesBuilt)
 {
  load_critical_index(ClassOidIndexId,
       RelationRelationId);
  load_critical_index(AttributeRelidNumIndexId,
       AttributeRelationId);
  load_critical_index(IndexRelidIndexId,
       IndexRelationId);
  load_critical_index(OpclassOidIndexId,
       OperatorClassRelationId);
  load_critical_index(AccessMethodProcedureIndexId,
       AccessMethodProcedureRelationId);
  load_critical_index(RewriteRelRulenameIndexId,
       RewriteRelationId);
  load_critical_index(TriggerRelidNameIndexId,
       TriggerRelationId);

#define NUM_CRITICAL_LOCAL_INDEXES 7 /* fix if you change list above */

  criticalRelcachesBuilt = true;
 }

 /*
  * Process critical shared indexes too.
  *
  * DatabaseNameIndexId isn't critical for relcache loading, but rather for
  * initial lookup of MyDatabaseId, without which we'll never find any
  * non-shared catalogs at all.  Autovacuum calls InitPostgres with a
  * database OID, so it instead depends on DatabaseOidIndexId.  We also
  * need to nail up some indexes on pg_authid and pg_auth_members for use
  * during client authentication.  SharedSecLabelObjectIndexId isn't
  * critical for the core system, but authentication hooks might be
  * interested in it.
  */
 if (!criticalSharedRelcachesBuilt)
 {
  load_critical_index(DatabaseNameIndexId,
       DatabaseRelationId);
  load_critical_index(DatabaseOidIndexId,
       DatabaseRelationId);
  load_critical_index(AuthIdRolnameIndexId,
       AuthIdRelationId);
  load_critical_index(AuthIdOidIndexId,
       AuthIdRelationId);
  load_critical_index(AuthMemMemRoleIndexId,
       AuthMemRelationId);
  load_critical_index(SharedSecLabelObjectIndexId,
       SharedSecLabelRelationId);

#define NUM_CRITICAL_SHARED_INDEXES 6 #define NUM_CRITICAL_SHARED_INDEXES 6 /* fix if you change list above */

  criticalSharedRelcachesBuilt = true;
 }

 /*
  * Now, scan all the relcache entries and update anything that might be
  * wrong in the results from formrdesc or the relcache cache file. If we
  * faked up relcache entries using formrdesc, then read the real pg_class
  * rows and replace the fake entries with them. Also, if any of the
  * relcache entries have rules, triggers, or security policies, load that
  * info the hard way since it isn't recorded in the cache file.
  *
  * Whenever we access the catalogs to read data, there is a possibility of
  * a shared-inval cache flush causing relcache entries to be removed.
  * Since hash_seq_search only guarantees to still work after the *current*
  * entry is removed, it's unsafe to continue the hashtable scan afterward.
  * We handle this by restarting the scan from scratch after each access.
  * This is theoretically O(N^2), but the number of entries that actually
  * need to be fixed is small enough that it doesn't matter.
 */
 hash_seq_init(&status, RelationIdCache);

 while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
 {
  Relation relation = idhentry->reldesc;
  bool  restart = false;

  /*
   * Make sure *this* entry doesn't get flushed while we work with it.
 */
  RelationIncrementReferenceCount(relation);

  /*
   * If it's a faked-up entry, read the real pg_class tuple.
 */
  if (relation->rd_rel->relowner == InvalidOid)
  {
   HeapTuple htup;
   Form_pg_class relp;

   htup = SearchSysCache1(RELOID,
           ObjectIdGetDatum(RelationGetRelid(relation)));
   if (!HeapTupleIsValid(htup))
    ereport(FATAL,
      errcode(ERRCODE_UNDEFINED_OBJECT),
      errmsg_internal("cache lookup failed for relation %u",
          RelationGetRelid(relation)));
   relp = (Form_pg_class) GETSTRUCT(htup);

   /*
    * Copy tuple to relation->rd_rel. (See notes in
    * AllocateRelationDesc())
 */
   memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);

   /* Update rd_options while we have the tuple */
   if (relation->rd_options)
    pfree(relation->rd_options);
   RelationParseRelOptions(relation, htup);

   /*
    * Check the values in rd_att were set up correctly.  (We cannot
    * just copy them over now: formrdesc must have set up the rd_att
    * data correctly to start with, because it may already have been
    * copied into one or more catcache entries.)
 */
   Assert(relation->rd_att->tdtypeid == relp->reltype);
   Assert(relation->rd_att->tdtypmod == -1);

   ReleaseSysCache(htup);

   /* relowner had better be OK now, else we'll loop forever */
   if (relation->rd_rel->relowner == InvalidOid)
    elog(ERROR, "invalid relowner in pg_class entry for \"%s\"",
      RelationGetRelationName(relation));

   restart = true;
  }

  /*
   * Fix data that isn't saved in relcache cache file.
   *
   * relhasrules or relhastriggers could possibly be wrong or out of
   * date.  If we don't actually find any rules or triggers, clear the
   * local copy of the flag so that we don't get into an infinite loop
   * here.  We don't make any attempt to fix the pg_class entry, though.
 */
  if (relation->rd_rel->relhasrules && relation->rd_rules == NULL)
  {
   RelationBuildRuleLock(relation);
   if (relation->rd_rules == NULL)
    relation->rd_rel->relhasrules = false;
   restart = true;
  }
  if (relation->rd_rel->relhastriggers && relation->trigdesc == NULL)
  {
   RelationBuildTriggers(relation);
   if (relation->trigdesc == NULL)
    relation->rd_rel->relhastriggers = false;
   restart = true;
  }

  /*
   * Re-load the row security policies if the relation has them, since
   * they are not preserved in the cache.  Note that we can never NOT
   * have a policy while relrowsecurity is true,
   * RelationBuildRowSecurity will create a single default-deny policy
   * if there is no policy defined in pg_policy.
 */
  if (relation->rd_rel->relrowsecurity && relation->rd_rsdesc == NULL)
  {
   RelationBuildRowSecurity(relation);

   Assert(relation->rd_rsdesc != NULL);
   restart = true;
  }

  /* Reload tableam data if needed */
  if (relation->rd_tableam == NULL &&
   (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) || relation->rd_rel->relkind == RELKIND_SEQUENCE))
  {
   RelationInitTableAccessMethod(relation);
   Assert(relation->rd_tableam != NULL);

   restart = true;
  }

  /* Release hold on the relation */
  RelationDecrementReferenceCount(relation);

  /* Now, restart the hashtable scan if needed */
  if (restart)
  {
   hash_seq_term(&status);
   hash_seq_init(&status, RelationIdCache);
  }
 }

 /*
  * Lastly, write out new relcache cache files if needed.  We don't bother
  * to distinguish cases where only one of the two needs an update.
 */
 if (needNewCacheFile)
 {
  /*
   * Force all the catcaches to finish initializing and thereby open the
   * catalogs and indexes they use.  This will preload the relcache with
   * entries for all the most important system catalogs and indexes, so
   * that the init files will be most useful for future backends.
 */
  InitCatalogCachePhase2();

  /* now write the files */
  write_relcache_init_file(true);
  write_relcache_init_file(false);
 }
}

/*
 * Load one critical system index into the relcache
 *
 * indexoid is the OID of the target index, heapoid is the OID of the catalog
 * it belongs to.
 */
static void
load_critical_index(Oid indexoid, Oid heapoid)
{
 Relation ird;

 /*
  * We must lock the underlying catalog before locking the index to avoid
  * deadlock, since RelationBuildDesc might well need to read the catalog,
  * and if anyone else is exclusive-locking this catalog and index they'll
  * be doing it in that order.
 */
 LockRelationOid(heapoid, AccessShareLock);
 LockRelationOid(indexoid, AccessShareLock);
 ird = RelationBuildDesc(indexoid, true);
 if (ird == NULL)
  ereport(PANIC,
    errcode(ERRCODE_DATA_CORRUPTED),
    errmsg_internal("could not open critical system index %u", indexoid));
 ird->rd_isnailed = true;
 ird->rd_refcnt = 1;
 UnlockRelationOid(indexoid, AccessShareLock);
 UnlockRelationOid(heapoid, AccessShareLock);

 (void) RelationGetIndexAttOptions(ird, false);
}

/*
 * GetPgClassDescriptor -- get a predefined tuple descriptor for pg_class
 * GetPgIndexDescriptor -- get a predefined tuple descriptor for pg_index
 *
 * We need this kluge because we have to be able to access non-fixed-width
 * fields of pg_class and pg_index before we have the standard catalog caches
 * available.  We use predefined data that's set up in just the same way as
 * the bootstrapped reldescs used by formrdesc().  The resulting tupdesc is
 * not 100% kosher: it does not have the correct rowtype OID in tdtypeid, nor
 * does it have a TupleConstr field.  But it's good enough for the purpose of
 * extracting fields.
 */
static TupleDesc
BuildHardcodedDescriptor(int natts, const FormData_pg_attribute *attrs)
{
 TupleDesc result;
 MemoryContext oldcxt;
 int   i;

 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);

 result = CreateTemplateTupleDesc(natts);
 result->tdtypeid = RECORDOID; /* not right, but we don't care */
 result->tdtypmod = -1;

 for (i = 0; i < natts; i++)
 {
  memcpy(TupleDescAttr(result, i), &attrs[i], ATTRIBUTE_FIXED_PART_SIZE);

  populate_compact_attribute(result, i);
 }

 /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
 TupleDescCompactAttr(result, 0)->attcacheoff = 0;

 /* Note: we don't bother to set up a TupleConstr entry */

 MemoryContextSwitchTo(oldcxt);

 return result;
}

static TupleDesc
GetPgClassDescriptor(void)
{
 static TupleDesc pgclassdesc = NULL;

 /* Already done? */
 if (pgclassdesc == NULL)
  pgclassdesc = BuildHardcodedDescriptor(Natts_pg_class,
              Desc_pg_class);

 return pgclassdesc;
}

static TupleDesc
GetPgIndexDescriptor(void)
{
 static TupleDesc pgindexdesc = NULL;

 /* Already done? */
 if (pgindexdesc == NULL)
  pgindexdesc = BuildHardcodedDescriptor(Natts_pg_index,
              Desc_pg_index);

 return pgindexdesc;
}

/*
 * Load any default attribute value definitions for the relation.
 *
 * ndef is the number of attributes that were marked atthasdef.
 *
 * Note: we don't make it a hard error to be missing some pg_attrdef records.
 * We can limp along as long as nothing needs to use the default value.  Code
 * that fails to find an expected AttrDefault record should throw an error.
 */
static void
AttrDefaultFetch(Relation relation, int ndef)
{
 AttrDefault *attrdef;
 Relation adrel;
 SysScanDesc adscan;
 ScanKeyData skey;
 HeapTuple htup;
 int   found = 0;

 /* Allocate array with room for as many entries as expected */
 attrdef = (AttrDefault *)
  MemoryContextAllocZero(CacheMemoryContext,
          ndef * sizeof(AttrDefault));

 /* Search pg_attrdef for relevant entries */
 ScanKeyInit(&skey,
    Anum_pg_attrdef_adrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));

 adrel = table_open(AttrDefaultRelationId, AccessShareLock);
 adscan = systable_beginscan(adrel, AttrDefaultIndexId, true,
        NULL, 1, &skey);

 while (HeapTupleIsValid(htup = systable_getnext(adscan)))
 {
  Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup);
  Datum  val;
  bool  isnull;

  /* protect limited size of array */
  if (found >= ndef)
  {
   elog(WARNING, "unexpected pg_attrdef record found for attribute %d of relation \"%s\"",
     adform->adnum, RelationGetRelationName(relation));
   break;
  }

  val = fastgetattr(htup,
        Anum_pg_attrdef_adbin,
        adrel->rd_att, &isnull);
  if (isnull)
   elog(WARNING, "null adbin for attribute %d of relation \"%s\"",
     adform->adnum, RelationGetRelationName(relation));
  else
  {
   /* detoast and convert to cstring in caller's context */
   char    *s = TextDatumGetCString(val);

   attrdef[found].adnum = adform->adnum;
   attrdef[found].adbin = MemoryContextStrdup(CacheMemoryContext, s);
   pfree(s);
   found++;
  }
 }

 systable_endscan(adscan);
 table_close(adrel, AccessShareLock);

 if (found != ndef)
  elog(WARNING, "%d pg_attrdef record(s) missing for relation \"%s\"",
    ndef - found, RelationGetRelationName(relation));

 /*
  * Sort the AttrDefault entries by adnum, for the convenience of
  * equalTupleDescs().  (Usually, they already will be in order, but this
  * might not be so if systable_getnext isn't using an index.)
 */
 if (found > 1)
  qsort(attrdef, found, sizeof(AttrDefault), AttrDefaultCmp);

 /* Install array only after it's fully valid */
 relation->rd_att->constr->defval = attrdef;
 relation->rd_att->constr->num_defval = found;
}

/*
 * qsort comparator to sort AttrDefault entries by adnum
 */
static int
AttrDefaultCmp(const void *a, const void *b)
{
 const AttrDefault *ada = (const AttrDefault *) a;
 const AttrDefault *adb = (const AttrDefault *) b;

 return pg_cmp_s16(ada->adnum, adb->adnum);
}

/*
 * Load any check constraints for the relation, and update not-null validity
 * of invalid constraints.
 *
 * As with defaults, if we don't find the expected number of them, just warn
 * here.  The executor should throw an error if an INSERT/UPDATE is attempted.
 */
static void
CheckNNConstraintFetch(Relation relation)
{
 ConstrCheck *check;
 int   ncheck = relation->rd_rel->relchecks;
 Relation conrel;
 SysScanDesc conscan;
 ScanKeyData skey[1];
 HeapTuple htup;
 int   found = 0;

 /* Allocate array with room for as many entries as expected, if needed */
 if (ncheck > 0)
  check = (ConstrCheck *)
   MemoryContextAllocZero(CacheMemoryContext,
           ncheck * sizeof(ConstrCheck));
 else
  check = NULL;

 /* Search pg_constraint for relevant entries */
 ScanKeyInit(&skey[0],
    Anum_pg_constraint_conrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));

 conrel = table_open(ConstraintRelationId, AccessShareLock);
 conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
         NULL, 1, skey);

 while (HeapTupleIsValid(htup = systable_getnext(conscan)))
 {
  Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(htup);
  Datum  val;
  bool  isnull;

  /*
   * If this is a not-null constraint, then only look at it if it's
   * invalid, and if so, mark the TupleDesc entry as known invalid.
   * Otherwise move on.  We'll mark any remaining columns that are still
   * in UNKNOWN state as known valid later.  This allows us not to have
   * to extract the attnum from this constraint tuple in the vast
   * majority of cases.
 */
  if (conform->contype == CONSTRAINT_NOTNULL)
  {
   if (!conform->convalidated)
   {
    AttrNumber attnum;

    attnum = extractNotNullColumn(htup);
    Assert(relation->rd_att->compact_attrs[attnum - 1].attnullability ==
        ATTNULLABLE_UNKNOWN);
    relation->rd_att->compact_attrs[attnum - 1].attnullability =
     ATTNULLABLE_INVALID;
   }

   continue;
  }

  /* For what follows, consider check constraints only */
  if (conform->contype != CONSTRAINT_CHECK)
   continue;

  /* protect limited size of array */
  if (found >= ncheck)
  {
   elog(WARNING, "unexpected pg_constraint record found for relation \"%s\"",
     RelationGetRelationName(relation));
   break;
  }

  check[found].ccenforced = conform->conenforced;
  check[found].ccvalid = conform->convalidated;
  check[found].ccnoinherit = conform->connoinherit;
  check[found].ccname = MemoryContextStrdup(CacheMemoryContext,
              NameStr(conform->conname));

  /* Grab and test conbin is actually set */
  val = fastgetattr(htup,
        Anum_pg_constraint_conbin,
        conrel->rd_att, &isnull);
  if (isnull)
   elog(WARNING, "null conbin for relation \"%s\"",
     RelationGetRelationName(relation));
  else
  {
   /* detoast and convert to cstring in caller's context */
   char    *s = TextDatumGetCString(val);

   check[found].ccbin = MemoryContextStrdup(CacheMemoryContext, s);
   pfree(s);
   found++;
  }
 }

 systable_endscan(conscan);
 table_close(conrel, AccessShareLock);

 if (found != ncheck)
  elog(WARNING, "%d pg_constraint record(s) missing for relation \"%s\"",
    ncheck - found, RelationGetRelationName(relation));

 /*
  * Sort the records by name.  This ensures that CHECKs are applied in a
  * deterministic order, and it also makes equalTupleDescs() faster.
 */
 if (found > 1)
  qsort(check, found, sizeof(ConstrCheck), CheckConstraintCmp);

 /* Install array only after it's fully valid */
 relation->rd_att->constr->check = check;
 relation->rd_att->constr->num_check = found;
}

/*
 * qsort comparator to sort ConstrCheck entries by name
 */
static int
CheckConstraintCmp(const void *a, const void *b)
{
 const ConstrCheck *ca = (const ConstrCheck *) a;
 const ConstrCheck *cb = (const ConstrCheck *) b;

 return strcmp(ca->ccname, cb->ccname);
}

/*
 * RelationGetFKeyList -- get a list of foreign key info for the relation
 *
 * Returns a list of ForeignKeyCacheInfo structs, one per FK constraining
 * the given relation.  This data is a direct copy of relevant fields from
 * pg_constraint.  The list items are in no particular order.
 *
 * CAUTION: the returned list is part of the relcache's data, and could
 * vanish in a relcache entry reset.  Callers must inspect or copy it
 * before doing anything that might trigger a cache flush, such as
 * system catalog accesses.  copyObject() can be used if desired.
 * (We define it this way because current callers want to filter and
 * modify the list entries anyway, so copying would be a waste of time.)
 */
List *
RelationGetFKeyList(Relation relation)
{
 List    *result;
 Relation conrel;
 SysScanDesc conscan;
 ScanKeyData skey;
 HeapTuple htup;
 List    *oldlist;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the list. */
 if (relation->rd_fkeyvalid)
  return relation->rd_fkeylist;

 /*
  * We build the list we intend to return (in the caller's context) while
  * doing the scan.  After successfully completing the scan, we copy that
  * list into the relcache entry.  This avoids cache-context memory leakage
  * if we get some sort of error partway through.
 */
 result = NIL;

 /* Prepare to scan pg_constraint for entries having conrelid = this rel. */
 ScanKeyInit(&skey,
    Anum_pg_constraint_conrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));

 conrel = table_open(ConstraintRelationId, AccessShareLock);
 conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
         NULL, 1, &skey);

 while (HeapTupleIsValid(htup = systable_getnext(conscan)))
 {
  Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(htup);
  ForeignKeyCacheInfo *info;

  /* consider only foreign keys */
  if (constraint->contype != CONSTRAINT_FOREIGN)
   continue;

  info = makeNode(ForeignKeyCacheInfo);
  info->conoid = constraint->oid;
  info->conrelid = constraint->conrelid;
  info->confrelid = constraint->confrelid;
  info->conenforced = constraint->conenforced;

  DeconstructFkConstraintRow(htup, &info->nkeys,
           info->conkey,
           info->confkey,
           info->conpfeqop,
           NULL, NULL, NULL, NULL);

  /* Add FK's node to the result list */
  result = lappend(result, info);
 }

 systable_endscan(conscan);
 table_close(conrel, AccessShareLock);

 /* Now save a copy of the completed list in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 oldlist = relation->rd_fkeylist;
 relation->rd_fkeylist = copyObject(result);
 relation->rd_fkeyvalid = true;
 MemoryContextSwitchTo(oldcxt);

 /* Don't leak the old list, if there is one */
 list_free_deep(oldlist);

 return result;
}

/*
 * RelationGetIndexList -- get a list of OIDs of indexes on this relation
 *
 * The index list is created only if someone requests it.  We scan pg_index
 * to find relevant indexes, and add the list to the relcache entry so that
 * we won't have to compute it again.  Note that shared cache inval of a
 * relcache entry will delete the old list and set rd_indexvalid to false,
 * so that we must recompute the index list on next request.  This handles
 * creation or deletion of an index.
 *
 * Indexes that are marked not indislive are omitted from the returned list.
 * Such indexes are expected to be dropped momentarily, and should not be
 * touched at all by any caller of this function.
 *
 * The returned list is guaranteed to be sorted in order by OID.  This is
 * needed by the executor, since for index types that we obtain exclusive
 * locks on when updating the index, all backends must lock the indexes in
 * the same order or we will get deadlocks (see ExecOpenIndices()).  Any
 * consistent ordering would do, but ordering by OID is easy.
 *
 * Since shared cache inval causes the relcache's copy of the list to go away,
 * we return a copy of the list palloc'd in the caller's context.  The caller
 * may list_free() the returned list after scanning it. This is necessary
 * since the caller will typically be doing syscache lookups on the relevant
 * indexes, and syscache lookup could cause SI messages to be processed!
 *
 * In exactly the same way, we update rd_pkindex, which is the OID of the
 * relation's primary key index if any, else InvalidOid; and rd_replidindex,
 * which is the pg_class OID of an index to be used as the relation's
 * replication identity index, or InvalidOid if there is no such index.
 */
List *
RelationGetIndexList(Relation relation)
{
 Relation indrel;
 SysScanDesc indscan;
 ScanKeyData skey;
 HeapTuple htup;
 List    *result;
 List    *oldlist;
 char  replident = relation->rd_rel->relreplident;
 Oid   pkeyIndex = InvalidOid;
 Oid   candidateIndex = InvalidOid;
 bool  pkdeferrable = false;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the list. */
 if (relation->rd_indexvalid)
  return list_copy(relation->rd_indexlist);

 /*
  * We build the list we intend to return (in the caller's context) while
  * doing the scan.  After successfully completing the scan, we copy that
  * list into the relcache entry.  This avoids cache-context memory leakage
  * if we get some sort of error partway through.
 */
 result = NIL;

 /* Prepare to scan pg_index for entries having indrelid = this rel. */
 ScanKeyInit(&skey,
    Anum_pg_index_indrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));

 indrel = table_open(IndexRelationId, AccessShareLock);
 indscan = systable_beginscan(indrel, IndexIndrelidIndexId, true,
         NULL, 1, &skey);

 while (HeapTupleIsValid(htup = systable_getnext(indscan)))
 {
  Form_pg_index index = (Form_pg_index) GETSTRUCT(htup);

  /*
   * Ignore any indexes that are currently being dropped.  This will
   * prevent them from being searched, inserted into, or considered in
   * HOT-safety decisions.  It's unsafe to touch such an index at all
   * since its catalog entries could disappear at any instant.
 */
  if (!index->indislive)
   continue;

  /* add index's OID to result list */
  result = lappend_oid(result, index->indexrelid);

  /*
   * Non-unique or predicate indexes aren't interesting for either oid
   * indexes or replication identity indexes, so don't check them.
   * Deferred ones are not useful for replication identity either; but
   * we do include them if they are PKs.
 */
  if (!index->indisunique ||
   !heap_attisnull(htup, Anum_pg_index_indpred, NULL))
   continue;

  /*
   * Remember primary key index, if any.  For regular tables we do this
   * only if the index is valid; but for partitioned tables, then we do
   * it even if it's invalid.
   *
   * The reason for returning invalid primary keys for partitioned
   * tables is that we need it to prevent drop of not-null constraints
   * that may underlie such a primary key, which is only a problem for
   * partitioned tables.
 */
  if (index->indisprimary &&
   (index->indisvalid ||
    relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
  {
   pkeyIndex = index->indexrelid;
   pkdeferrable = !index->indimmediate;
  }

  if (!index->indimmediate)
   continue;

  if (!index->indisvalid)
   continue;

  /* remember explicitly chosen replica index */
  if (index->indisreplident)
   candidateIndex = index->indexrelid;
 }

 systable_endscan(indscan);

 table_close(indrel, AccessShareLock);

 /* Sort the result list into OID order, per API spec. */
 list_sort(result, list_oid_cmp);

 /* Now save a copy of the completed list in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 oldlist = relation->rd_indexlist;
 relation->rd_indexlist = list_copy(result);
 relation->rd_pkindex = pkeyIndex;
 relation->rd_ispkdeferrable = pkdeferrable;
 if (replident == REPLICA_IDENTITY_DEFAULT && OidIsValid(pkeyIndex) && !pkdeferrable)
  relation->rd_replidindex = pkeyIndex;
 else if (replident == REPLICA_IDENTITY_INDEX && OidIsValid(candidateIndex))
  relation->rd_replidindex = candidateIndex;
 else
  relation->rd_replidindex = InvalidOid;
 relation->rd_indexvalid = true;
 MemoryContextSwitchTo(oldcxt);

 /* Don't leak the old list, if there is one */
 list_free(oldlist);

 return result;
}

/*
 * RelationGetStatExtList
 *  get a list of OIDs of statistics objects on this relation
 *
 * The statistics list is created only if someone requests it, in a way
 * similar to RelationGetIndexList().  We scan pg_statistic_ext to find
 * relevant statistics, and add the list to the relcache entry so that we
 * won't have to compute it again.  Note that shared cache inval of a
 * relcache entry will delete the old list and set rd_statvalid to 0,
 * so that we must recompute the statistics list on next request.  This
 * handles creation or deletion of a statistics object.
 *
 * The returned list is guaranteed to be sorted in order by OID, although
 * this is not currently needed.
 *
 * Since shared cache inval causes the relcache's copy of the list to go away,
 * we return a copy of the list palloc'd in the caller's context.  The caller
 * may list_free() the returned list after scanning it. This is necessary
 * since the caller will typically be doing syscache lookups on the relevant
 * statistics, and syscache lookup could cause SI messages to be processed!
 */
List *
RelationGetStatExtList(Relation relation)
{
 Relation indrel;
 SysScanDesc indscan;
 ScanKeyData skey;
 HeapTuple htup;
 List    *result;
 List    *oldlist;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the list. */
 if (relation->rd_statvalid != 0)
  return list_copy(relation->rd_statlist);

 /*
  * We build the list we intend to return (in the caller's context) while
  * doing the scan.  After successfully completing the scan, we copy that
  * list into the relcache entry.  This avoids cache-context memory leakage
  * if we get some sort of error partway through.
 */
 result = NIL;

 /*
  * Prepare to scan pg_statistic_ext for entries having stxrelid = this
  * rel.
 */
 ScanKeyInit(&skey,
    Anum_pg_statistic_ext_stxrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(RelationGetRelid(relation)));

 indrel = table_open(StatisticExtRelationId, AccessShareLock);
 indscan = systable_beginscan(indrel, StatisticExtRelidIndexId, true,
         NULL, 1, &skey);

 while (HeapTupleIsValid(htup = systable_getnext(indscan)))
 {
  Oid   oid = ((Form_pg_statistic_ext) GETSTRUCT(htup))->oid;

  result = lappend_oid(result, oid);
 }

 systable_endscan(indscan);

 table_close(indrel, AccessShareLock);

 /* Sort the result list into OID order, per API spec. */
 list_sort(result, list_oid_cmp);

 /* Now save a copy of the completed list in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 oldlist = relation->rd_statlist;
 relation->rd_statlist = list_copy(result);

 relation->rd_statvalid = true;
 MemoryContextSwitchTo(oldcxt);

 /* Don't leak the old list, if there is one */
 list_free(oldlist);

 return result;
}

/*
 * RelationGetPrimaryKeyIndex -- get OID of the relation's primary key index
 *
 * Returns InvalidOid if there is no such index, or if the primary key is
 * DEFERRABLE and the caller isn't OK with that.
 */
Oid
RelationGetPrimaryKeyIndex(Relation relation, bool deferrable_ok)
{
 List    *ilist;

 if (!relation->rd_indexvalid)
 {
  /* RelationGetIndexList does the heavy lifting. */
  ilist = RelationGetIndexList(relation);
  list_free(ilist);
  Assert(relation->rd_indexvalid);
 }

 if (deferrable_ok)
  return relation->rd_pkindex;
 else if (relation->rd_ispkdeferrable)
  return InvalidOid;
 return relation->rd_pkindex;
}

/*
 * RelationGetReplicaIndex -- get OID of the relation's replica identity index
 *
 * Returns InvalidOid if there is no such index.
 */
Oid
RelationGetReplicaIndex(Relation relation)
{
 List    *ilist;

 if (!relation->rd_indexvalid)
 {
  /* RelationGetIndexList does the heavy lifting. */
  ilist = RelationGetIndexList(relation);
  list_free(ilist);
  Assert(relation->rd_indexvalid);
 }

 return relation->rd_replidindex;
}

/*
 * RelationGetIndexExpressions -- get the index expressions for an index
 *
 * We cache the result of transforming pg_index.indexprs into a node tree.
 * If the rel is not an index or has no expressional columns, we return NIL.
 * Otherwise, the returned tree is copied into the caller's memory context.
 * (We don't want to return a pointer to the relcache copy, since it could
 * disappear due to relcache invalidation.)
 */
List *
RelationGetIndexExpressions(Relation relation)
{
 List    *result;
 Datum  exprsDatum;
 bool  isnull;
 char    *exprsString;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the result. */
 if (relation->rd_indexprs)
  return copyObject(relation->rd_indexprs);

 /* Quick exit if there is nothing to do. */
 if (relation->rd_indextuple == NULL ||
  heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
  return NIL;

 /*
  * We build the tree we intend to return in the caller's context. After
  * successfully completing the work, we copy it into the relcache entry.
  * This avoids problems if we get some sort of error partway through.
 */
 exprsDatum = heap_getattr(relation->rd_indextuple,
         Anum_pg_index_indexprs,
         GetPgIndexDescriptor(),
         &isnull);
 Assert(!isnull);
 exprsString = TextDatumGetCString(exprsDatum);
 result = (List *) stringToNode(exprsString);
 pfree(exprsString);

 /*
  * Run the expressions through eval_const_expressions. This is not just an
  * optimization, but is necessary, because the planner will be comparing
  * them to similarly-processed qual clauses, and may fail to detect valid
  * matches without this.  We must not use canonicalize_qual, however,
  * since these aren't qual expressions.
 */
 result = (List *) eval_const_expressions(NULL, (Node *) result);

 /* May as well fix opfuncids too */
 fix_opfuncids((Node *) result);

 /* Now save a copy of the completed tree in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
 relation->rd_indexprs = copyObject(result);
 MemoryContextSwitchTo(oldcxt);

 return result;
}

/*
 * RelationGetDummyIndexExpressions -- get dummy expressions for an index
 *
 * Return a list of dummy expressions (just Const nodes) with the same
 * types/typmods/collations as the index's real expressions.  This is
 * useful in situations where we don't want to run any user-defined code.
 */
List *
RelationGetDummyIndexExpressions(Relation relation)
{
 List    *result;
 Datum  exprsDatum;
 bool  isnull;
 char    *exprsString;
 List    *rawExprs;
 ListCell   *lc;

 /* Quick exit if there is nothing to do. */
 if (relation->rd_indextuple == NULL ||
  heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
  return NIL;

 /* Extract raw node tree(s) from index tuple. */
 exprsDatum = heap_getattr(relation->rd_indextuple,
         Anum_pg_index_indexprs,
         GetPgIndexDescriptor(),
         &isnull);
 Assert(!isnull);
 exprsString = TextDatumGetCString(exprsDatum);
 rawExprs = (List *) stringToNode(exprsString);
 pfree(exprsString);

 /* Construct null Consts; the typlen and typbyval are arbitrary. */
 result = NIL;
 foreach(lc, rawExprs)
 {
  Node    *rawExpr = (Node *) lfirst(lc);

  result = lappend(result,
       makeConst(exprType(rawExpr),
           exprTypmod(rawExpr),
           exprCollation(rawExpr),
           1,
           (Datum) 0,
           true,
           true));
 }

 return result;
}

/*
 * RelationGetIndexPredicate -- get the index predicate for an index
 *
 * We cache the result of transforming pg_index.indpred into an implicit-AND
 * node tree (suitable for use in planning).
 * If the rel is not an index or has no predicate, we return NIL.
 * Otherwise, the returned tree is copied into the caller's memory context.
 * (We don't want to return a pointer to the relcache copy, since it could
 * disappear due to relcache invalidation.)
 */
List *
RelationGetIndexPredicate(Relation relation)
{
 List    *result;
 Datum  predDatum;
 bool  isnull;
 char    *predString;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the result. */
 if (relation->rd_indpred)
  return copyObject(relation->rd_indpred);

 /* Quick exit if there is nothing to do. */
 if (relation->rd_indextuple == NULL ||
  heap_attisnull(relation->rd_indextuple, Anum_pg_index_indpred, NULL))
  return NIL;

 /*
  * We build the tree we intend to return in the caller's context. After
  * successfully completing the work, we copy it into the relcache entry.
  * This avoids problems if we get some sort of error partway through.
 */
 predDatum = heap_getattr(relation->rd_indextuple,
        Anum_pg_index_indpred,
        GetPgIndexDescriptor(),
        &isnull);
 Assert(!isnull);
 predString = TextDatumGetCString(predDatum);
 result = (List *) stringToNode(predString);
 pfree(predString);

 /*
  * Run the expression through const-simplification and canonicalization.
  * This is not just an optimization, but is necessary, because the planner
  * will be comparing it to similarly-processed qual clauses, and may fail
  * to detect valid matches without this.  This must match the processing
  * done to qual clauses in preprocess_expression()!  (We can skip the
  * stuff involving subqueries, however, since we don't allow any in index
  * predicates.)
 */
 result = (List *) eval_const_expressions(NULL, (Node *) result);

 result = (List *) canonicalize_qual((Expr *) result, false);

 /* Also convert to implicit-AND format */
 result = make_ands_implicit((Expr *) result);

 /* May as well fix opfuncids too */
 fix_opfuncids((Node *) result);

 /* Now save a copy of the completed tree in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
 relation->rd_indpred = copyObject(result);
 MemoryContextSwitchTo(oldcxt);

 return result;
}

/*
 * RelationGetIndexAttrBitmap -- get a bitmap of index attribute numbers
 *
 * The result has a bit set for each attribute used anywhere in the index
 * definitions of all the indexes on this relation.  (This includes not only
 * simple index keys, but attributes used in expressions and partial-index
 * predicates.)
 *
 * Depending on attrKind, a bitmap covering attnums for certain columns is
 * returned:
 * INDEX_ATTR_BITMAP_KEY   Columns in non-partial unique indexes not
 *         in expressions (i.e., usable for FKs)
 * INDEX_ATTR_BITMAP_PRIMARY_KEY Columns in the table's primary key
 *         (beware: even if PK is deferrable!)
 * INDEX_ATTR_BITMAP_IDENTITY_KEY Columns in the table's replica identity
 *         index (empty if FULL)
 * INDEX_ATTR_BITMAP_HOT_BLOCKING Columns that block updates from being HOT
 * INDEX_ATTR_BITMAP_SUMMARIZED Columns included in summarizing indexes
 *
 * Attribute numbers are offset by FirstLowInvalidHeapAttributeNumber so that
 * we can include system attributes (e.g., OID) in the bitmap representation.
 *
 * Deferred indexes are considered for the primary key, but not for replica
 * identity.
 *
 * Caller had better hold at least RowExclusiveLock on the target relation
 * to ensure it is safe (deadlock-free) for us to take locks on the relation's
 * indexes.  Note that since the introduction of CREATE INDEX CONCURRENTLY,
 * that lock level doesn't guarantee a stable set of indexes, so we have to
 * be prepared to retry here in case of a change in the set of indexes.
 *
 * The returned result is palloc'd in the caller's memory context and should
 * be bms_free'd when not needed anymore.
 */
Bitmapset *
RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
{
 Bitmapset  *uindexattrs; /* columns in unique indexes */
 Bitmapset  *pkindexattrs; /* columns in the primary index */
 Bitmapset  *idindexattrs; /* columns in the replica identity */
 Bitmapset  *hotblockingattrs; /* columns with HOT blocking indexes */
 Bitmapset  *summarizedattrs; /* columns with summarizing indexes */
 List    *indexoidlist;
 List    *newindexoidlist;
 Oid   relpkindex;
 Oid   relreplindex;
 ListCell   *l;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the result. */
 if (relation->rd_attrsvalid)
 {
  switch (attrKind)
  {
   case INDEX_ATTR_BITMAP_KEY:
    return bms_copy(relation->rd_keyattr);
   case INDEX_ATTR_BITMAP_PRIMARY_KEY:
    return bms_copy(relation->rd_pkattr);
   case INDEX_ATTR_BITMAP_IDENTITY_KEY:
    return bms_copy(relation->rd_idattr);
   case INDEX_ATTR_BITMAP_HOT_BLOCKING:
    return bms_copy(relation->rd_hotblockingattr);
   case INDEX_ATTR_BITMAP_SUMMARIZED:
    return bms_copy(relation->rd_summarizedattr);
   default:
    elog(ERROR, "unknown attrKind %u", attrKind);
  }
 }

 /* Fast path if definitely no indexes */
 if (!RelationGetForm(relation)->relhasindex)
  return NULL;

 /*
  * Get cached list of index OIDs. If we have to start over, we do so here.
 */
restart:
 indexoidlist = RelationGetIndexList(relation);

 /* Fall out if no indexes (but relhasindex was set) */
 if (indexoidlist == NIL)
  return NULL;

 /*
  * Copy the rd_pkindex and rd_replidindex values computed by
  * RelationGetIndexList before proceeding.  This is needed because a
  * relcache flush could occur inside index_open below, resetting the
  * fields managed by RelationGetIndexList.  We need to do the work with
  * stable values of these fields.
 */
 relpkindex = relation->rd_pkindex;
 relreplindex = relation->rd_replidindex;

 /*
  * For each index, add referenced attributes to indexattrs.
  *
  * Note: we consider all indexes returned by RelationGetIndexList, even if
  * they are not indisready or indisvalid.  This is important because an
  * index for which CREATE INDEX CONCURRENTLY has just started must be
  * included in HOT-safety decisions (see README.HOT).  If a DROP INDEX
  * CONCURRENTLY is far enough along that we should ignore the index, it
  * won't be returned at all by RelationGetIndexList.
 */
 uindexattrs = NULL;
 pkindexattrs = NULL;
 idindexattrs = NULL;
 hotblockingattrs = NULL;
 summarizedattrs = NULL;
 foreach(l, indexoidlist)
 {
  Oid   indexOid = lfirst_oid(l);
  Relation indexDesc;
  Datum  datum;
  bool  isnull;
  Node    *indexExpressions;
  Node    *indexPredicate;
  int   i;
  bool  isKey;  /* candidate key */
  bool  isPK;  /* primary key */
  bool  isIDKey; /* replica identity index */
  Bitmapset **attrs;

  indexDesc = index_open(indexOid, AccessShareLock);

  /*
   * Extract index expressions and index predicate.  Note: Don't use
   * RelationGetIndexExpressions()/RelationGetIndexPredicate(), because
   * those might run constant expressions evaluation, which needs a
   * snapshot, which we might not have here.  (Also, it's probably more
   * sound to collect the bitmaps before any transformations that might
   * eliminate columns, but the practical impact of this is limited.)
 */

  datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indexprs,
        GetPgIndexDescriptor(), &isnull);
  if (!isnull)
   indexExpressions = stringToNode(TextDatumGetCString(datum));
  else
   indexExpressions = NULL;

  datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indpred,
        GetPgIndexDescriptor(), &isnull);
  if (!isnull)
   indexPredicate = stringToNode(TextDatumGetCString(datum));
  else
   indexPredicate = NULL;

  /* Can this index be referenced by a foreign key? */
  isKey = indexDesc->rd_index->indisunique &&
   indexExpressions == NULL &&
   indexPredicate == NULL;

  /* Is this a primary key? */
  isPK = (indexOid == relpkindex);

  /* Is this index the configured (or default) replica identity? */
  isIDKey = (indexOid == relreplindex);

  /*
   * If the index is summarizing, it doesn't block HOT updates, but we
   * may still need to update it (if the attributes were modified). So
   * decide which bitmap we'll update in the following loop.
 */
  if (indexDesc->rd_indam->amsummarizing)
   attrs = &summarizedattrs;
  else
   attrs = &hotblockingattrs;

  /* Collect simple attribute references */
  for (i = 0; i < indexDesc->rd_index->indnatts; i++)
  {
   int   attrnum = indexDesc->rd_index->indkey.values[i];

   /*
    * Since we have covering indexes with non-key columns, we must
    * handle them accurately here. non-key columns must be added into
    * hotblockingattrs or summarizedattrs, since they are in index,
    * and update shouldn't miss them.
    *
    * Summarizing indexes do not block HOT, but do need to be updated
    * when the column value changes, thus require a separate
    * attribute bitmapset.
    *
    * Obviously, non-key columns couldn't be referenced by foreign
    * key or identity key. Hence we do not include them into
    * uindexattrs, pkindexattrs and idindexattrs bitmaps.
 */
   if (attrnum != 0)
   {
    *attrs = bms_add_member(*attrs,
          attrnum - FirstLowInvalidHeapAttributeNumber);

    if (isKey && i < indexDesc->rd_index->indnkeyatts)
     uindexattrs = bms_add_member(uindexattrs,
             attrnum - FirstLowInvalidHeapAttributeNumber);

    if (isPK && i < indexDesc->rd_index->indnkeyatts)
     pkindexattrs = bms_add_member(pkindexattrs,
              attrnum - FirstLowInvalidHeapAttributeNumber);

    if (isIDKey && i < indexDesc->rd_index->indnkeyatts)
     idindexattrs = bms_add_member(idindexattrs,
              attrnum - FirstLowInvalidHeapAttributeNumber);
   }
  }

  /* Collect all attributes used in expressions, too */
  pull_varattnos(indexExpressions, 1, attrs);

  /* Collect all attributes in the index predicate, too */
  pull_varattnos(indexPredicate, 1, attrs);

  index_close(indexDesc, AccessShareLock);
 }

 /*
  * During one of the index_opens in the above loop, we might have received
  * a relcache flush event on this relcache entry, which might have been
  * signaling a change in the rel's index list.  If so, we'd better start
  * over to ensure we deliver up-to-date attribute bitmaps.
 */
 newindexoidlist = RelationGetIndexList(relation);
 if (equal(indexoidlist, newindexoidlist) &&
  relpkindex == relation->rd_pkindex &&
  relreplindex == relation->rd_replidindex)
 {
  /* Still the same index set, so proceed */
  list_free(newindexoidlist);
  list_free(indexoidlist);
 }
 else
 {
  /* Gotta do it over ... might as well not leak memory */
  list_free(newindexoidlist);
  list_free(indexoidlist);
  bms_free(uindexattrs);
  bms_free(pkindexattrs);
  bms_free(idindexattrs);
  bms_free(hotblockingattrs);
  bms_free(summarizedattrs);

  goto restart;
 }

 /* Don't leak the old values of these bitmaps, if any */
 relation->rd_attrsvalid = false;
 bms_free(relation->rd_keyattr);
 relation->rd_keyattr = NULL;
 bms_free(relation->rd_pkattr);
 relation->rd_pkattr = NULL;
 bms_free(relation->rd_idattr);
 relation->rd_idattr = NULL;
 bms_free(relation->rd_hotblockingattr);
 relation->rd_hotblockingattr = NULL;
 bms_free(relation->rd_summarizedattr);
 relation->rd_summarizedattr = NULL;

 /*
  * Now save copies of the bitmaps in the relcache entry.  We intentionally
  * set rd_attrsvalid last, because that's the one that signals validity of
  * the values; if we run out of memory before making that copy, we won't
  * leave the relcache entry looking like the other ones are valid but
  * empty.
 */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 relation->rd_keyattr = bms_copy(uindexattrs);
 relation->rd_pkattr = bms_copy(pkindexattrs);
 relation->rd_idattr = bms_copy(idindexattrs);
 relation->rd_hotblockingattr = bms_copy(hotblockingattrs);
 relation->rd_summarizedattr = bms_copy(summarizedattrs);
 relation->rd_attrsvalid = true;
 MemoryContextSwitchTo(oldcxt);

 /* We return our original working copy for caller to play with */
 switch (attrKind)
 {
  case INDEX_ATTR_BITMAP_KEY:
   return uindexattrs;
  case INDEX_ATTR_BITMAP_PRIMARY_KEY:
   return pkindexattrs;
  case INDEX_ATTR_BITMAP_IDENTITY_KEY:
   return idindexattrs;
  case INDEX_ATTR_BITMAP_HOT_BLOCKING:
   return hotblockingattrs;
  case INDEX_ATTR_BITMAP_SUMMARIZED:
   return summarizedattrs;
  default:
   elog(ERROR, "unknown attrKind %u", attrKind);
   return NULL;
 }
}

/*
 * RelationGetIdentityKeyBitmap -- get a bitmap of replica identity attribute
 * numbers
 *
 * A bitmap of index attribute numbers for the configured replica identity
 * index is returned.
 *
 * See also comments of RelationGetIndexAttrBitmap().
 *
 * This is a special purpose function used during logical replication. Here,
 * unlike RelationGetIndexAttrBitmap(), we don't acquire a lock on the required
 * index as we build the cache entry using a historic snapshot and all the
 * later changes are absorbed while decoding WAL. Due to this reason, we don't
 * need to retry here in case of a change in the set of indexes.
 */
Bitmapset *
RelationGetIdentityKeyBitmap(Relation relation)
{
 Bitmapset  *idindexattrs = NULL; /* columns in the replica identity */
 Relation indexDesc;
 int   i;
 Oid   replidindex;
 MemoryContext oldcxt;

 /* Quick exit if we already computed the result */
 if (relation->rd_idattr != NULL)
  return bms_copy(relation->rd_idattr);

 /* Fast path if definitely no indexes */
 if (!RelationGetForm(relation)->relhasindex)
  return NULL;

 /* Historic snapshot must be set. */
 Assert(HistoricSnapshotActive());

 replidindex = RelationGetReplicaIndex(relation);

 /* Fall out if there is no replica identity index */
 if (!OidIsValid(replidindex))
  return NULL;

 /* Look up the description for the replica identity index */
 indexDesc = RelationIdGetRelation(replidindex);

 if (!RelationIsValid(indexDesc))
  elog(ERROR, "could not open relation with OID %u",
    relation->rd_replidindex);

 /* Add referenced attributes to idindexattrs */
 for (i = 0; i < indexDesc->rd_index->indnatts; i++)
 {
  int   attrnum = indexDesc->rd_index->indkey.values[i];

  /*
   * We don't include non-key columns into idindexattrs bitmaps. See
   * RelationGetIndexAttrBitmap.
 */
  if (attrnum != 0)
  {
   if (i < indexDesc->rd_index->indnkeyatts)
    idindexattrs = bms_add_member(idindexattrs,
             attrnum - FirstLowInvalidHeapAttributeNumber);
  }
 }

 RelationClose(indexDesc);

 /* Don't leak the old values of these bitmaps, if any */
 bms_free(relation->rd_idattr);
 relation->rd_idattr = NULL;

 /* Now save copy of the bitmap in the relcache entry */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 relation->rd_idattr = bms_copy(idindexattrs);
 MemoryContextSwitchTo(oldcxt);

 /* We return our original working copy for caller to play with */
 return idindexattrs;
}

/*
 * RelationGetExclusionInfo -- get info about index's exclusion constraint
 *
 * This should be called only for an index that is known to have an associated
 * exclusion constraint or primary key/unique constraint using WITHOUT
 * OVERLAPS.

 * It returns arrays (palloc'd in caller's context) of the exclusion operator
 * OIDs, their underlying functions' OIDs, and their strategy numbers in the
 * index's opclasses.  We cache all this information since it requires a fair
 * amount of work to get.
 */
void
RelationGetExclusionInfo(Relation indexRelation,
       Oid **operators,
       Oid **procs,
       uint16 **strategies)
{
 int   indnkeyatts;
 Oid     *ops;
 Oid     *funcs;
 uint16    *strats;
 Relation conrel;
 SysScanDesc conscan;
 ScanKeyData skey[1];
 HeapTuple htup;
 bool  found;
 MemoryContext oldcxt;
 int   i;

 indnkeyatts = IndexRelationGetNumberOfKeyAttributes(indexRelation);

 /* Allocate result space in caller context */
 *operators = ops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
 *procs = funcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
 *strategies = strats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);

 /* Quick exit if we have the data cached already */
 if (indexRelation->rd_exclstrats != NULL)
 {
  memcpy(ops, indexRelation->rd_exclops, sizeof(Oid) * indnkeyatts);
  memcpy(funcs, indexRelation->rd_exclprocs, sizeof(Oid) * indnkeyatts);
  memcpy(strats, indexRelation->rd_exclstrats, sizeof(uint16) * indnkeyatts);
  return;
 }

 /*
  * Search pg_constraint for the constraint associated with the index. To
  * make this not too painfully slow, we use the index on conrelid; that
  * will hold the parent relation's OID not the index's own OID.
  *
  * Note: if we wanted to rely on the constraint name matching the index's
  * name, we could just do a direct lookup using pg_constraint's unique
  * index.  For the moment it doesn't seem worth requiring that.
 */
 ScanKeyInit(&skey[0],
    Anum_pg_constraint_conrelid,
    BTEqualStrategyNumber, F_OIDEQ,
    ObjectIdGetDatum(indexRelation->rd_index->indrelid));

 conrel = table_open(ConstraintRelationId, AccessShareLock);
 conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
         NULL, 1, skey);
 found = false;

 while (HeapTupleIsValid(htup = systable_getnext(conscan)))
 {
  Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(htup);
  Datum  val;
  bool  isnull;
  ArrayType  *arr;
  int   nelem;

  /* We want the exclusion constraint owning the index */
  if ((conform->contype != CONSTRAINT_EXCLUSION &&
    !(conform->conperiod && (conform->contype == CONSTRAINT_PRIMARY
           || conform->contype == CONSTRAINT_UNIQUE))) ||
   conform->conindid != RelationGetRelid(indexRelation))
   continue;

  /* There should be only one */
  if (found)
   elog(ERROR, "unexpected exclusion constraint record found for rel %s",
     RelationGetRelationName(indexRelation));
  found = true;

  /* Extract the operator OIDS from conexclop */
  val = fastgetattr(htup,
        Anum_pg_constraint_conexclop,
        conrel->rd_att, &isnull);
  if (isnull)
   elog(ERROR, "null conexclop for rel %s",
     RelationGetRelationName(indexRelation));

  arr = DatumGetArrayTypeP(val); /* ensure not toasted */
  nelem = ARR_DIMS(arr)[0];
  if (ARR_NDIM(arr) != 1 ||
   nelem != indnkeyatts ||
   ARR_HASNULL(arr) ||
   ARR_ELEMTYPE(arr) != OIDOID)
   elog(ERROR, "conexclop is not a 1-D Oid array");

  memcpy(ops, ARR_DATA_PTR(arr), sizeof(Oid) * indnkeyatts);
 }

 systable_endscan(conscan);
 table_close(conrel, AccessShareLock);

 if (!found)
  elog(ERROR, "exclusion constraint record missing for rel %s",
    RelationGetRelationName(indexRelation));

 /* We need the func OIDs and strategy numbers too */
 for (i = 0; i < indnkeyatts; i++)
 {
  funcs[i] = get_opcode(ops[i]);
  strats[i] = get_op_opfamily_strategy(ops[i],
            indexRelation->rd_opfamily[i]);
  /* shouldn't fail, since it was checked at index creation */
  if (strats[i] == InvalidStrategy)
   elog(ERROR, "could not find strategy for operator %u in family %u",
     ops[i], indexRelation->rd_opfamily[i]);
 }

 /* Save a copy of the results in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(indexRelation->rd_indexcxt);
 indexRelation->rd_exclops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
 indexRelation->rd_exclprocs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
 indexRelation->rd_exclstrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
 memcpy(indexRelation->rd_exclops, ops, sizeof(Oid) * indnkeyatts);
 memcpy(indexRelation->rd_exclprocs, funcs, sizeof(Oid) * indnkeyatts);
 memcpy(indexRelation->rd_exclstrats, strats, sizeof(uint16) * indnkeyatts);
 MemoryContextSwitchTo(oldcxt);
}

/*
 * Get the publication information for the given relation.
 *
 * Traverse all the publications which the relation is in to get the
 * publication actions and validate:
 * 1. The row filter expressions for such publications if any. We consider the
 *    row filter expression as invalid if it references any column which is not
 *    part of REPLICA IDENTITY.
 * 2. The column list for such publication if any. We consider the column list
 *    invalid if REPLICA IDENTITY contains any column that is not part of it.
 * 3. The generated columns of the relation for such publications. We consider
 *    any reference of an unpublished generated column in REPLICA IDENTITY as
 *    invalid.
 *
 * To avoid fetching the publication information repeatedly, we cache the
 * publication actions, row filter validation information, column list
 * validation information, and generated column validation information.
 */
void
RelationBuildPublicationDesc(Relation relation, PublicationDesc *pubdesc)
{
 List    *puboids;
 ListCell   *lc;
 MemoryContext oldcxt;
 Oid   schemaid;
 List    *ancestors = NIL;
 Oid   relid = RelationGetRelid(relation);

 /*
  * If not publishable, it publishes no actions.  (pgoutput_change() will
  * ignore it.)
 */
 if (!is_publishable_relation(relation))
 {
  memset(pubdesc, 0, sizeof(PublicationDesc));
  pubdesc->rf_valid_for_update = true;
  pubdesc->rf_valid_for_delete = true;
  pubdesc->cols_valid_for_update = true;
  pubdesc->cols_valid_for_delete = true;
  pubdesc->gencols_valid_for_update = true;
  pubdesc->gencols_valid_for_delete = true;
  return;
 }

 if (relation->rd_pubdesc)
 {
  memcpy(pubdesc, relation->rd_pubdesc, sizeof(PublicationDesc));
  return;
 }

 memset(pubdesc, 0, sizeof(PublicationDesc));
 pubdesc->rf_valid_for_update = true;
 pubdesc->rf_valid_for_delete = true;
 pubdesc->cols_valid_for_update = true;
 pubdesc->cols_valid_for_delete = true;
 pubdesc->gencols_valid_for_update = true;
 pubdesc->gencols_valid_for_delete = true;

 /* Fetch the publication membership info. */
 puboids = GetRelationPublications(relid);
 schemaid = RelationGetNamespace(relation);
 puboids = list_concat_unique_oid(puboids, GetSchemaPublications(schemaid));

 if (relation->rd_rel->relispartition)
 {
  /* Add publications that the ancestors are in too. */
  ancestors = get_partition_ancestors(relid);

  foreach(lc, ancestors)
  {
   Oid   ancestor = lfirst_oid(lc);

   puboids = list_concat_unique_oid(puboids,
            GetRelationPublications(ancestor));
   schemaid = get_rel_namespace(ancestor);
   puboids = list_concat_unique_oid(puboids,
            GetSchemaPublications(schemaid));
  }
 }
 puboids = list_concat_unique_oid(puboids, GetAllTablesPublications());

 foreach(lc, puboids)
 {
  Oid   pubid = lfirst_oid(lc);
  HeapTuple tup;
  Form_pg_publication pubform;
  bool  invalid_column_list;
  bool  invalid_gen_col;

  tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));

  if (!HeapTupleIsValid(tup))
   elog(ERROR, "cache lookup failed for publication %u", pubid);

  pubform = (Form_pg_publication) GETSTRUCT(tup);

  pubdesc->pubactions.pubinsert |= pubform->pubinsert;
  pubdesc->pubactions.pubupdate |= pubform->pubupdate;
  pubdesc->pubactions.pubdelete |= pubform->pubdelete;
  pubdesc->pubactions.pubtruncate |= pubform->pubtruncate;

  /*
   * Check if all columns referenced in the filter expression are part
   * of the REPLICA IDENTITY index or not.
   *
   * If the publication is FOR ALL TABLES then it means the table has no
   * row filters and we can skip the validation.
 */
  if (!pubform->puballtables &&
   (pubform->pubupdate || pubform->pubdelete) &&
   pub_rf_contains_invalid_column(pubid, relation, ancestors,
             pubform->pubviaroot))
  {
   if (pubform->pubupdate)
    pubdesc->rf_valid_for_update = false;
   if (pubform->pubdelete)
    pubdesc->rf_valid_for_delete = false;
  }

  /*
   * Check if all columns are part of the REPLICA IDENTITY index or not.
   *
   * Check if all generated columns included in the REPLICA IDENTITY are
   * published.
 */
  if ((pubform->pubupdate || pubform->pubdelete) &&
   pub_contains_invalid_column(pubid, relation, ancestors,
          pubform->pubviaroot,
          pubform->pubgencols,
          &invalid_column_list,
          &invalid_gen_col))
  {
   if (pubform->pubupdate)
   {
    pubdesc->cols_valid_for_update = !invalid_column_list;
    pubdesc->gencols_valid_for_update = !invalid_gen_col;
   }

   if (pubform->pubdelete)
   {
    pubdesc->cols_valid_for_delete = !invalid_column_list;
    pubdesc->gencols_valid_for_delete = !invalid_gen_col;
   }
  }

  ReleaseSysCache(tup);

  /*
   * If we know everything is replicated and the row filter is invalid
   * for update and delete, there is no point to check for other
   * publications.
 */
  if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
   pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
   !pubdesc->rf_valid_for_update && !pubdesc->rf_valid_for_delete)
   break;

  /*
   * If we know everything is replicated and the column list is invalid
   * for update and delete, there is no point to check for other
   * publications.
 */
  if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
   pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
   !pubdesc->cols_valid_for_update && !pubdesc->cols_valid_for_delete)
   break;

  /*
   * If we know everything is replicated and replica identity has an
   * unpublished generated column, there is no point to check for other
   * publications.
 */
  if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
   pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
   !pubdesc->gencols_valid_for_update &&
   !pubdesc->gencols_valid_for_delete)
   break;
 }

 if (relation->rd_pubdesc)
 {
  pfree(relation->rd_pubdesc);
  relation->rd_pubdesc = NULL;
 }

 /* Now save copy of the descriptor in the relcache entry. */
 oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 relation->rd_pubdesc = palloc(sizeof(PublicationDesc));
 memcpy(relation->rd_pubdesc, pubdesc, sizeof(PublicationDesc));
 MemoryContextSwitchTo(oldcxt);
}

static bytea **
CopyIndexAttOptions(bytea **srcopts, int natts)
{
 bytea   **opts = palloc(sizeof(*opts) * natts);

 for (int i = 0; i < natts; i++)
 {
  bytea    *opt = srcopts[i];

  opts[i] = !opt ? NULL : (bytea *)
   DatumGetPointer(datumCopy(PointerGetDatum(opt), false, -1));
 }

 return opts;
}

/*
 * RelationGetIndexAttOptions
 *  get AM/opclass-specific options for an index parsed into a binary form
 */
bytea   **
RelationGetIndexAttOptions(Relation relation, bool copy)
{
 MemoryContext oldcxt;
 bytea   **opts = relation->rd_opcoptions;
 Oid   relid = RelationGetRelid(relation);
 int   natts = RelationGetNumberOfAttributes(relation); /* XXX
 * IndexRelationGetNumberOfKeyAttributes */
 int   i;

 /* Try to copy cached options. */
 if (opts)
  return copy ? CopyIndexAttOptions(opts, natts) : opts;

 /* Get and parse opclass options. */
 opts = palloc0(sizeof(*opts) * natts);

 for (i = 0; i < natts; i++)
 {
  if (criticalRelcachesBuilt && relid != AttributeRelidNumIndexId)
  {
   Datum  attoptions = get_attoptions(relid, i + 1);

   opts[i] = index_opclass_options(relation, i + 1, attoptions, false);

   if (attoptions != (Datum) 0)
    pfree(DatumGetPointer(attoptions));
  }
 }

 /* Copy parsed options to the cache. */
 oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
 relation->rd_opcoptions = CopyIndexAttOptions(opts, natts);
 MemoryContextSwitchTo(oldcxt);

 if (copy)
  return opts;

 for (i = 0; i < natts; i++)
 {
  if (opts[i])
   pfree(opts[i]);
 }

 pfree(opts);

 return relation->rd_opcoptions;
}

/*
 * Routines to support ereport() reports of relation-related errors
 *
 * These could have been put into elog.c, but it seems like a module layering
 * violation to have elog.c calling relcache or syscache stuff --- and we
 * definitely don't want elog.h including rel.h.  So we put them here.
 */

/*
 * errtable --- stores schema_name and table_name of a table
 * within the current errordata.
 */
int
errtable(Relation rel)
{
 err_generic_string(PG_DIAG_SCHEMA_NAME,
        get_namespace_name(RelationGetNamespace(rel)));
 err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));

 return 0;     /* return value does not matter */
}

/*
 * errtablecol --- stores schema_name, table_name and column_name
 * of a table column within the current errordata.
 *
 * The column is specified by attribute number --- for most callers, this is
 * easier and less error-prone than getting the column name for themselves.
 */
int
errtablecol(Relation rel, int attnum)
{
 TupleDesc reldesc = RelationGetDescr(rel);
 const char *colname;

 /* Use reldesc if it's a user attribute, else consult the catalogs */
 if (attnum > 0 && attnum <= reldesc->natts)
  colname = NameStr(TupleDescAttr(reldesc, attnum - 1)->attname);
 else
  colname = get_attname(RelationGetRelid(rel), attnum, false);

 return errtablecolname(rel, colname);
}

/*
 * errtablecolname --- stores schema_name, table_name and column_name
 * of a table column within the current errordata, where the column name is
 * given directly rather than extracted from the relation's catalog data.
 *
 * Don't use this directly unless errtablecol() is inconvenient for some
 * reason.  This might possibly be needed during intermediate states in ALTER
 * TABLE, for instance.
 */
int
errtablecolname(Relation rel, const char *colname)
{
 errtable(rel);
 err_generic_string(PG_DIAG_COLUMN_NAME, colname);

 return 0;     /* return value does not matter */
}

/*
 * errtableconstraint --- stores schema_name, table_name and constraint_name
 * of a table-related constraint within the current errordata.
 */
int
errtableconstraint(Relation rel, const char *conname)
{
 errtable(rel);
 err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);

 return 0;     /* return value does not matter */
}


/*
 * load_relcache_init_file, write_relcache_init_file
 *
 *  In late 1992, we started regularly having databases with more than
 *  a thousand classes in them.  With this number of classes, it became
 *  critical to do indexed lookups on the system catalogs.
 *
 *  Bootstrapping these lookups is very hard.  We want to be able to
 *  use an index on pg_attribute, for example, but in order to do so,
 *  we must have read pg_attribute for the attributes in the index,
 *  which implies that we need to use the index.
 *
 *  In order to get around the problem, we do the following:
 *
 *     +  When the database system is initialized (at initdb time), we
 *     don't use indexes.  We do sequential scans.
 *
 *     +  When the backend is started up in normal mode, we load an image
 *     of the appropriate relation descriptors, in internal format,
 *     from an initialization file in the data/base/... directory.
 *
 *     +  If the initialization file isn't there, then we create the
 *     relation descriptors using sequential scans and write 'em to
 *     the initialization file for use by subsequent backends.
 *
 *  As of Postgres 9.0, there is one local initialization file in each
 *  database, plus one shared initialization file for shared catalogs.
 *
 *  We could dispense with the initialization files and just build the
 *  critical reldescs the hard way on every backend startup, but that
 *  slows down backend startup noticeably.
 *
 *  We can in fact go further, and save more relcache entries than
 *  just the ones that are absolutely critical; this allows us to speed
 *  up backend startup by not having to build such entries the hard way.
 *  Presently, all the catalog and index entries that are referred to
 *  by catcaches are stored in the initialization files.
 *
 *  The same mechanism that detects when catcache and relcache entries
 *  need to be invalidated (due to catalog updates) also arranges to
 *  unlink the initialization files when the contents may be out of date.
 *  The files will then be rebuilt during the next backend startup.
 */

/*
 * load_relcache_init_file -- attempt to load cache from the shared
 * or local cache init file
 *
 * If successful, return true and set criticalRelcachesBuilt or
 * criticalSharedRelcachesBuilt to true.
 * If not successful, return false.
 *
 * NOTE: we assume we are already switched into CacheMemoryContext.
 */
static bool
load_relcache_init_file(bool shared)
{
 FILE    *fp;
 char  initfilename[MAXPGPATH];
 Relation   *rels;
 int   relno,
    num_rels,
    max_rels,
    nailed_rels,
    nailed_indexes,
    magic;
 int   i;

 if (shared)
  snprintf(initfilename, sizeof(initfilename), "global/%s",
     RELCACHE_INIT_FILENAME);
 else
  snprintf(initfilename, sizeof(initfilename), "%s/%s",
     DatabasePath, RELCACHE_INIT_FILENAME);

 fp = AllocateFile(initfilename, PG_BINARY_R);
 if (fp == NULL)
  return false;

 /*
  * Read the index relcache entries from the file.  Note we will not enter
  * any of them into the cache if the read fails partway through; this
  * helps to guard against broken init files.
  */
 max_rels = 100;
 rels = (Relation *) palloc(max_rels * sizeof(Relation));
 num_rels = 0;
 nailed_rels = nailed_indexes = 0;

 /* check for correct magic number (compatible version) */
 if (fread(&magic, 1, sizeof(magic), fp) != sizeof(magic))
  goto read_failed;
 if (magic != RELCACHE_INIT_FILEMAGIC)
  goto read_failed;

 for (relno = 0;; relno++)
 {
  Size  len;
  size_t  nread;
  Relation rel;
  Form_pg_class relform;
  bool  has_not_null;

  /* first read the relation descriptor length */
  nread = fread(&len, 1, sizeof(len), fp);
  if (nread != sizeof(len))
  {
   if (nread == 0)
    break;   /* end of file */
   goto read_failed;
  }

  /* safety check for incompatible relcache layout */
  if (len != sizeof(RelationData))
   goto read_failed;

  /* allocate another relcache header */
  if (num_rels >= max_rels)
  {
   max_rels *= 2;
   rels = (Relation *) repalloc(rels, max_rels * sizeof(Relation));
  }

  rel = rels[num_rels++] = (Relation) palloc(len);

  /* then, read the Relation structure */
  if (fread(rel, 1, len, fp) != len)
   goto read_failed;

  /* next read the relation tuple form */
  if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
   goto read_failed;

  relform = (Form_pg_class) palloc(len);
  if (fread(relform, 1, len, fp) != len)
   goto read_failed;

  rel->rd_rel = relform;

  /* initialize attribute tuple forms */
  rel->rd_att = CreateTemplateTupleDesc(relform->relnatts);
  rel->rd_att->tdrefcount = 1; /* mark as refcounted */

  rel->rd_att->tdtypeid = relform->reltype ? relform->reltype : RECORDOID;
  rel->rd_att->tdtypmod = -1; /* just to be sure */

  /* next read all the attribute tuple form data entries */
  has_not_null = false;
  for (i = 0; i < relform->relnatts; i++)
  {
   Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i);

   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;
   if (len != ATTRIBUTE_FIXED_PART_SIZE)
    goto read_failed;
   if (fread(attr, 1, len, fp) != len)
    goto read_failed;

   has_not_null |= attr->attnotnull;

   populate_compact_attribute(rel->rd_att, i);
  }

  /* next read the access method specific field */
  if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
   goto read_failed;
  if (len > 0)
  {
   rel->rd_options = palloc(len);
   if (fread(rel->rd_options, 1, len, fp) != len)
    goto read_failed;
   if (len != VARSIZE(rel->rd_options))
    goto read_failed; /* sanity check */
  }
  else
  {
   rel->rd_options = NULL;
  }

  /* mark not-null status */
  if (has_not_null)
  {
   TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));

   constr->has_not_null = true;
   rel->rd_att->constr = constr;
  }

  /*
   * If it's an index, there's more to do.  Note we explicitly ignore
   * partitioned indexes here.
   */
  if (rel->rd_rel->relkind == RELKIND_INDEX)
  {
   MemoryContext indexcxt;
   Oid     *opfamily;
   Oid     *opcintype;
   RegProcedure *support;
   int   nsupport;
   int16    *indoption;
   Oid     *indcollation;

   /* Count nailed indexes to ensure we have 'em all */
   if (rel->rd_isnailed)
    nailed_indexes++;

   /* read the pg_index tuple */
   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;

   rel->rd_indextuple = (HeapTuple) palloc(len);
   if (fread(rel->rd_indextuple, 1, len, fp) != len)
    goto read_failed;

   /* Fix up internal pointers in the tuple -- see heap_copytuple */
   rel->rd_indextuple->t_data = (HeapTupleHeader) ((char *) rel->rd_indextuple + HEAPTUPLESIZE);
   rel->rd_index = (Form_pg_index) GETSTRUCT(rel->rd_indextuple);

   /*
    * prepare index info context --- parameters should match
    * RelationInitIndexAccessInfo
    */
   indexcxt = AllocSetContextCreate(CacheMemoryContext,
            "index info",
            ALLOCSET_SMALL_SIZES);
   rel->rd_indexcxt = indexcxt;
   MemoryContextCopyAndSetIdentifier(indexcxt,
             RelationGetRelationName(rel));

   /*
    * Now we can fetch the index AM's API struct.  (We can't store
    * that in the init file, since it contains function pointers that
    * might vary across server executions.  Fortunately, it should be
    * safe to call the amhandler even while bootstrapping indexes.)
    */
   InitIndexAmRoutine(rel);

   /* read the vector of opfamily OIDs */
   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;

   opfamily = (Oid *) MemoryContextAlloc(indexcxt, len);
   if (fread(opfamily, 1, len, fp) != len)
    goto read_failed;

   rel->rd_opfamily = opfamily;

   /* read the vector of opcintype OIDs */
   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;

   opcintype = (Oid *) MemoryContextAlloc(indexcxt, len);
   if (fread(opcintype, 1, len, fp) != len)
    goto read_failed;

   rel->rd_opcintype = opcintype;

   /* read the vector of support procedure OIDs */
   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;
   support = (RegProcedure *) MemoryContextAlloc(indexcxt, len);
   if (fread(support, 1, len, fp) != len)
    goto read_failed;

   rel->rd_support = support;

   /* read the vector of collation OIDs */
   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;

   indcollation = (Oid *) MemoryContextAlloc(indexcxt, len);
   if (fread(indcollation, 1, len, fp) != len)
    goto read_failed;

   rel->rd_indcollation = indcollation;

   /* read the vector of indoption values */
   if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    goto read_failed;

   indoption = (int16 *) MemoryContextAlloc(indexcxt, len);
   if (fread(indoption, 1, len, fp) != len)
    goto read_failed;

   rel->rd_indoption = indoption;

   /* read the vector of opcoptions values */
   rel->rd_opcoptions = (bytea **)
    MemoryContextAllocZero(indexcxt, sizeof(*rel->rd_opcoptions) * relform->relnatts);

   for (i = 0; i < relform->relnatts; i++)
   {
    if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
     goto read_failed;

    if (len > 0)
    {
     rel->rd_opcoptions[i] = (bytea *) MemoryContextAlloc(indexcxt, len);
     if (fread(rel->rd_opcoptions[i], 1, len, fp) != len)
      goto read_failed;
    }
   }

   /* set up zeroed fmgr-info vector */
   nsupport = relform->relnatts * rel->rd_indam->amsupport;
   rel->rd_supportinfo = (FmgrInfo *)
    MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
  }
  else
  {
   /* Count nailed rels to ensure we have 'em all */
   if (rel->rd_isnailed)
    nailed_rels++;

   /* Load table AM data */
   if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind) || rel->rd_rel->relkind == RELKIND_SEQUENCE)
    RelationInitTableAccessMethod(rel);

   Assert(rel->rd_index == NULL);
   Assert(rel->rd_indextuple == NULL);
   Assert(rel->rd_indexcxt == NULL);
   Assert(rel->rd_indam == NULL);
   Assert(rel->rd_opfamily == NULL);
   Assert(rel->rd_opcintype == NULL);
   Assert(rel->rd_support == NULL);
   Assert(rel->rd_supportinfo == NULL);
   Assert(rel->rd_indoption == NULL);
   Assert(rel->rd_indcollation == NULL);
   Assert(rel->rd_opcoptions == NULL);
  }

  /*
   * Rules and triggers are not saved (mainly because the internal
   * format is complex and subject to change).  They must be rebuilt if
   * needed by RelationCacheInitializePhase3.  This is not expected to
   * be a big performance hit since few system catalogs have such. Ditto
   * for RLS policy data, partition info, index expressions, predicates,
   * exclusion info, and FDW info.
   */
  rel->rd_rules = NULL;
  rel->rd_rulescxt = NULL;
  rel->trigdesc = NULL;
  rel->rd_rsdesc = NULL;
  rel->rd_partkey = NULL;
  rel->rd_partkeycxt = NULL;
  rel->rd_partdesc = NULL;
  rel->rd_partdesc_nodetached = NULL;
  rel->rd_partdesc_nodetached_xmin = InvalidTransactionId;
  rel->rd_pdcxt = NULL;
  rel->rd_pddcxt = NULL;
  rel->rd_partcheck = NIL;
  rel->rd_partcheckvalid = false;
  rel->rd_partcheckcxt = NULL;
  rel->rd_indexprs = NIL;
  rel->rd_indpred = NIL;
  rel->rd_exclops = NULL;
  rel->rd_exclprocs = NULL;
  rel->rd_exclstrats = NULL;
  rel->rd_fdwroutine = NULL;

  /*
   * Reset transient-state fields in the relcache entry
   */
  rel->rd_smgr = NULL;
  if (rel->rd_isnailed)
   rel->rd_refcnt = 1;
  else
   rel->rd_refcnt = 0;
  rel->rd_indexvalid = false;
  rel->rd_indexlist = NIL;
  rel->rd_pkindex = InvalidOid;
  rel->rd_replidindex = InvalidOid;
  rel->rd_attrsvalid = false;
  rel->rd_keyattr = NULL;
  rel->rd_pkattr = NULL;
  rel->rd_idattr = NULL;
  rel->rd_pubdesc = NULL;
  rel->rd_statvalid = false;
  rel->rd_statlist = NIL;
  rel->rd_fkeyvalid = false;
  rel->rd_fkeylist = NIL;
  rel->rd_createSubid = InvalidSubTransactionId;
  rel->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
  rel->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
  rel->rd_droppedSubid = InvalidSubTransactionId;
  rel->rd_amcache = NULL;
  rel->pgstat_info = NULL;

  /*
   * Recompute lock and physical addressing info.  This is needed in
   * case the pg_internal.init file was copied from some other database
   * by CREATE DATABASE.
   */
  RelationInitLockInfo(rel);
  RelationInitPhysicalAddr(rel);
 }

 /*
  * We reached the end of the init file without apparent problem.  Did we
  * get the right number of nailed items?  This is a useful crosscheck in
  * case the set of critical rels or indexes changes.  However, that should
  * not happen in a normally-running system, so let's bleat if it does.
  *
  * For the shared init file, we're called before client authentication is
  * done, which means that elog(WARNING) will go only to the postmaster
  * log, where it's easily missed.  To ensure that developers notice bad
  * values of NUM_CRITICAL_SHARED_RELS/NUM_CRITICAL_SHARED_INDEXES, we put
  * an Assert(false) there.
  */
 if (shared)
 {
  if (nailed_rels != NUM_CRITICAL_SHARED_RELS ||
   nailed_indexes != NUM_CRITICAL_SHARED_INDEXES)
  {
   elog(WARNING, "found %d nailed shared rels and %d nailed shared indexes in init file, but expected %d and %d respectively",
     nailed_rels, nailed_indexes,
     NUM_CRITICAL_SHARED_RELS, NUM_CRITICAL_SHARED_INDEXES);
   /* Make sure we get developers' attention about this */
   Assert(false);
   /* In production builds, recover by bootstrapping the relcache */
   goto read_failed;
  }
 }
 else
 {
  if (nailed_rels != NUM_CRITICAL_LOCAL_RELS ||
   nailed_indexes != NUM_CRITICAL_LOCAL_INDEXES)
  {
   elog(WARNING, "found %d nailed rels and %d nailed indexes in init file, but expected %d and %d respectively",
     nailed_rels, nailed_indexes,
     NUM_CRITICAL_LOCAL_RELS, NUM_CRITICAL_LOCAL_INDEXES);
   /* We don't need an Assert() in this case */
   goto read_failed;
  }
 }

 /*
  * OK, all appears well.
  *
  * Now insert all the new relcache entries into the cache.
  */
 for (relno = 0; relno < num_rels; relno++)
 {
  RelationCacheInsert(rels[relno], false);
 }

 pfree(rels);
 FreeFile(fp);

 if (shared)
  criticalSharedRelcachesBuilt = true;
 else
  criticalRelcachesBuilt = true;
 return true;

 /*
  * init file is broken, so do it the hard way.  We don't bother trying to
  * free the clutter we just allocated; it's not in the relcache so it
  * won't hurt.
  */
read_failed:
 pfree(rels);
 FreeFile(fp);

 return false;
}

/*
 * Write out a new initialization file with the current contents
 * of the relcache (either shared rels or local rels, as indicated).
 */
static void
write_relcache_init_file(bool shared)
{
 FILE    *fp;
 char  tempfilename[MAXPGPATH];
 char  finalfilename[MAXPGPATH];
 int   magic;
 HASH_SEQ_STATUS status;
 RelIdCacheEnt *idhentry;
 int   i;

 /*
  * If we have already received any relcache inval events, there's no
  * chance of succeeding so we may as well skip the whole thing.
  */
 if (relcacheInvalsReceived != 0L)
  return;

 /*
  * We must write a temporary file and rename it into place. Otherwise,
  * another backend starting at about the same time might crash trying to
  * read the partially-complete file.
  */
 if (shared)
 {
  snprintf(tempfilename, sizeof(tempfilename), "global/%s.%d",
     RELCACHE_INIT_FILENAME, MyProcPid);
  snprintf(finalfilename, sizeof(finalfilename), "global/%s",
     RELCACHE_INIT_FILENAME);
 }
 else
 {
  snprintf(tempfilename, sizeof(tempfilename), "%s/%s.%d",
     DatabasePath, RELCACHE_INIT_FILENAME, MyProcPid);
  snprintf(finalfilename, sizeof(finalfilename), "%s/%s",
     DatabasePath, RELCACHE_INIT_FILENAME);
 }

 unlink(tempfilename);  /* in case it exists w/wrong permissions */

 fp = AllocateFile(tempfilename, PG_BINARY_W);
 if (fp == NULL)
 {
  /*
   * We used to consider this a fatal error, but we might as well
   * continue with backend startup ...
   */
  ereport(WARNING,
    (errcode_for_file_access(),
     errmsg("could not create relation-cache initialization file \"%s\": %m",
      tempfilename),
     errdetail("Continuing anyway, but there's something wrong.")));
  return;
 }

 /*
  * Write a magic number to serve as a file version identifier.  We can
  * change the magic number whenever the relcache layout changes.
  */
 magic = RELCACHE_INIT_FILEMAGIC;
 if (fwrite(&magic, 1, sizeof(magic), fp) != sizeof(magic))
  ereport(FATAL,
    errcode_for_file_access(),
    errmsg_internal("could not write init file: %m"));

 /*
  * Write all the appropriate reldescs (in no particular order).
  */
 hash_seq_init(&status, RelationIdCache);

 while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
 {
  Relation rel = idhentry->reldesc;
  Form_pg_class relform = rel->rd_rel;

  /* ignore if not correct group */
  if (relform->relisshared != shared)
   continue;

  /*
   * Ignore if not supposed to be in init file.  We can allow any shared
   * relation that's been loaded so far to be in the shared init file,
   * but unshared relations must be ones that should be in the local
   * file per RelationIdIsInInitFile.  (Note: if you want to change the
   * criterion for rels to be kept in the init file, see also inval.c.
   * The reason for filtering here is to be sure that we don't put
   * anything into the local init file for which a relcache inval would
   * not cause invalidation of that init file.)
   */
  if (!shared && !RelationIdIsInInitFile(RelationGetRelid(rel)))
  {
   /* Nailed rels had better get stored. */
   Assert(!rel->rd_isnailed);
   continue;
  }

  /* first write the relcache entry proper */
  write_item(rel, sizeof(RelationData), fp);

  /* next write the relation tuple form */
  write_item(relform, CLASS_TUPLE_SIZE, fp);

  /* next, do all the attribute tuple form data entries */
  for (i = 0; i < relform->relnatts; i++)
  {
   write_item(TupleDescAttr(rel->rd_att, i),
        ATTRIBUTE_FIXED_PART_SIZE, fp);
  }

  /* next, do the access method specific field */
  write_item(rel->rd_options,
       (rel->rd_options ? VARSIZE(rel->rd_options) : 0),
       fp);

  /*
   * If it's an index, there's more to do. Note we explicitly ignore
   * partitioned indexes here.
   */
  if (rel->rd_rel->relkind == RELKIND_INDEX)
  {
   /* write the pg_index tuple */
   /* we assume this was created by heap_copytuple! */
   write_item(rel->rd_indextuple,
        HEAPTUPLESIZE + rel->rd_indextuple->t_len,
        fp);

   /* write the vector of opfamily OIDs */
   write_item(rel->rd_opfamily,
        relform->relnatts * sizeof(Oid),
        fp);

   /* write the vector of opcintype OIDs */
   write_item(rel->rd_opcintype,
        relform->relnatts * sizeof(Oid),
        fp);

   /* write the vector of support procedure OIDs */
   write_item(rel->rd_support,
        relform->relnatts * (rel->rd_indam->amsupport * sizeof(RegProcedure)),
        fp);

   /* write the vector of collation OIDs */
   write_item(rel->rd_indcollation,
        relform->relnatts * sizeof(Oid),
        fp);

   /* write the vector of indoption values */
   write_item(rel->rd_indoption,
        relform->relnatts * sizeof(int16),
        fp);

   Assert(rel->rd_opcoptions);

   /* write the vector of opcoptions values */
   for (i = 0; i < relform->relnatts; i++)
   {
    bytea    *opt = rel->rd_opcoptions[i];

    write_item(opt, opt ? VARSIZE(opt) : 0, fp);
   }
  }
 }

 if (FreeFile(fp))
  ereport(FATAL,
    errcode_for_file_access(),
    errmsg_internal("could not write init file: %m"));

 /*
  * Now we have to check whether the data we've so painstakingly
  * accumulated is already obsolete due to someone else's just-committed
  * catalog changes.  If so, we just delete the temp file and leave it to
  * the next backend to try again.  (Our own relcache entries will be
  * updated by SI message processing, but we can't be sure whether what we
  * wrote out was up-to-date.)
  *
  * This mustn't run concurrently with the code that unlinks an init file
  * and sends SI messages, so grab a serialization lock for the duration.
  */
 LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE);

 /* Make sure we have seen all incoming SI messages */
 AcceptInvalidationMessages();

 /*
  * If we have received any SI relcache invals since backend start, assume
  * we may have written out-of-date data.
  */
 if (relcacheInvalsReceived == 0L)
 {
  /*
   * OK, rename the temp file to its final name, deleting any
   * previously-existing init file.
   *
   * Note: a failure here is possible under Cygwin, if some other
   * backend is holding open an unlinked-but-not-yet-gone init file. So
   * treat this as a noncritical failure; just remove the useless temp
   * file on failure.
   */
  if (rename(tempfilename, finalfilename) < 0)
   unlink(tempfilename);
 }
 else
 {
  /* Delete the already-obsolete temp file */
  unlink(tempfilename);
 }

 LWLockRelease(RelCacheInitLock);
}

/* write a chunk of data preceded by its length */
static void
write_item(const void *data, Size len, FILE *fp)
{
 if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len))
  ereport(FATAL,
    errcode_for_file_access(),
    errmsg_internal("could not write init file: %m"));
 if (len > 0 && fwrite(data, 1, len, fp) != len)
  ereport(FATAL,
    errcode_for_file_access(),
    errmsg_internal("could not write init file: %m"));
}

/*
 * Determine whether a given relation (identified by OID) is one of the ones
 * we should store in a relcache init file.
 *
 * We must cache all nailed rels, and for efficiency we should cache every rel
 * that supports a syscache.  The former set is almost but not quite a subset
 * of the latter. The special cases are relations where
 * RelationCacheInitializePhase2/3 chooses to nail for efficiency reasons, but
 * which do not support any syscache.
 */
bool
RelationIdIsInInitFile(Oid relationId)
{
 if (relationId == SharedSecLabelRelationId ||
  relationId == TriggerRelidNameIndexId ||
  relationId == DatabaseNameIndexId ||
  relationId == SharedSecLabelObjectIndexId)
 {
  /*
   * If this Assert fails, we don't need the applicable special case
   * anymore.
   */
  Assert(!RelationSupportsSysCache(relationId));
  return true;
 }
 return RelationSupportsSysCache(relationId);
}

/*
 * Invalidate (remove) the init file during commit of a transaction that
 * changed one or more of the relation cache entries that are kept in the
 * local init file.
 *
 * To be safe against concurrent inspection or rewriting of the init file,
 * we must take RelCacheInitLock, then remove the old init file, then send
 * the SI messages that include relcache inval for such relations, and then
 * release RelCacheInitLock.  This serializes the whole affair against
 * write_relcache_init_file, so that we can be sure that any other process
 * that's concurrently trying to create a new init file won't move an
 * already-stale version into place after we unlink.  Also, because we unlink
 * before sending the SI messages, a backend that's currently starting cannot
 * read the now-obsolete init file and then miss the SI messages that will
 * force it to update its relcache entries.  (This works because the backend
 * startup sequence gets into the sinval array before trying to load the init
 * file.)
 *
 * We take the lock and do the unlink in RelationCacheInitFilePreInvalidate,
 * then release the lock in RelationCacheInitFilePostInvalidate.  Caller must
 * send any pending SI messages between those calls.
 */
void
RelationCacheInitFilePreInvalidate(void)
{
 char  localinitfname[MAXPGPATH];
 char  sharedinitfname[MAXPGPATH];

 if (DatabasePath)
  snprintf(localinitfname, sizeof(localinitfname), "%s/%s",
     DatabasePath, RELCACHE_INIT_FILENAME);
 snprintf(sharedinitfname, sizeof(sharedinitfname), "global/%s",
    RELCACHE_INIT_FILENAME);

 LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE);

 /*
  * The files might not be there if no backend has been started since the
  * last removal.  But complain about failures other than ENOENT with
  * ERROR.  Fortunately, it's not too late to abort the transaction if we
  * can't get rid of the would-be-obsolete init file.
  */
 if (DatabasePath)
  unlink_initfile(localinitfname, ERROR);
 unlink_initfile(sharedinitfname, ERROR);
}

void
RelationCacheInitFilePostInvalidate(void)
{
 LWLockRelease(RelCacheInitLock);
}

/*
 * Remove the init files during postmaster startup.
 *
 * We used to keep the init files across restarts, but that is unsafe in PITR
 * scenarios, and even in simple crash-recovery cases there are windows for
 * the init files to become out-of-sync with the database.  So now we just
 * remove them during startup and expect the first backend launch to rebuild
 * them.  Of course, this has to happen in each database of the cluster.
 */
void
RelationCacheInitFileRemove(void)
{
 const char *tblspcdir = PG_TBLSPC_DIR;
 DIR     *dir;
 struct dirent *de;
 char  path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)];

 snprintf(path, sizeof(path), "global/%s",
    RELCACHE_INIT_FILENAME);
 unlink_initfile(path, LOG);

 /* Scan everything in the default tablespace */
 RelationCacheInitFileRemoveInDir("base");

 /* Scan the tablespace link directory to find non-default tablespaces */
 dir = AllocateDir(tblspcdir);

 while ((de = ReadDirExtended(dir, tblspcdir, LOG)) != NULL)
 {
  if (strspn(de->d_name, "0123456789") == strlen(de->d_name))
  {
   /* Scan the tablespace dir for per-database dirs */
   snprintf(path, sizeof(path), "%s/%s/%s",
      tblspcdir, de->d_name, TABLESPACE_VERSION_DIRECTORY);
   RelationCacheInitFileRemoveInDir(path);
  }
 }

 FreeDir(dir);
}

/* Process one per-tablespace directory for RelationCacheInitFileRemove */
static void
RelationCacheInitFileRemoveInDir(const char *tblspcpath)
{
 DIR     *dir;
 struct dirent *de;
 char  initfilename[MAXPGPATH * 2];

 /* Scan the tablespace directory to find per-database directories */
 dir = AllocateDir(tblspcpath);

 while ((de = ReadDirExtended(dir, tblspcpath, LOG)) != NULL)
 {
  if (strspn(de->d_name, "0123456789") == strlen(de->d_name))
  {
   /* Try to remove the init file in each database */
   snprintf(initfilename, sizeof(initfilename), "%s/%s/%s",
      tblspcpath, de->d_name, RELCACHE_INIT_FILENAME);
   unlink_initfile(initfilename, LOG);
  }
 }

 FreeDir(dir);
}

static void
unlink_initfile(const char *initfilename, int elevel)
{
 if (unlink(initfilename) < 0)
 {
  /* It might not be there, but log any error other than ENOENT */
  if (errno != ENOENT)
   ereport(elevel,
     (errcode_for_file_access(),
      errmsg("could not remove cache file \"%s\": %m",
       initfilename)));
 }
}

/*
 * ResourceOwner callbacks
 */
static char *
ResOwnerPrintRelCache(Datum res)
{
 Relation rel = (Relation) DatumGetPointer(res);

 return psprintf("relation \"%s\"", RelationGetRelationName(rel));
}

static void
ResOwnerReleaseRelation(Datum res)
{
 Relation rel = (Relation) DatumGetPointer(res);

 /*
  * This reference has already been removed from the resource owner, so
  * just decrement reference count without calling
  * ResourceOwnerForgetRelationRef.
  */
 Assert(rel->rd_refcnt > 0);
 rel->rd_refcnt -= 1;

 RelationCloseCleanup((Relation) res);
}