LCOV - code coverage report
Current view: top level - src/backend/utils/cache - relcache.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18beta1 Lines: 1889 2052 92.1 %
Date: 2025-05-15 19:15:43 Functions: 81 82 98.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * relcache.c
       4             :  *    POSTGRES relation descriptor cache code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/utils/cache/relcache.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : /*
      16             :  * INTERFACE ROUTINES
      17             :  *      RelationCacheInitialize         - initialize relcache (to empty)
      18             :  *      RelationCacheInitializePhase2   - initialize shared-catalog entries
      19             :  *      RelationCacheInitializePhase3   - finish initializing relcache
      20             :  *      RelationIdGetRelation           - get a reldesc by relation id
      21             :  *      RelationClose                   - close an open relation
      22             :  *
      23             :  * NOTES
      24             :  *      The following code contains many undocumented hacks.  Please be
      25             :  *      careful....
      26             :  */
      27             : #include "postgres.h"
      28             : 
      29             : #include <sys/file.h>
      30             : #include <fcntl.h>
      31             : #include <unistd.h>
      32             : 
      33             : #include "access/htup_details.h"
      34             : #include "access/multixact.h"
      35             : #include "access/parallel.h"
      36             : #include "access/reloptions.h"
      37             : #include "access/sysattr.h"
      38             : #include "access/table.h"
      39             : #include "access/tableam.h"
      40             : #include "access/tupdesc_details.h"
      41             : #include "access/xact.h"
      42             : #include "catalog/binary_upgrade.h"
      43             : #include "catalog/catalog.h"
      44             : #include "catalog/indexing.h"
      45             : #include "catalog/namespace.h"
      46             : #include "catalog/partition.h"
      47             : #include "catalog/pg_am.h"
      48             : #include "catalog/pg_amproc.h"
      49             : #include "catalog/pg_attrdef.h"
      50             : #include "catalog/pg_auth_members.h"
      51             : #include "catalog/pg_authid.h"
      52             : #include "catalog/pg_constraint.h"
      53             : #include "catalog/pg_database.h"
      54             : #include "catalog/pg_namespace.h"
      55             : #include "catalog/pg_opclass.h"
      56             : #include "catalog/pg_proc.h"
      57             : #include "catalog/pg_publication.h"
      58             : #include "catalog/pg_rewrite.h"
      59             : #include "catalog/pg_shseclabel.h"
      60             : #include "catalog/pg_statistic_ext.h"
      61             : #include "catalog/pg_subscription.h"
      62             : #include "catalog/pg_tablespace.h"
      63             : #include "catalog/pg_trigger.h"
      64             : #include "catalog/pg_type.h"
      65             : #include "catalog/schemapg.h"
      66             : #include "catalog/storage.h"
      67             : #include "commands/policy.h"
      68             : #include "commands/publicationcmds.h"
      69             : #include "commands/trigger.h"
      70             : #include "common/int.h"
      71             : #include "miscadmin.h"
      72             : #include "nodes/makefuncs.h"
      73             : #include "nodes/nodeFuncs.h"
      74             : #include "optimizer/optimizer.h"
      75             : #include "pgstat.h"
      76             : #include "rewrite/rewriteDefine.h"
      77             : #include "rewrite/rowsecurity.h"
      78             : #include "storage/lmgr.h"
      79             : #include "storage/smgr.h"
      80             : #include "utils/array.h"
      81             : #include "utils/builtins.h"
      82             : #include "utils/catcache.h"
      83             : #include "utils/datum.h"
      84             : #include "utils/fmgroids.h"
      85             : #include "utils/inval.h"
      86             : #include "utils/lsyscache.h"
      87             : #include "utils/memutils.h"
      88             : #include "utils/relmapper.h"
      89             : #include "utils/resowner.h"
      90             : #include "utils/snapmgr.h"
      91             : #include "utils/syscache.h"
      92             : 
      93             : #define RELCACHE_INIT_FILEMAGIC     0x573266    /* version ID value */
      94             : 
      95             : /*
      96             :  * Whether to bother checking if relation cache memory needs to be freed
      97             :  * eagerly.  See also RelationBuildDesc() and pg_config_manual.h.
      98             :  */
      99             : #if defined(RECOVER_RELATION_BUILD_MEMORY) && (RECOVER_RELATION_BUILD_MEMORY != 0)
     100             : #define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
     101             : #else
     102             : #define RECOVER_RELATION_BUILD_MEMORY 0
     103             : #ifdef DISCARD_CACHES_ENABLED
     104             : #define MAYBE_RECOVER_RELATION_BUILD_MEMORY 1
     105             : #endif
     106             : #endif
     107             : 
     108             : /*
     109             :  *      hardcoded tuple descriptors, contents generated by genbki.pl
     110             :  */
     111             : static const FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
     112             : static const FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
     113             : static const FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
     114             : static const FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
     115             : static const FormData_pg_attribute Desc_pg_database[Natts_pg_database] = {Schema_pg_database};
     116             : static const FormData_pg_attribute Desc_pg_authid[Natts_pg_authid] = {Schema_pg_authid};
     117             : static const FormData_pg_attribute Desc_pg_auth_members[Natts_pg_auth_members] = {Schema_pg_auth_members};
     118             : static const FormData_pg_attribute Desc_pg_index[Natts_pg_index] = {Schema_pg_index};
     119             : static const FormData_pg_attribute Desc_pg_shseclabel[Natts_pg_shseclabel] = {Schema_pg_shseclabel};
     120             : static const FormData_pg_attribute Desc_pg_subscription[Natts_pg_subscription] = {Schema_pg_subscription};
     121             : 
     122             : /*
     123             :  *      Hash tables that index the relation cache
     124             :  *
     125             :  *      We used to index the cache by both name and OID, but now there
     126             :  *      is only an index by OID.
     127             :  */
     128             : typedef struct relidcacheent
     129             : {
     130             :     Oid         reloid;
     131             :     Relation    reldesc;
     132             : } RelIdCacheEnt;
     133             : 
     134             : static HTAB *RelationIdCache;
     135             : 
     136             : /*
     137             :  * This flag is false until we have prepared the critical relcache entries
     138             :  * that are needed to do indexscans on the tables read by relcache building.
     139             :  */
     140             : bool        criticalRelcachesBuilt = false;
     141             : 
     142             : /*
     143             :  * This flag is false until we have prepared the critical relcache entries
     144             :  * for shared catalogs (which are the tables needed for login).
     145             :  */
     146             : bool        criticalSharedRelcachesBuilt = false;
     147             : 
     148             : /*
     149             :  * This counter counts relcache inval events received since backend startup
     150             :  * (but only for rels that are actually in cache).  Presently, we use it only
     151             :  * to detect whether data about to be written by write_relcache_init_file()
     152             :  * might already be obsolete.
     153             :  */
     154             : static long relcacheInvalsReceived = 0L;
     155             : 
     156             : /*
     157             :  * in_progress_list is a stack of ongoing RelationBuildDesc() calls.  CREATE
     158             :  * INDEX CONCURRENTLY makes catalog changes under ShareUpdateExclusiveLock.
     159             :  * It critically relies on each backend absorbing those changes no later than
     160             :  * next transaction start.  Hence, RelationBuildDesc() loops until it finishes
     161             :  * without accepting a relevant invalidation.  (Most invalidation consumers
     162             :  * don't do this.)
     163             :  */
     164             : typedef struct inprogressent
     165             : {
     166             :     Oid         reloid;         /* OID of relation being built */
     167             :     bool        invalidated;    /* whether an invalidation arrived for it */
     168             : } InProgressEnt;
     169             : 
     170             : static InProgressEnt *in_progress_list;
     171             : static int  in_progress_list_len;
     172             : static int  in_progress_list_maxlen;
     173             : 
     174             : /*
     175             :  * eoxact_list[] stores the OIDs of relations that (might) need AtEOXact
     176             :  * cleanup work.  This list intentionally has limited size; if it overflows,
     177             :  * we fall back to scanning the whole hashtable.  There is no value in a very
     178             :  * large list because (1) at some point, a hash_seq_search scan is faster than
     179             :  * retail lookups, and (2) the value of this is to reduce EOXact work for
     180             :  * short transactions, which can't have dirtied all that many tables anyway.
     181             :  * EOXactListAdd() does not bother to prevent duplicate list entries, so the
     182             :  * cleanup processing must be idempotent.
     183             :  */
     184             : #define MAX_EOXACT_LIST 32
     185             : static Oid  eoxact_list[MAX_EOXACT_LIST];
     186             : static int  eoxact_list_len = 0;
     187             : static bool eoxact_list_overflowed = false;
     188             : 
     189             : #define EOXactListAdd(rel) \
     190             :     do { \
     191             :         if (eoxact_list_len < MAX_EOXACT_LIST) \
     192             :             eoxact_list[eoxact_list_len++] = (rel)->rd_id; \
     193             :         else \
     194             :             eoxact_list_overflowed = true; \
     195             :     } while (0)
     196             : 
     197             : /*
     198             :  * EOXactTupleDescArray stores TupleDescs that (might) need AtEOXact
     199             :  * cleanup work.  The array expands as needed; there is no hashtable because
     200             :  * we don't need to access individual items except at EOXact.
     201             :  */
     202             : static TupleDesc *EOXactTupleDescArray;
     203             : static int  NextEOXactTupleDescNum = 0;
     204             : static int  EOXactTupleDescArrayLen = 0;
     205             : 
     206             : /*
     207             :  *      macros to manipulate the lookup hashtable
     208             :  */
     209             : #define RelationCacheInsert(RELATION, replace_allowed)  \
     210             : do { \
     211             :     RelIdCacheEnt *hentry; bool found; \
     212             :     hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
     213             :                                            &((RELATION)->rd_id), \
     214             :                                            HASH_ENTER, &found); \
     215             :     if (found) \
     216             :     { \
     217             :         /* see comments in RelationBuildDesc and RelationBuildLocalRelation */ \
     218             :         Relation _old_rel = hentry->reldesc; \
     219             :         Assert(replace_allowed); \
     220             :         hentry->reldesc = (RELATION); \
     221             :         if (RelationHasReferenceCountZero(_old_rel)) \
     222             :             RelationDestroyRelation(_old_rel, false); \
     223             :         else if (!IsBootstrapProcessingMode()) \
     224             :             elog(WARNING, "leaking still-referenced relcache entry for \"%s\"", \
     225             :                  RelationGetRelationName(_old_rel)); \
     226             :     } \
     227             :     else \
     228             :         hentry->reldesc = (RELATION); \
     229             : } while(0)
     230             : 
     231             : #define RelationIdCacheLookup(ID, RELATION) \
     232             : do { \
     233             :     RelIdCacheEnt *hentry; \
     234             :     hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
     235             :                                            &(ID), \
     236             :                                            HASH_FIND, NULL); \
     237             :     if (hentry) \
     238             :         RELATION = hentry->reldesc; \
     239             :     else \
     240             :         RELATION = NULL; \
     241             : } while(0)
     242             : 
     243             : #define RelationCacheDelete(RELATION) \
     244             : do { \
     245             :     RelIdCacheEnt *hentry; \
     246             :     hentry = (RelIdCacheEnt *) hash_search(RelationIdCache, \
     247             :                                            &((RELATION)->rd_id), \
     248             :                                            HASH_REMOVE, NULL); \
     249             :     if (hentry == NULL) \
     250             :         elog(WARNING, "failed to delete relcache entry for OID %u", \
     251             :              (RELATION)->rd_id); \
     252             : } while(0)
     253             : 
     254             : 
     255             : /*
     256             :  * Special cache for opclass-related information
     257             :  *
     258             :  * Note: only default support procs get cached, ie, those with
     259             :  * lefttype = righttype = opcintype.
     260             :  */
     261             : typedef struct opclasscacheent
     262             : {
     263             :     Oid         opclassoid;     /* lookup key: OID of opclass */
     264             :     bool        valid;          /* set true after successful fill-in */
     265             :     StrategyNumber numSupport;  /* max # of support procs (from pg_am) */
     266             :     Oid         opcfamily;      /* OID of opclass's family */
     267             :     Oid         opcintype;      /* OID of opclass's declared input type */
     268             :     RegProcedure *supportProcs; /* OIDs of support procedures */
     269             : } OpClassCacheEnt;
     270             : 
     271             : static HTAB *OpClassCache = NULL;
     272             : 
     273             : 
     274             : /* non-export function prototypes */
     275             : 
     276             : static void RelationCloseCleanup(Relation relation);
     277             : static void RelationDestroyRelation(Relation relation, bool remember_tupdesc);
     278             : static void RelationInvalidateRelation(Relation relation);
     279             : static void RelationClearRelation(Relation relation);
     280             : static void RelationRebuildRelation(Relation relation);
     281             : 
     282             : static void RelationReloadIndexInfo(Relation relation);
     283             : static void RelationReloadNailed(Relation relation);
     284             : static void RelationFlushRelation(Relation relation);
     285             : static void RememberToFreeTupleDescAtEOX(TupleDesc td);
     286             : #ifdef USE_ASSERT_CHECKING
     287             : static void AssertPendingSyncConsistency(Relation relation);
     288             : #endif
     289             : static void AtEOXact_cleanup(Relation relation, bool isCommit);
     290             : static void AtEOSubXact_cleanup(Relation relation, bool isCommit,
     291             :                                 SubTransactionId mySubid, SubTransactionId parentSubid);
     292             : static bool load_relcache_init_file(bool shared);
     293             : static void write_relcache_init_file(bool shared);
     294             : static void write_item(const void *data, Size len, FILE *fp);
     295             : 
     296             : static void formrdesc(const char *relationName, Oid relationReltype,
     297             :                       bool isshared, int natts, const FormData_pg_attribute *attrs);
     298             : 
     299             : static HeapTuple ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic);
     300             : static Relation AllocateRelationDesc(Form_pg_class relp);
     301             : static void RelationParseRelOptions(Relation relation, HeapTuple tuple);
     302             : static void RelationBuildTupleDesc(Relation relation);
     303             : static Relation RelationBuildDesc(Oid targetRelId, bool insertIt);
     304             : static void RelationInitPhysicalAddr(Relation relation);
     305             : static void load_critical_index(Oid indexoid, Oid heapoid);
     306             : static TupleDesc GetPgClassDescriptor(void);
     307             : static TupleDesc GetPgIndexDescriptor(void);
     308             : static void AttrDefaultFetch(Relation relation, int ndef);
     309             : static int  AttrDefaultCmp(const void *a, const void *b);
     310             : static void CheckNNConstraintFetch(Relation relation);
     311             : static int  CheckConstraintCmp(const void *a, const void *b);
     312             : static void InitIndexAmRoutine(Relation relation);
     313             : static void IndexSupportInitialize(oidvector *indclass,
     314             :                                    RegProcedure *indexSupport,
     315             :                                    Oid *opFamily,
     316             :                                    Oid *opcInType,
     317             :                                    StrategyNumber maxSupportNumber,
     318             :                                    AttrNumber maxAttributeNumber);
     319             : static OpClassCacheEnt *LookupOpclassInfo(Oid operatorClassOid,
     320             :                                           StrategyNumber numSupport);
     321             : static void RelationCacheInitFileRemoveInDir(const char *tblspcpath);
     322             : static void unlink_initfile(const char *initfilename, int elevel);
     323             : 
     324             : 
     325             : /*
     326             :  *      ScanPgRelation
     327             :  *
     328             :  *      This is used by RelationBuildDesc to find a pg_class
     329             :  *      tuple matching targetRelId.  The caller must hold at least
     330             :  *      AccessShareLock on the target relid to prevent concurrent-update
     331             :  *      scenarios; it isn't guaranteed that all scans used to build the
     332             :  *      relcache entry will use the same snapshot.  If, for example,
     333             :  *      an attribute were to be added after scanning pg_class and before
     334             :  *      scanning pg_attribute, relnatts wouldn't match.
     335             :  *
     336             :  *      NB: the returned tuple has been copied into palloc'd storage
     337             :  *      and must eventually be freed with heap_freetuple.
     338             :  */
     339             : static HeapTuple
     340     1714720 : ScanPgRelation(Oid targetRelId, bool indexOK, bool force_non_historic)
     341             : {
     342             :     HeapTuple   pg_class_tuple;
     343             :     Relation    pg_class_desc;
     344             :     SysScanDesc pg_class_scan;
     345             :     ScanKeyData key[1];
     346     1714720 :     Snapshot    snapshot = NULL;
     347             : 
     348             :     /*
     349             :      * If something goes wrong during backend startup, we might find ourselves
     350             :      * trying to read pg_class before we've selected a database.  That ain't
     351             :      * gonna work, so bail out with a useful error message.  If this happens,
     352             :      * it probably means a relcache entry that needs to be nailed isn't.
     353             :      */
     354     1714720 :     if (!OidIsValid(MyDatabaseId))
     355           0 :         elog(FATAL, "cannot read pg_class without having selected a database");
     356             : 
     357             :     /*
     358             :      * form a scan key
     359             :      */
     360     1714720 :     ScanKeyInit(&key[0],
     361             :                 Anum_pg_class_oid,
     362             :                 BTEqualStrategyNumber, F_OIDEQ,
     363             :                 ObjectIdGetDatum(targetRelId));
     364             : 
     365             :     /*
     366             :      * Open pg_class and fetch a tuple.  Force heap scan if we haven't yet
     367             :      * built the critical relcache entries (this includes initdb and startup
     368             :      * without a pg_internal.init file).  The caller can also force a heap
     369             :      * scan by setting indexOK == false.
     370             :      */
     371     1714720 :     pg_class_desc = table_open(RelationRelationId, AccessShareLock);
     372             : 
     373             :     /*
     374             :      * The caller might need a tuple that's newer than what's visible to the
     375             :      * historic snapshot; currently the only case requiring to do so is
     376             :      * looking up the relfilenumber of non mapped system relations during
     377             :      * decoding.
     378             :      */
     379     1714720 :     if (force_non_historic)
     380        3210 :         snapshot = RegisterSnapshot(GetNonHistoricCatalogSnapshot(RelationRelationId));
     381             : 
     382     1714720 :     pg_class_scan = systable_beginscan(pg_class_desc, ClassOidIndexId,
     383     1714720 :                                        indexOK && criticalRelcachesBuilt,
     384             :                                        snapshot,
     385             :                                        1, key);
     386             : 
     387     1714714 :     pg_class_tuple = systable_getnext(pg_class_scan);
     388             : 
     389             :     /*
     390             :      * Must copy tuple before releasing buffer.
     391             :      */
     392     1714708 :     if (HeapTupleIsValid(pg_class_tuple))
     393     1714698 :         pg_class_tuple = heap_copytuple(pg_class_tuple);
     394             : 
     395             :     /* all done */
     396     1714708 :     systable_endscan(pg_class_scan);
     397             : 
     398     1714708 :     if (snapshot)
     399        3210 :         UnregisterSnapshot(snapshot);
     400             : 
     401     1714708 :     table_close(pg_class_desc, AccessShareLock);
     402             : 
     403     1714708 :     return pg_class_tuple;
     404             : }
     405             : 
     406             : /*
     407             :  *      AllocateRelationDesc
     408             :  *
     409             :  *      This is used to allocate memory for a new relation descriptor
     410             :  *      and initialize the rd_rel field from the given pg_class tuple.
     411             :  */
     412             : static Relation
     413     1564808 : AllocateRelationDesc(Form_pg_class relp)
     414             : {
     415             :     Relation    relation;
     416             :     MemoryContext oldcxt;
     417             :     Form_pg_class relationForm;
     418             : 
     419             :     /* Relcache entries must live in CacheMemoryContext */
     420     1564808 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     421             : 
     422             :     /*
     423             :      * allocate and zero space for new relation descriptor
     424             :      */
     425     1564808 :     relation = (Relation) palloc0(sizeof(RelationData));
     426             : 
     427             :     /* make sure relation is marked as having no open file yet */
     428     1564808 :     relation->rd_smgr = NULL;
     429             : 
     430             :     /*
     431             :      * Copy the relation tuple form
     432             :      *
     433             :      * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. The
     434             :      * variable-length fields (relacl, reloptions) are NOT stored in the
     435             :      * relcache --- there'd be little point in it, since we don't copy the
     436             :      * tuple's nulls bitmap and hence wouldn't know if the values are valid.
     437             :      * Bottom line is that relacl *cannot* be retrieved from the relcache. Get
     438             :      * it from the syscache if you need it.  The same goes for the original
     439             :      * form of reloptions (however, we do store the parsed form of reloptions
     440             :      * in rd_options).
     441             :      */
     442     1564808 :     relationForm = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
     443             : 
     444     1564808 :     memcpy(relationForm, relp, CLASS_TUPLE_SIZE);
     445             : 
     446             :     /* initialize relation tuple form */
     447     1564808 :     relation->rd_rel = relationForm;
     448             : 
     449             :     /* and allocate attribute tuple form storage */
     450     1564808 :     relation->rd_att = CreateTemplateTupleDesc(relationForm->relnatts);
     451             :     /* which we mark as a reference-counted tupdesc */
     452     1564808 :     relation->rd_att->tdrefcount = 1;
     453             : 
     454     1564808 :     MemoryContextSwitchTo(oldcxt);
     455             : 
     456     1564808 :     return relation;
     457             : }
     458             : 
     459             : /*
     460             :  * RelationParseRelOptions
     461             :  *      Convert pg_class.reloptions into pre-parsed rd_options
     462             :  *
     463             :  * tuple is the real pg_class tuple (not rd_rel!) for relation
     464             :  *
     465             :  * Note: rd_rel and (if an index) rd_indam must be valid already
     466             :  */
     467             : static void
     468     1704064 : RelationParseRelOptions(Relation relation, HeapTuple tuple)
     469             : {
     470             :     bytea      *options;
     471             :     amoptions_function amoptsfn;
     472             : 
     473     1704064 :     relation->rd_options = NULL;
     474             : 
     475             :     /*
     476             :      * Look up any AM-specific parse function; fall out if relkind should not
     477             :      * have options.
     478             :      */
     479     1704064 :     switch (relation->rd_rel->relkind)
     480             :     {
     481      949430 :         case RELKIND_RELATION:
     482             :         case RELKIND_TOASTVALUE:
     483             :         case RELKIND_VIEW:
     484             :         case RELKIND_MATVIEW:
     485             :         case RELKIND_PARTITIONED_TABLE:
     486      949430 :             amoptsfn = NULL;
     487      949430 :             break;
     488      735642 :         case RELKIND_INDEX:
     489             :         case RELKIND_PARTITIONED_INDEX:
     490      735642 :             amoptsfn = relation->rd_indam->amoptions;
     491      735642 :             break;
     492       18992 :         default:
     493       18992 :             return;
     494             :     }
     495             : 
     496             :     /*
     497             :      * Fetch reloptions from tuple; have to use a hardwired descriptor because
     498             :      * we might not have any other for pg_class yet (consider executing this
     499             :      * code for pg_class itself)
     500             :      */
     501     1685072 :     options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn);
     502             : 
     503             :     /*
     504             :      * Copy parsed data into CacheMemoryContext.  To guard against the
     505             :      * possibility of leaks in the reloptions code, we want to do the actual
     506             :      * parsing in the caller's memory context and copy the results into
     507             :      * CacheMemoryContext after the fact.
     508             :      */
     509     1685072 :     if (options)
     510             :     {
     511       37364 :         relation->rd_options = MemoryContextAlloc(CacheMemoryContext,
     512       18682 :                                                   VARSIZE(options));
     513       18682 :         memcpy(relation->rd_options, options, VARSIZE(options));
     514       18682 :         pfree(options);
     515             :     }
     516             : }
     517             : 
     518             : /*
     519             :  *      RelationBuildTupleDesc
     520             :  *
     521             :  *      Form the relation's tuple descriptor from information in
     522             :  *      the pg_attribute, pg_attrdef & pg_constraint system catalogs.
     523             :  */
     524             : static void
     525     1564808 : RelationBuildTupleDesc(Relation relation)
     526             : {
     527             :     HeapTuple   pg_attribute_tuple;
     528             :     Relation    pg_attribute_desc;
     529             :     SysScanDesc pg_attribute_scan;
     530             :     ScanKeyData skey[2];
     531             :     int         need;
     532             :     TupleConstr *constr;
     533     1564808 :     AttrMissing *attrmiss = NULL;
     534     1564808 :     int         ndef = 0;
     535             : 
     536             :     /* fill rd_att's type ID fields (compare heap.c's AddNewRelationTuple) */
     537     1564808 :     relation->rd_att->tdtypeid =
     538     1564808 :         relation->rd_rel->reltype ? relation->rd_rel->reltype : RECORDOID;
     539     1564808 :     relation->rd_att->tdtypmod = -1;  /* just to be sure */
     540             : 
     541     1564808 :     constr = (TupleConstr *) MemoryContextAllocZero(CacheMemoryContext,
     542             :                                                     sizeof(TupleConstr));
     543             : 
     544             :     /*
     545             :      * Form a scan key that selects only user attributes (attnum > 0).
     546             :      * (Eliminating system attribute rows at the index level is lots faster
     547             :      * than fetching them.)
     548             :      */
     549     1564808 :     ScanKeyInit(&skey[0],
     550             :                 Anum_pg_attribute_attrelid,
     551             :                 BTEqualStrategyNumber, F_OIDEQ,
     552             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
     553     1564808 :     ScanKeyInit(&skey[1],
     554             :                 Anum_pg_attribute_attnum,
     555             :                 BTGreaterStrategyNumber, F_INT2GT,
     556             :                 Int16GetDatum(0));
     557             : 
     558             :     /*
     559             :      * Open pg_attribute and begin a scan.  Force heap scan if we haven't yet
     560             :      * built the critical relcache entries (this includes initdb and startup
     561             :      * without a pg_internal.init file).
     562             :      */
     563     1564808 :     pg_attribute_desc = table_open(AttributeRelationId, AccessShareLock);
     564     1564808 :     pg_attribute_scan = systable_beginscan(pg_attribute_desc,
     565             :                                            AttributeRelidNumIndexId,
     566             :                                            criticalRelcachesBuilt,
     567             :                                            NULL,
     568             :                                            2, skey);
     569             : 
     570             :     /*
     571             :      * add attribute data to relation->rd_att
     572             :      */
     573     1564808 :     need = RelationGetNumberOfAttributes(relation);
     574             : 
     575     5498608 :     while (HeapTupleIsValid(pg_attribute_tuple = systable_getnext(pg_attribute_scan)))
     576             :     {
     577             :         Form_pg_attribute attp;
     578             :         int         attnum;
     579             : 
     580     5488564 :         attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);
     581             : 
     582     5488564 :         attnum = attp->attnum;
     583     5488564 :         if (attnum <= 0 || attnum > RelationGetNumberOfAttributes(relation))
     584           0 :             elog(ERROR, "invalid attribute number %d for relation \"%s\"",
     585             :                  attp->attnum, RelationGetRelationName(relation));
     586             : 
     587     5488564 :         memcpy(TupleDescAttr(relation->rd_att, attnum - 1),
     588             :                attp,
     589             :                ATTRIBUTE_FIXED_PART_SIZE);
     590             : 
     591     5488564 :         populate_compact_attribute(relation->rd_att, attnum - 1);
     592             : 
     593             :         /* Update constraint/default info */
     594     5488564 :         if (attp->attnotnull)
     595     2302004 :             constr->has_not_null = true;
     596     5488564 :         if (attp->attgenerated == ATTRIBUTE_GENERATED_STORED)
     597       10710 :             constr->has_generated_stored = true;
     598     5488564 :         if (attp->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
     599        7374 :             constr->has_generated_virtual = true;
     600     5488564 :         if (attp->atthasdef)
     601       53904 :             ndef++;
     602             : 
     603             :         /* If the column has a "missing" value, put it in the attrmiss array */
     604     5488564 :         if (attp->atthasmissing)
     605             :         {
     606             :             Datum       missingval;
     607             :             bool        missingNull;
     608             : 
     609             :             /* Do we have a missing value? */
     610        7898 :             missingval = heap_getattr(pg_attribute_tuple,
     611             :                                       Anum_pg_attribute_attmissingval,
     612             :                                       pg_attribute_desc->rd_att,
     613             :                                       &missingNull);
     614        7898 :             if (!missingNull)
     615             :             {
     616             :                 /* Yes, fetch from the array */
     617             :                 MemoryContext oldcxt;
     618             :                 bool        is_null;
     619        7898 :                 int         one = 1;
     620             :                 Datum       missval;
     621             : 
     622        7898 :                 if (attrmiss == NULL)
     623             :                     attrmiss = (AttrMissing *)
     624        3758 :                         MemoryContextAllocZero(CacheMemoryContext,
     625        3758 :                                                relation->rd_rel->relnatts *
     626             :                                                sizeof(AttrMissing));
     627             : 
     628        7898 :                 missval = array_get_element(missingval,
     629             :                                             1,
     630             :                                             &one,
     631             :                                             -1,
     632        7898 :                                             attp->attlen,
     633        7898 :                                             attp->attbyval,
     634        7898 :                                             attp->attalign,
     635             :                                             &is_null);
     636             :                 Assert(!is_null);
     637        7898 :                 if (attp->attbyval)
     638             :                 {
     639             :                     /* for copy by val just copy the datum direct */
     640        4950 :                     attrmiss[attnum - 1].am_value = missval;
     641             :                 }
     642             :                 else
     643             :                 {
     644             :                     /* otherwise copy in the correct context */
     645        2948 :                     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
     646        5896 :                     attrmiss[attnum - 1].am_value = datumCopy(missval,
     647        2948 :                                                               attp->attbyval,
     648        2948 :                                                               attp->attlen);
     649        2948 :                     MemoryContextSwitchTo(oldcxt);
     650             :                 }
     651        7898 :                 attrmiss[attnum - 1].am_present = true;
     652             :             }
     653             :         }
     654     5488564 :         need--;
     655     5488564 :         if (need == 0)
     656     1554764 :             break;
     657             :     }
     658             : 
     659             :     /*
     660             :      * end the scan and close the attribute relation
     661             :      */
     662     1564808 :     systable_endscan(pg_attribute_scan);
     663     1564808 :     table_close(pg_attribute_desc, AccessShareLock);
     664             : 
     665     1564808 :     if (need != 0)
     666           0 :         elog(ERROR, "pg_attribute catalog is missing %d attribute(s) for relation OID %u",
     667             :              need, RelationGetRelid(relation));
     668             : 
     669             :     /*
     670             :      * We can easily set the attcacheoff value for the first attribute: it
     671             :      * must be zero.  This eliminates the need for special cases for attnum=1
     672             :      * that used to exist in fastgetattr() and index_getattr().
     673             :      */
     674     1564808 :     if (RelationGetNumberOfAttributes(relation) > 0)
     675     1554764 :         TupleDescCompactAttr(relation->rd_att, 0)->attcacheoff = 0;
     676             : 
     677             :     /*
     678             :      * Set up constraint/default info
     679             :      */
     680     1564808 :     if (constr->has_not_null ||
     681     1076720 :         constr->has_generated_stored ||
     682     1072908 :         constr->has_generated_virtual ||
     683     1066248 :         ndef > 0 ||
     684     1066200 :         attrmiss ||
     685     1066200 :         relation->rd_rel->relchecks > 0)
     686      504354 :     {
     687      504354 :         bool        is_catalog = IsCatalogRelation(relation);
     688             : 
     689      504354 :         relation->rd_att->constr = constr;
     690             : 
     691      504354 :         if (ndef > 0)            /* DEFAULTs */
     692       38008 :             AttrDefaultFetch(relation, ndef);
     693             :         else
     694      466346 :             constr->num_defval = 0;
     695             : 
     696      504354 :         constr->missing = attrmiss;
     697             : 
     698             :         /* CHECK and NOT NULLs */
     699      504354 :         if (relation->rd_rel->relchecks > 0 ||
     700      491406 :             (!is_catalog && constr->has_not_null))
     701      174740 :             CheckNNConstraintFetch(relation);
     702             : 
     703             :         /*
     704             :          * Any not-null constraint that wasn't marked invalid by
     705             :          * CheckNNConstraintFetch must necessarily be valid; make it so in the
     706             :          * CompactAttribute array.
     707             :          */
     708      504354 :         if (!is_catalog)
     709             :         {
     710      637202 :             for (int i = 0; i < relation->rd_rel->relnatts; i++)
     711             :             {
     712             :                 CompactAttribute *attr;
     713             : 
     714      452376 :                 attr = TupleDescCompactAttr(relation->rd_att, i);
     715             : 
     716      452376 :                 if (attr->attnullability == ATTNULLABLE_UNKNOWN)
     717      248196 :                     attr->attnullability = ATTNULLABLE_VALID;
     718             :                 else
     719             :                     Assert(attr->attnullability == ATTNULLABLE_INVALID ||
     720             :                            attr->attnullability == ATTNULLABLE_UNRESTRICTED);
     721             :             }
     722             :         }
     723             : 
     724      504354 :         if (relation->rd_rel->relchecks == 0)
     725      491406 :             constr->num_check = 0;
     726             :     }
     727             :     else
     728             :     {
     729     1060454 :         pfree(constr);
     730     1060454 :         relation->rd_att->constr = NULL;
     731             :     }
     732     1564808 : }
     733             : 
     734             : /*
     735             :  *      RelationBuildRuleLock
     736             :  *
     737             :  *      Form the relation's rewrite rules from information in
     738             :  *      the pg_rewrite system catalog.
     739             :  *
     740             :  * Note: The rule parsetrees are potentially very complex node structures.
     741             :  * To allow these trees to be freed when the relcache entry is flushed,
     742             :  * we make a private memory context to hold the RuleLock information for
     743             :  * each relcache entry that has associated rules.  The context is used
     744             :  * just for rule info, not for any other subsidiary data of the relcache
     745             :  * entry, because that keeps the update logic in RelationRebuildRelation()
     746             :  * manageable.  The other subsidiary data structures are simple enough
     747             :  * to be easy to free explicitly, anyway.
     748             :  *
     749             :  * Note: The relation's reloptions must have been extracted first.
     750             :  */
     751             : static void
     752       39222 : RelationBuildRuleLock(Relation relation)
     753             : {
     754             :     MemoryContext rulescxt;
     755             :     MemoryContext oldcxt;
     756             :     HeapTuple   rewrite_tuple;
     757             :     Relation    rewrite_desc;
     758             :     TupleDesc   rewrite_tupdesc;
     759             :     SysScanDesc rewrite_scan;
     760             :     ScanKeyData key;
     761             :     RuleLock   *rulelock;
     762             :     int         numlocks;
     763             :     RewriteRule **rules;
     764             :     int         maxlocks;
     765             : 
     766             :     /*
     767             :      * Make the private context.  Assume it'll not contain much data.
     768             :      */
     769       39222 :     rulescxt = AllocSetContextCreate(CacheMemoryContext,
     770             :                                      "relation rules",
     771             :                                      ALLOCSET_SMALL_SIZES);
     772       39222 :     relation->rd_rulescxt = rulescxt;
     773       39222 :     MemoryContextCopyAndSetIdentifier(rulescxt,
     774             :                                       RelationGetRelationName(relation));
     775             : 
     776             :     /*
     777             :      * allocate an array to hold the rewrite rules (the array is extended if
     778             :      * necessary)
     779             :      */
     780       39222 :     maxlocks = 4;
     781             :     rules = (RewriteRule **)
     782       39222 :         MemoryContextAlloc(rulescxt, sizeof(RewriteRule *) * maxlocks);
     783       39222 :     numlocks = 0;
     784             : 
     785             :     /*
     786             :      * form a scan key
     787             :      */
     788       39222 :     ScanKeyInit(&key,
     789             :                 Anum_pg_rewrite_ev_class,
     790             :                 BTEqualStrategyNumber, F_OIDEQ,
     791             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
     792             : 
     793             :     /*
     794             :      * open pg_rewrite and begin a scan
     795             :      *
     796             :      * Note: since we scan the rules using RewriteRelRulenameIndexId, we will
     797             :      * be reading the rules in name order, except possibly during
     798             :      * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
     799             :      * ensures that rules will be fired in name order.
     800             :      */
     801       39222 :     rewrite_desc = table_open(RewriteRelationId, AccessShareLock);
     802       39222 :     rewrite_tupdesc = RelationGetDescr(rewrite_desc);
     803       39222 :     rewrite_scan = systable_beginscan(rewrite_desc,
     804             :                                       RewriteRelRulenameIndexId,
     805             :                                       true, NULL,
     806             :                                       1, &key);
     807             : 
     808       78384 :     while (HeapTupleIsValid(rewrite_tuple = systable_getnext(rewrite_scan)))
     809             :     {
     810       39162 :         Form_pg_rewrite rewrite_form = (Form_pg_rewrite) GETSTRUCT(rewrite_tuple);
     811             :         bool        isnull;
     812             :         Datum       rule_datum;
     813             :         char       *rule_str;
     814             :         RewriteRule *rule;
     815             :         Oid         check_as_user;
     816             : 
     817       39162 :         rule = (RewriteRule *) MemoryContextAlloc(rulescxt,
     818             :                                                   sizeof(RewriteRule));
     819             : 
     820       39162 :         rule->ruleId = rewrite_form->oid;
     821             : 
     822       39162 :         rule->event = rewrite_form->ev_type - '0';
     823       39162 :         rule->enabled = rewrite_form->ev_enabled;
     824       39162 :         rule->isInstead = rewrite_form->is_instead;
     825             : 
     826             :         /*
     827             :          * Must use heap_getattr to fetch ev_action and ev_qual.  Also, the
     828             :          * rule strings are often large enough to be toasted.  To avoid
     829             :          * leaking memory in the caller's context, do the detoasting here so
     830             :          * we can free the detoasted version.
     831             :          */
     832       39162 :         rule_datum = heap_getattr(rewrite_tuple,
     833             :                                   Anum_pg_rewrite_ev_action,
     834             :                                   rewrite_tupdesc,
     835             :                                   &isnull);
     836             :         Assert(!isnull);
     837       39162 :         rule_str = TextDatumGetCString(rule_datum);
     838       39162 :         oldcxt = MemoryContextSwitchTo(rulescxt);
     839       39162 :         rule->actions = (List *) stringToNode(rule_str);
     840       39162 :         MemoryContextSwitchTo(oldcxt);
     841       39162 :         pfree(rule_str);
     842             : 
     843       39162 :         rule_datum = heap_getattr(rewrite_tuple,
     844             :                                   Anum_pg_rewrite_ev_qual,
     845             :                                   rewrite_tupdesc,
     846             :                                   &isnull);
     847             :         Assert(!isnull);
     848       39162 :         rule_str = TextDatumGetCString(rule_datum);
     849       39162 :         oldcxt = MemoryContextSwitchTo(rulescxt);
     850       39162 :         rule->qual = (Node *) stringToNode(rule_str);
     851       39162 :         MemoryContextSwitchTo(oldcxt);
     852       39162 :         pfree(rule_str);
     853             : 
     854             :         /*
     855             :          * If this is a SELECT rule defining a view, and the view has
     856             :          * "security_invoker" set, we must perform all permissions checks on
     857             :          * relations referred to by the rule as the invoking user.
     858             :          *
     859             :          * In all other cases (including non-SELECT rules on security invoker
     860             :          * views), perform the permissions checks as the relation owner.
     861             :          */
     862       39162 :         if (rule->event == CMD_SELECT &&
     863       35186 :             relation->rd_rel->relkind == RELKIND_VIEW &&
     864       30948 :             RelationHasSecurityInvoker(relation))
     865         168 :             check_as_user = InvalidOid;
     866             :         else
     867       38994 :             check_as_user = relation->rd_rel->relowner;
     868             : 
     869             :         /*
     870             :          * Scan through the rule's actions and set the checkAsUser field on
     871             :          * all RTEPermissionInfos. We have to look at the qual as well, in
     872             :          * case it contains sublinks.
     873             :          *
     874             :          * The reason for doing this when the rule is loaded, rather than when
     875             :          * it is stored, is that otherwise ALTER TABLE OWNER would have to
     876             :          * grovel through stored rules to update checkAsUser fields. Scanning
     877             :          * the rule tree during load is relatively cheap (compared to
     878             :          * constructing it in the first place), so we do it here.
     879             :          */
     880       39162 :         setRuleCheckAsUser((Node *) rule->actions, check_as_user);
     881       39162 :         setRuleCheckAsUser(rule->qual, check_as_user);
     882             : 
     883       39162 :         if (numlocks >= maxlocks)
     884             :         {
     885          46 :             maxlocks *= 2;
     886             :             rules = (RewriteRule **)
     887          46 :                 repalloc(rules, sizeof(RewriteRule *) * maxlocks);
     888             :         }
     889       39162 :         rules[numlocks++] = rule;
     890             :     }
     891             : 
     892             :     /*
     893             :      * end the scan and close the attribute relation
     894             :      */
     895       39222 :     systable_endscan(rewrite_scan);
     896       39222 :     table_close(rewrite_desc, AccessShareLock);
     897             : 
     898             :     /*
     899             :      * there might not be any rules (if relhasrules is out-of-date)
     900             :      */
     901       39222 :     if (numlocks == 0)
     902             :     {
     903        2900 :         relation->rd_rules = NULL;
     904        2900 :         relation->rd_rulescxt = NULL;
     905        2900 :         MemoryContextDelete(rulescxt);
     906        2900 :         return;
     907             :     }
     908             : 
     909             :     /*
     910             :      * form a RuleLock and insert into relation
     911             :      */
     912       36322 :     rulelock = (RuleLock *) MemoryContextAlloc(rulescxt, sizeof(RuleLock));
     913       36322 :     rulelock->numLocks = numlocks;
     914       36322 :     rulelock->rules = rules;
     915             : 
     916       36322 :     relation->rd_rules = rulelock;
     917             : }
     918             : 
     919             : /*
     920             :  *      equalRuleLocks
     921             :  *
     922             :  *      Determine whether two RuleLocks are equivalent
     923             :  *
     924             :  *      Probably this should be in the rules code someplace...
     925             :  */
     926             : static bool
     927      433578 : equalRuleLocks(RuleLock *rlock1, RuleLock *rlock2)
     928             : {
     929             :     int         i;
     930             : 
     931             :     /*
     932             :      * As of 7.3 we assume the rule ordering is repeatable, because
     933             :      * RelationBuildRuleLock should read 'em in a consistent order.  So just
     934             :      * compare corresponding slots.
     935             :      */
     936      433578 :     if (rlock1 != NULL)
     937             :     {
     938        2822 :         if (rlock2 == NULL)
     939          68 :             return false;
     940        2754 :         if (rlock1->numLocks != rlock2->numLocks)
     941           6 :             return false;
     942        5248 :         for (i = 0; i < rlock1->numLocks; i++)
     943             :         {
     944        2796 :             RewriteRule *rule1 = rlock1->rules[i];
     945        2796 :             RewriteRule *rule2 = rlock2->rules[i];
     946             : 
     947        2796 :             if (rule1->ruleId != rule2->ruleId)
     948           0 :                 return false;
     949        2796 :             if (rule1->event != rule2->event)
     950           0 :                 return false;
     951        2796 :             if (rule1->enabled != rule2->enabled)
     952          52 :                 return false;
     953        2744 :             if (rule1->isInstead != rule2->isInstead)
     954           0 :                 return false;
     955        2744 :             if (!equal(rule1->qual, rule2->qual))
     956           0 :                 return false;
     957        2744 :             if (!equal(rule1->actions, rule2->actions))
     958         244 :                 return false;
     959             :         }
     960             :     }
     961      430756 :     else if (rlock2 != NULL)
     962       16820 :         return false;
     963      416388 :     return true;
     964             : }
     965             : 
     966             : /*
     967             :  *      equalPolicy
     968             :  *
     969             :  *      Determine whether two policies are equivalent
     970             :  */
     971             : static bool
     972         228 : equalPolicy(RowSecurityPolicy *policy1, RowSecurityPolicy *policy2)
     973             : {
     974             :     int         i;
     975             :     Oid        *r1,
     976             :                *r2;
     977             : 
     978         228 :     if (policy1 != NULL)
     979             :     {
     980         228 :         if (policy2 == NULL)
     981           0 :             return false;
     982             : 
     983         228 :         if (policy1->polcmd != policy2->polcmd)
     984           0 :             return false;
     985         228 :         if (policy1->hassublinks != policy2->hassublinks)
     986           0 :             return false;
     987         228 :         if (strcmp(policy1->policy_name, policy2->policy_name) != 0)
     988           0 :             return false;
     989         228 :         if (ARR_DIMS(policy1->roles)[0] != ARR_DIMS(policy2->roles)[0])
     990           0 :             return false;
     991             : 
     992         228 :         r1 = (Oid *) ARR_DATA_PTR(policy1->roles);
     993         228 :         r2 = (Oid *) ARR_DATA_PTR(policy2->roles);
     994             : 
     995         456 :         for (i = 0; i < ARR_DIMS(policy1->roles)[0]; i++)
     996             :         {
     997         228 :             if (r1[i] != r2[i])
     998           0 :                 return false;
     999             :         }
    1000             : 
    1001         228 :         if (!equal(policy1->qual, policy2->qual))
    1002           0 :             return false;
    1003         228 :         if (!equal(policy1->with_check_qual, policy2->with_check_qual))
    1004           0 :             return false;
    1005             :     }
    1006           0 :     else if (policy2 != NULL)
    1007           0 :         return false;
    1008             : 
    1009         228 :     return true;
    1010             : }
    1011             : 
    1012             : /*
    1013             :  *      equalRSDesc
    1014             :  *
    1015             :  *      Determine whether two RowSecurityDesc's are equivalent
    1016             :  */
    1017             : static bool
    1018      433578 : equalRSDesc(RowSecurityDesc *rsdesc1, RowSecurityDesc *rsdesc2)
    1019             : {
    1020             :     ListCell   *lc,
    1021             :                *rc;
    1022             : 
    1023      433578 :     if (rsdesc1 == NULL && rsdesc2 == NULL)
    1024      433096 :         return true;
    1025             : 
    1026         482 :     if ((rsdesc1 != NULL && rsdesc2 == NULL) ||
    1027         302 :         (rsdesc1 == NULL && rsdesc2 != NULL))
    1028         312 :         return false;
    1029             : 
    1030         170 :     if (list_length(rsdesc1->policies) != list_length(rsdesc2->policies))
    1031           6 :         return false;
    1032             : 
    1033             :     /* RelationBuildRowSecurity should build policies in order */
    1034         392 :     forboth(lc, rsdesc1->policies, rc, rsdesc2->policies)
    1035             :     {
    1036         228 :         RowSecurityPolicy *l = (RowSecurityPolicy *) lfirst(lc);
    1037         228 :         RowSecurityPolicy *r = (RowSecurityPolicy *) lfirst(rc);
    1038             : 
    1039         228 :         if (!equalPolicy(l, r))
    1040           0 :             return false;
    1041             :     }
    1042             : 
    1043         164 :     return true;
    1044             : }
    1045             : 
    1046             : /*
    1047             :  *      RelationBuildDesc
    1048             :  *
    1049             :  *      Build a relation descriptor.  The caller must hold at least
    1050             :  *      AccessShareLock on the target relid.
    1051             :  *
    1052             :  *      The new descriptor is inserted into the hash table if insertIt is true.
    1053             :  *
    1054             :  *      Returns NULL if no pg_class row could be found for the given relid
    1055             :  *      (suggesting we are trying to access a just-deleted relation).
    1056             :  *      Any other error is reported via elog.
    1057             :  */
    1058             : static Relation
    1059     1564796 : RelationBuildDesc(Oid targetRelId, bool insertIt)
    1060             : {
    1061             :     int         in_progress_offset;
    1062             :     Relation    relation;
    1063             :     Oid         relid;
    1064             :     HeapTuple   pg_class_tuple;
    1065             :     Form_pg_class relp;
    1066             : 
    1067             :     /*
    1068             :      * This function and its subroutines can allocate a good deal of transient
    1069             :      * data in CurrentMemoryContext.  Traditionally we've just leaked that
    1070             :      * data, reasoning that the caller's context is at worst of transaction
    1071             :      * scope, and relcache loads shouldn't happen so often that it's essential
    1072             :      * to recover transient data before end of statement/transaction.  However
    1073             :      * that's definitely not true when debug_discard_caches is active, and
    1074             :      * perhaps it's not true in other cases.
    1075             :      *
    1076             :      * When debug_discard_caches is active or when forced to by
    1077             :      * RECOVER_RELATION_BUILD_MEMORY=1, arrange to allocate the junk in a
    1078             :      * temporary context that we'll free before returning.  Make it a child of
    1079             :      * caller's context so that it will get cleaned up appropriately if we
    1080             :      * error out partway through.
    1081             :      */
    1082             : #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
    1083             :     MemoryContext tmpcxt = NULL;
    1084             :     MemoryContext oldcxt = NULL;
    1085             : 
    1086             :     if (RECOVER_RELATION_BUILD_MEMORY || debug_discard_caches > 0)
    1087             :     {
    1088             :         tmpcxt = AllocSetContextCreate(CurrentMemoryContext,
    1089             :                                        "RelationBuildDesc workspace",
    1090             :                                        ALLOCSET_DEFAULT_SIZES);
    1091             :         oldcxt = MemoryContextSwitchTo(tmpcxt);
    1092             :     }
    1093             : #endif
    1094             : 
    1095             :     /* Register to catch invalidation messages */
    1096     1564796 :     if (in_progress_list_len >= in_progress_list_maxlen)
    1097             :     {
    1098             :         int         allocsize;
    1099             : 
    1100          28 :         allocsize = in_progress_list_maxlen * 2;
    1101          28 :         in_progress_list = repalloc(in_progress_list,
    1102             :                                     allocsize * sizeof(*in_progress_list));
    1103          28 :         in_progress_list_maxlen = allocsize;
    1104             :     }
    1105     1564796 :     in_progress_offset = in_progress_list_len++;
    1106     1564796 :     in_progress_list[in_progress_offset].reloid = targetRelId;
    1107     1564818 : retry:
    1108     1564818 :     in_progress_list[in_progress_offset].invalidated = false;
    1109             : 
    1110             :     /*
    1111             :      * find the tuple in pg_class corresponding to the given relation id
    1112             :      */
    1113     1564818 :     pg_class_tuple = ScanPgRelation(targetRelId, true, false);
    1114             : 
    1115             :     /*
    1116             :      * if no such tuple exists, return NULL
    1117             :      */
    1118     1564818 :     if (!HeapTupleIsValid(pg_class_tuple))
    1119             :     {
    1120             : #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
    1121             :         if (tmpcxt)
    1122             :         {
    1123             :             /* Return to caller's context, and blow away the temporary context */
    1124             :             MemoryContextSwitchTo(oldcxt);
    1125             :             MemoryContextDelete(tmpcxt);
    1126             :         }
    1127             : #endif
    1128             :         Assert(in_progress_offset + 1 == in_progress_list_len);
    1129          10 :         in_progress_list_len--;
    1130          10 :         return NULL;
    1131             :     }
    1132             : 
    1133             :     /*
    1134             :      * get information from the pg_class_tuple
    1135             :      */
    1136     1564808 :     relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
    1137     1564808 :     relid = relp->oid;
    1138             :     Assert(relid == targetRelId);
    1139             : 
    1140             :     /*
    1141             :      * allocate storage for the relation descriptor, and copy pg_class_tuple
    1142             :      * to relation->rd_rel.
    1143             :      */
    1144     1564808 :     relation = AllocateRelationDesc(relp);
    1145             : 
    1146             :     /*
    1147             :      * initialize the relation's relation id (relation->rd_id)
    1148             :      */
    1149     1564808 :     RelationGetRelid(relation) = relid;
    1150             : 
    1151             :     /*
    1152             :      * Normal relations are not nailed into the cache.  Since we don't flush
    1153             :      * new relations, it won't be new.  It could be temp though.
    1154             :      */
    1155     1564808 :     relation->rd_refcnt = 0;
    1156     1564808 :     relation->rd_isnailed = false;
    1157     1564808 :     relation->rd_createSubid = InvalidSubTransactionId;
    1158     1564808 :     relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    1159     1564808 :     relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    1160     1564808 :     relation->rd_droppedSubid = InvalidSubTransactionId;
    1161     1564808 :     switch (relation->rd_rel->relpersistence)
    1162             :     {
    1163     1535680 :         case RELPERSISTENCE_UNLOGGED:
    1164             :         case RELPERSISTENCE_PERMANENT:
    1165     1535680 :             relation->rd_backend = INVALID_PROC_NUMBER;
    1166     1535680 :             relation->rd_islocaltemp = false;
    1167     1535680 :             break;
    1168       29128 :         case RELPERSISTENCE_TEMP:
    1169       29128 :             if (isTempOrTempToastNamespace(relation->rd_rel->relnamespace))
    1170             :             {
    1171       29092 :                 relation->rd_backend = ProcNumberForTempRelations();
    1172       29092 :                 relation->rd_islocaltemp = true;
    1173             :             }
    1174             :             else
    1175             :             {
    1176             :                 /*
    1177             :                  * If it's a temp table, but not one of ours, we have to use
    1178             :                  * the slow, grotty method to figure out the owning backend.
    1179             :                  *
    1180             :                  * Note: it's possible that rd_backend gets set to
    1181             :                  * MyProcNumber here, in case we are looking at a pg_class
    1182             :                  * entry left over from a crashed backend that coincidentally
    1183             :                  * had the same ProcNumber we're using.  We should *not*
    1184             :                  * consider such a table to be "ours"; this is why we need the
    1185             :                  * separate rd_islocaltemp flag.  The pg_class entry will get
    1186             :                  * flushed if/when we clean out the corresponding temp table
    1187             :                  * namespace in preparation for using it.
    1188             :                  */
    1189          36 :                 relation->rd_backend =
    1190          36 :                     GetTempNamespaceProcNumber(relation->rd_rel->relnamespace);
    1191             :                 Assert(relation->rd_backend != INVALID_PROC_NUMBER);
    1192          36 :                 relation->rd_islocaltemp = false;
    1193             :             }
    1194       29128 :             break;
    1195           0 :         default:
    1196           0 :             elog(ERROR, "invalid relpersistence: %c",
    1197             :                  relation->rd_rel->relpersistence);
    1198             :             break;
    1199             :     }
    1200             : 
    1201             :     /*
    1202             :      * initialize the tuple descriptor (relation->rd_att).
    1203             :      */
    1204     1564808 :     RelationBuildTupleDesc(relation);
    1205             : 
    1206             :     /* foreign key data is not loaded till asked for */
    1207     1564808 :     relation->rd_fkeylist = NIL;
    1208     1564808 :     relation->rd_fkeyvalid = false;
    1209             : 
    1210             :     /* partitioning data is not loaded till asked for */
    1211     1564808 :     relation->rd_partkey = NULL;
    1212     1564808 :     relation->rd_partkeycxt = NULL;
    1213     1564808 :     relation->rd_partdesc = NULL;
    1214     1564808 :     relation->rd_partdesc_nodetached = NULL;
    1215     1564808 :     relation->rd_partdesc_nodetached_xmin = InvalidTransactionId;
    1216     1564808 :     relation->rd_pdcxt = NULL;
    1217     1564808 :     relation->rd_pddcxt = NULL;
    1218     1564808 :     relation->rd_partcheck = NIL;
    1219     1564808 :     relation->rd_partcheckvalid = false;
    1220     1564808 :     relation->rd_partcheckcxt = NULL;
    1221             : 
    1222             :     /*
    1223             :      * initialize access method information
    1224             :      */
    1225     1564808 :     if (relation->rd_rel->relkind == RELKIND_INDEX ||
    1226      950842 :         relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
    1227      620318 :         RelationInitIndexAccessInfo(relation);
    1228      944490 :     else if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) ||
    1229      129496 :              relation->rd_rel->relkind == RELKIND_SEQUENCE)
    1230      821642 :         RelationInitTableAccessMethod(relation);
    1231             :     else if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    1232             :     {
    1233             :         /*
    1234             :          * Do nothing: access methods are a setting that partitions can
    1235             :          * inherit.
    1236             :          */
    1237             :     }
    1238             :     else
    1239             :         Assert(relation->rd_rel->relam == InvalidOid);
    1240             : 
    1241             :     /* extract reloptions if any */
    1242     1564800 :     RelationParseRelOptions(relation, pg_class_tuple);
    1243             : 
    1244             :     /*
    1245             :      * Fetch rules and triggers that affect this relation.
    1246             :      *
    1247             :      * Note that RelationBuildRuleLock() relies on this being done after
    1248             :      * extracting the relation's reloptions.
    1249             :      */
    1250     1564800 :     if (relation->rd_rel->relhasrules)
    1251       39222 :         RelationBuildRuleLock(relation);
    1252             :     else
    1253             :     {
    1254     1525578 :         relation->rd_rules = NULL;
    1255     1525578 :         relation->rd_rulescxt = NULL;
    1256             :     }
    1257             : 
    1258     1564800 :     if (relation->rd_rel->relhastriggers)
    1259       62754 :         RelationBuildTriggers(relation);
    1260             :     else
    1261     1502046 :         relation->trigdesc = NULL;
    1262             : 
    1263     1564800 :     if (relation->rd_rel->relrowsecurity)
    1264        2102 :         RelationBuildRowSecurity(relation);
    1265             :     else
    1266     1562698 :         relation->rd_rsdesc = NULL;
    1267             : 
    1268             :     /*
    1269             :      * initialize the relation lock manager information
    1270             :      */
    1271     1564800 :     RelationInitLockInfo(relation); /* see lmgr.c */
    1272             : 
    1273             :     /*
    1274             :      * initialize physical addressing information for the relation
    1275             :      */
    1276     1564800 :     RelationInitPhysicalAddr(relation);
    1277             : 
    1278             :     /* make sure relation is marked as having no open file yet */
    1279     1564800 :     relation->rd_smgr = NULL;
    1280             : 
    1281             :     /*
    1282             :      * now we can free the memory allocated for pg_class_tuple
    1283             :      */
    1284     1564800 :     heap_freetuple(pg_class_tuple);
    1285             : 
    1286             :     /*
    1287             :      * If an invalidation arrived mid-build, start over.  Between here and the
    1288             :      * end of this function, don't add code that does or reasonably could read
    1289             :      * system catalogs.  That range must be free from invalidation processing
    1290             :      * for the !insertIt case.  For the insertIt case, RelationCacheInsert()
    1291             :      * will enroll this relation in ordinary relcache invalidation processing,
    1292             :      */
    1293     1564800 :     if (in_progress_list[in_progress_offset].invalidated)
    1294             :     {
    1295          22 :         RelationDestroyRelation(relation, false);
    1296          22 :         goto retry;
    1297             :     }
    1298             :     Assert(in_progress_offset + 1 == in_progress_list_len);
    1299     1564778 :     in_progress_list_len--;
    1300             : 
    1301             :     /*
    1302             :      * Insert newly created relation into relcache hash table, if requested.
    1303             :      *
    1304             :      * There is one scenario in which we might find a hashtable entry already
    1305             :      * present, even though our caller failed to find it: if the relation is a
    1306             :      * system catalog or index that's used during relcache load, we might have
    1307             :      * recursively created the same relcache entry during the preceding steps.
    1308             :      * So allow RelationCacheInsert to delete any already-present relcache
    1309             :      * entry for the same OID.  The already-present entry should have refcount
    1310             :      * zero (else somebody forgot to close it); in the event that it doesn't,
    1311             :      * we'll elog a WARNING and leak the already-present entry.
    1312             :      */
    1313     1564778 :     if (insertIt)
    1314     1131200 :         RelationCacheInsert(relation, true);
    1315             : 
    1316             :     /* It's fully valid */
    1317     1564778 :     relation->rd_isvalid = true;
    1318             : 
    1319             : #ifdef MAYBE_RECOVER_RELATION_BUILD_MEMORY
    1320             :     if (tmpcxt)
    1321             :     {
    1322             :         /* Return to caller's context, and blow away the temporary context */
    1323             :         MemoryContextSwitchTo(oldcxt);
    1324             :         MemoryContextDelete(tmpcxt);
    1325             :     }
    1326             : #endif
    1327             : 
    1328     1564778 :     return relation;
    1329             : }
    1330             : 
    1331             : /*
    1332             :  * Initialize the physical addressing info (RelFileLocator) for a relcache entry
    1333             :  *
    1334             :  * Note: at the physical level, relations in the pg_global tablespace must
    1335             :  * be treated as shared, even if relisshared isn't set.  Hence we do not
    1336             :  * look at relisshared here.
    1337             :  */
    1338             : static void
    1339     6168732 : RelationInitPhysicalAddr(Relation relation)
    1340             : {
    1341     6168732 :     RelFileNumber oldnumber = relation->rd_locator.relNumber;
    1342             : 
    1343             :     /* these relations kinds never have storage */
    1344     6168732 :     if (!RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
    1345      161092 :         return;
    1346             : 
    1347     6007640 :     if (relation->rd_rel->reltablespace)
    1348      952002 :         relation->rd_locator.spcOid = relation->rd_rel->reltablespace;
    1349             :     else
    1350     5055638 :         relation->rd_locator.spcOid = MyDatabaseTableSpace;
    1351     6007640 :     if (relation->rd_locator.spcOid == GLOBALTABLESPACE_OID)
    1352      948624 :         relation->rd_locator.dbOid = InvalidOid;
    1353             :     else
    1354     5059016 :         relation->rd_locator.dbOid = MyDatabaseId;
    1355             : 
    1356     6007640 :     if (relation->rd_rel->relfilenode)
    1357             :     {
    1358             :         /*
    1359             :          * Even if we are using a decoding snapshot that doesn't represent the
    1360             :          * current state of the catalog we need to make sure the filenode
    1361             :          * points to the current file since the older file will be gone (or
    1362             :          * truncated). The new file will still contain older rows so lookups
    1363             :          * in them will work correctly. This wouldn't work correctly if
    1364             :          * rewrites were allowed to change the schema in an incompatible way,
    1365             :          * but those are prevented both on catalog tables and on user tables
    1366             :          * declared as additional catalog tables.
    1367             :          */
    1368     4465304 :         if (HistoricSnapshotActive()
    1369        4716 :             && RelationIsAccessibleInLogicalDecoding(relation)
    1370        3210 :             && IsTransactionState())
    1371             :         {
    1372             :             HeapTuple   phys_tuple;
    1373             :             Form_pg_class physrel;
    1374             : 
    1375        3210 :             phys_tuple = ScanPgRelation(RelationGetRelid(relation),
    1376        3210 :                                         RelationGetRelid(relation) != ClassOidIndexId,
    1377             :                                         true);
    1378        3210 :             if (!HeapTupleIsValid(phys_tuple))
    1379           0 :                 elog(ERROR, "could not find pg_class entry for %u",
    1380             :                      RelationGetRelid(relation));
    1381        3210 :             physrel = (Form_pg_class) GETSTRUCT(phys_tuple);
    1382             : 
    1383        3210 :             relation->rd_rel->reltablespace = physrel->reltablespace;
    1384        3210 :             relation->rd_rel->relfilenode = physrel->relfilenode;
    1385        3210 :             heap_freetuple(phys_tuple);
    1386             :         }
    1387             : 
    1388     4465304 :         relation->rd_locator.relNumber = relation->rd_rel->relfilenode;
    1389             :     }
    1390             :     else
    1391             :     {
    1392             :         /* Consult the relation mapper */
    1393     1542336 :         relation->rd_locator.relNumber =
    1394     1542336 :             RelationMapOidToFilenumber(relation->rd_id,
    1395     1542336 :                                        relation->rd_rel->relisshared);
    1396     1542336 :         if (!RelFileNumberIsValid(relation->rd_locator.relNumber))
    1397           0 :             elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u",
    1398             :                  RelationGetRelationName(relation), relation->rd_id);
    1399             :     }
    1400             : 
    1401             :     /*
    1402             :      * For RelationNeedsWAL() to answer correctly on parallel workers, restore
    1403             :      * rd_firstRelfilelocatorSubid.  No subtransactions start or end while in
    1404             :      * parallel mode, so the specific SubTransactionId does not matter.
    1405             :      */
    1406     6007640 :     if (IsParallelWorker() && oldnumber != relation->rd_locator.relNumber)
    1407             :     {
    1408       57158 :         if (RelFileLocatorSkippingWAL(relation->rd_locator))
    1409         304 :             relation->rd_firstRelfilelocatorSubid = TopSubTransactionId;
    1410             :         else
    1411       56854 :             relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    1412             :     }
    1413             : }
    1414             : 
    1415             : /*
    1416             :  * Fill in the IndexAmRoutine for an index relation.
    1417             :  *
    1418             :  * relation's rd_amhandler and rd_indexcxt must be valid already.
    1419             :  */
    1420             : static void
    1421     3200856 : InitIndexAmRoutine(Relation relation)
    1422             : {
    1423             :     IndexAmRoutine *cached,
    1424             :                *tmp;
    1425             : 
    1426             :     /*
    1427             :      * Call the amhandler in current, short-lived memory context, just in case
    1428             :      * it leaks anything (it probably won't, but let's be paranoid).
    1429             :      */
    1430     3200856 :     tmp = GetIndexAmRoutine(relation->rd_amhandler);
    1431             : 
    1432             :     /* OK, now transfer the data into relation's rd_indexcxt. */
    1433     3200856 :     cached = (IndexAmRoutine *) MemoryContextAlloc(relation->rd_indexcxt,
    1434             :                                                    sizeof(IndexAmRoutine));
    1435     3200856 :     memcpy(cached, tmp, sizeof(IndexAmRoutine));
    1436     3200856 :     relation->rd_indam = cached;
    1437             : 
    1438     3200856 :     pfree(tmp);
    1439     3200856 : }
    1440             : 
    1441             : /*
    1442             :  * Initialize index-access-method support data for an index relation
    1443             :  */
    1444             : void
    1445      635900 : RelationInitIndexAccessInfo(Relation relation)
    1446             : {
    1447             :     HeapTuple   tuple;
    1448             :     Form_pg_am  aform;
    1449             :     Datum       indcollDatum;
    1450             :     Datum       indclassDatum;
    1451             :     Datum       indoptionDatum;
    1452             :     bool        isnull;
    1453             :     oidvector  *indcoll;
    1454             :     oidvector  *indclass;
    1455             :     int2vector *indoption;
    1456             :     MemoryContext indexcxt;
    1457             :     MemoryContext oldcontext;
    1458             :     int         indnatts;
    1459             :     int         indnkeyatts;
    1460             :     uint16      amsupport;
    1461             : 
    1462             :     /*
    1463             :      * Make a copy of the pg_index entry for the index.  Since pg_index
    1464             :      * contains variable-length and possibly-null fields, we have to do this
    1465             :      * honestly rather than just treating it as a Form_pg_index struct.
    1466             :      */
    1467      635900 :     tuple = SearchSysCache1(INDEXRELID,
    1468             :                             ObjectIdGetDatum(RelationGetRelid(relation)));
    1469      635900 :     if (!HeapTupleIsValid(tuple))
    1470           0 :         elog(ERROR, "cache lookup failed for index %u",
    1471             :              RelationGetRelid(relation));
    1472      635900 :     oldcontext = MemoryContextSwitchTo(CacheMemoryContext);
    1473      635900 :     relation->rd_indextuple = heap_copytuple(tuple);
    1474      635900 :     relation->rd_index = (Form_pg_index) GETSTRUCT(relation->rd_indextuple);
    1475      635900 :     MemoryContextSwitchTo(oldcontext);
    1476      635900 :     ReleaseSysCache(tuple);
    1477             : 
    1478             :     /*
    1479             :      * Look up the index's access method, save the OID of its handler function
    1480             :      */
    1481             :     Assert(relation->rd_rel->relam != InvalidOid);
    1482      635900 :     tuple = SearchSysCache1(AMOID, ObjectIdGetDatum(relation->rd_rel->relam));
    1483      635900 :     if (!HeapTupleIsValid(tuple))
    1484           0 :         elog(ERROR, "cache lookup failed for access method %u",
    1485             :              relation->rd_rel->relam);
    1486      635900 :     aform = (Form_pg_am) GETSTRUCT(tuple);
    1487      635900 :     relation->rd_amhandler = aform->amhandler;
    1488      635900 :     ReleaseSysCache(tuple);
    1489             : 
    1490      635900 :     indnatts = RelationGetNumberOfAttributes(relation);
    1491      635900 :     if (indnatts != IndexRelationGetNumberOfAttributes(relation))
    1492           0 :         elog(ERROR, "relnatts disagrees with indnatts for index %u",
    1493             :              RelationGetRelid(relation));
    1494      635900 :     indnkeyatts = IndexRelationGetNumberOfKeyAttributes(relation);
    1495             : 
    1496             :     /*
    1497             :      * Make the private context to hold index access info.  The reason we need
    1498             :      * a context, and not just a couple of pallocs, is so that we won't leak
    1499             :      * any subsidiary info attached to fmgr lookup records.
    1500             :      */
    1501      635900 :     indexcxt = AllocSetContextCreate(CacheMemoryContext,
    1502             :                                      "index info",
    1503             :                                      ALLOCSET_SMALL_SIZES);
    1504      635900 :     relation->rd_indexcxt = indexcxt;
    1505      635900 :     MemoryContextCopyAndSetIdentifier(indexcxt,
    1506             :                                       RelationGetRelationName(relation));
    1507             : 
    1508             :     /*
    1509             :      * Now we can fetch the index AM's API struct
    1510             :      */
    1511      635900 :     InitIndexAmRoutine(relation);
    1512             : 
    1513             :     /*
    1514             :      * Allocate arrays to hold data. Opclasses are not used for included
    1515             :      * columns, so allocate them for indnkeyatts only.
    1516             :      */
    1517      635900 :     relation->rd_opfamily = (Oid *)
    1518      635900 :         MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
    1519      635900 :     relation->rd_opcintype = (Oid *)
    1520      635900 :         MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
    1521             : 
    1522      635900 :     amsupport = relation->rd_indam->amsupport;
    1523      635900 :     if (amsupport > 0)
    1524             :     {
    1525      635900 :         int         nsupport = indnatts * amsupport;
    1526             : 
    1527      635900 :         relation->rd_support = (RegProcedure *)
    1528      635900 :             MemoryContextAllocZero(indexcxt, nsupport * sizeof(RegProcedure));
    1529      635900 :         relation->rd_supportinfo = (FmgrInfo *)
    1530      635900 :             MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
    1531             :     }
    1532             :     else
    1533             :     {
    1534           0 :         relation->rd_support = NULL;
    1535           0 :         relation->rd_supportinfo = NULL;
    1536             :     }
    1537             : 
    1538      635900 :     relation->rd_indcollation = (Oid *)
    1539      635900 :         MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(Oid));
    1540             : 
    1541      635900 :     relation->rd_indoption = (int16 *)
    1542      635900 :         MemoryContextAllocZero(indexcxt, indnkeyatts * sizeof(int16));
    1543             : 
    1544             :     /*
    1545             :      * indcollation cannot be referenced directly through the C struct,
    1546             :      * because it comes after the variable-width indkey field.  Must extract
    1547             :      * the datum the hard way...
    1548             :      */
    1549      635900 :     indcollDatum = fastgetattr(relation->rd_indextuple,
    1550             :                                Anum_pg_index_indcollation,
    1551             :                                GetPgIndexDescriptor(),
    1552             :                                &isnull);
    1553             :     Assert(!isnull);
    1554      635900 :     indcoll = (oidvector *) DatumGetPointer(indcollDatum);
    1555      635900 :     memcpy(relation->rd_indcollation, indcoll->values, indnkeyatts * sizeof(Oid));
    1556             : 
    1557             :     /*
    1558             :      * indclass cannot be referenced directly through the C struct, because it
    1559             :      * comes after the variable-width indkey field.  Must extract the datum
    1560             :      * the hard way...
    1561             :      */
    1562      635900 :     indclassDatum = fastgetattr(relation->rd_indextuple,
    1563             :                                 Anum_pg_index_indclass,
    1564             :                                 GetPgIndexDescriptor(),
    1565             :                                 &isnull);
    1566             :     Assert(!isnull);
    1567      635900 :     indclass = (oidvector *) DatumGetPointer(indclassDatum);
    1568             : 
    1569             :     /*
    1570             :      * Fill the support procedure OID array, as well as the info about
    1571             :      * opfamilies and opclass input types.  (aminfo and supportinfo are left
    1572             :      * as zeroes, and are filled on-the-fly when used)
    1573             :      */
    1574      635900 :     IndexSupportInitialize(indclass, relation->rd_support,
    1575             :                            relation->rd_opfamily, relation->rd_opcintype,
    1576             :                            amsupport, indnkeyatts);
    1577             : 
    1578             :     /*
    1579             :      * Similarly extract indoption and copy it to the cache entry
    1580             :      */
    1581      635898 :     indoptionDatum = fastgetattr(relation->rd_indextuple,
    1582             :                                  Anum_pg_index_indoption,
    1583             :                                  GetPgIndexDescriptor(),
    1584             :                                  &isnull);
    1585             :     Assert(!isnull);
    1586      635898 :     indoption = (int2vector *) DatumGetPointer(indoptionDatum);
    1587      635898 :     memcpy(relation->rd_indoption, indoption->values, indnkeyatts * sizeof(int16));
    1588             : 
    1589      635898 :     (void) RelationGetIndexAttOptions(relation, false);
    1590             : 
    1591             :     /*
    1592             :      * expressions, predicate, exclusion caches will be filled later
    1593             :      */
    1594      635892 :     relation->rd_indexprs = NIL;
    1595      635892 :     relation->rd_indpred = NIL;
    1596      635892 :     relation->rd_exclops = NULL;
    1597      635892 :     relation->rd_exclprocs = NULL;
    1598      635892 :     relation->rd_exclstrats = NULL;
    1599      635892 :     relation->rd_amcache = NULL;
    1600      635892 : }
    1601             : 
    1602             : /*
    1603             :  * IndexSupportInitialize
    1604             :  *      Initializes an index's cached opclass information,
    1605             :  *      given the index's pg_index.indclass entry.
    1606             :  *
    1607             :  * Data is returned into *indexSupport, *opFamily, and *opcInType,
    1608             :  * which are arrays allocated by the caller.
    1609             :  *
    1610             :  * The caller also passes maxSupportNumber and maxAttributeNumber, since these
    1611             :  * indicate the size of the arrays it has allocated --- but in practice these
    1612             :  * numbers must always match those obtainable from the system catalog entries
    1613             :  * for the index and access method.
    1614             :  */
    1615             : static void
    1616      635900 : IndexSupportInitialize(oidvector *indclass,
    1617             :                        RegProcedure *indexSupport,
    1618             :                        Oid *opFamily,
    1619             :                        Oid *opcInType,
    1620             :                        StrategyNumber maxSupportNumber,
    1621             :                        AttrNumber maxAttributeNumber)
    1622             : {
    1623             :     int         attIndex;
    1624             : 
    1625     1719468 :     for (attIndex = 0; attIndex < maxAttributeNumber; attIndex++)
    1626             :     {
    1627             :         OpClassCacheEnt *opcentry;
    1628             : 
    1629     1083570 :         if (!OidIsValid(indclass->values[attIndex]))
    1630           0 :             elog(ERROR, "bogus pg_index tuple");
    1631             : 
    1632             :         /* look up the info for this opclass, using a cache */
    1633     1083570 :         opcentry = LookupOpclassInfo(indclass->values[attIndex],
    1634             :                                      maxSupportNumber);
    1635             : 
    1636             :         /* copy cached data into relcache entry */
    1637     1083568 :         opFamily[attIndex] = opcentry->opcfamily;
    1638     1083568 :         opcInType[attIndex] = opcentry->opcintype;
    1639     1083568 :         if (maxSupportNumber > 0)
    1640     1083568 :             memcpy(&indexSupport[attIndex * maxSupportNumber],
    1641     1083568 :                    opcentry->supportProcs,
    1642             :                    maxSupportNumber * sizeof(RegProcedure));
    1643             :     }
    1644      635898 : }
    1645             : 
    1646             : /*
    1647             :  * LookupOpclassInfo
    1648             :  *
    1649             :  * This routine maintains a per-opclass cache of the information needed
    1650             :  * by IndexSupportInitialize().  This is more efficient than relying on
    1651             :  * the catalog cache, because we can load all the info about a particular
    1652             :  * opclass in a single indexscan of pg_amproc.
    1653             :  *
    1654             :  * The information from pg_am about expected range of support function
    1655             :  * numbers is passed in, rather than being looked up, mainly because the
    1656             :  * caller will have it already.
    1657             :  *
    1658             :  * Note there is no provision for flushing the cache.  This is OK at the
    1659             :  * moment because there is no way to ALTER any interesting properties of an
    1660             :  * existing opclass --- all you can do is drop it, which will result in
    1661             :  * a useless but harmless dead entry in the cache.  To support altering
    1662             :  * opclass membership (not the same as opfamily membership!), we'd need to
    1663             :  * be able to flush this cache as well as the contents of relcache entries
    1664             :  * for indexes.
    1665             :  */
    1666             : static OpClassCacheEnt *
    1667     1083570 : LookupOpclassInfo(Oid operatorClassOid,
    1668             :                   StrategyNumber numSupport)
    1669             : {
    1670             :     OpClassCacheEnt *opcentry;
    1671             :     bool        found;
    1672             :     Relation    rel;
    1673             :     SysScanDesc scan;
    1674             :     ScanKeyData skey[3];
    1675             :     HeapTuple   htup;
    1676             :     bool        indexOK;
    1677             : 
    1678     1083570 :     if (OpClassCache == NULL)
    1679             :     {
    1680             :         /* First time through: initialize the opclass cache */
    1681             :         HASHCTL     ctl;
    1682             : 
    1683             :         /* Also make sure CacheMemoryContext exists */
    1684       32730 :         if (!CacheMemoryContext)
    1685           0 :             CreateCacheMemoryContext();
    1686             : 
    1687       32730 :         ctl.keysize = sizeof(Oid);
    1688       32730 :         ctl.entrysize = sizeof(OpClassCacheEnt);
    1689       32730 :         OpClassCache = hash_create("Operator class cache", 64,
    1690             :                                    &ctl, HASH_ELEM | HASH_BLOBS);
    1691             :     }
    1692             : 
    1693     1083570 :     opcentry = (OpClassCacheEnt *) hash_search(OpClassCache,
    1694             :                                                &operatorClassOid,
    1695             :                                                HASH_ENTER, &found);
    1696             : 
    1697     1083570 :     if (!found)
    1698             :     {
    1699             :         /* Initialize new entry */
    1700       94974 :         opcentry->valid = false; /* until known OK */
    1701       94974 :         opcentry->numSupport = numSupport;
    1702       94974 :         opcentry->supportProcs = NULL;   /* filled below */
    1703             :     }
    1704             :     else
    1705             :     {
    1706             :         Assert(numSupport == opcentry->numSupport);
    1707             :     }
    1708             : 
    1709             :     /*
    1710             :      * When aggressively testing cache-flush hazards, we disable the operator
    1711             :      * class cache and force reloading of the info on each call.  This models
    1712             :      * no real-world behavior, since the cache entries are never invalidated
    1713             :      * otherwise.  However it can be helpful for detecting bugs in the cache
    1714             :      * loading logic itself, such as reliance on a non-nailed index.  Given
    1715             :      * the limited use-case and the fact that this adds a great deal of
    1716             :      * expense, we enable it only for high values of debug_discard_caches.
    1717             :      */
    1718             : #ifdef DISCARD_CACHES_ENABLED
    1719             :     if (debug_discard_caches > 2)
    1720             :         opcentry->valid = false;
    1721             : #endif
    1722             : 
    1723     1083570 :     if (opcentry->valid)
    1724      988596 :         return opcentry;
    1725             : 
    1726             :     /*
    1727             :      * Need to fill in new entry.  First allocate space, unless we already did
    1728             :      * so in some previous attempt.
    1729             :      */
    1730       94974 :     if (opcentry->supportProcs == NULL && numSupport > 0)
    1731       94974 :         opcentry->supportProcs = (RegProcedure *)
    1732       94974 :             MemoryContextAllocZero(CacheMemoryContext,
    1733             :                                    numSupport * sizeof(RegProcedure));
    1734             : 
    1735             :     /*
    1736             :      * To avoid infinite recursion during startup, force heap scans if we're
    1737             :      * looking up info for the opclasses used by the indexes we would like to
    1738             :      * reference here.
    1739             :      */
    1740      104978 :     indexOK = criticalRelcachesBuilt ||
    1741       10004 :         (operatorClassOid != OID_BTREE_OPS_OID &&
    1742        6864 :          operatorClassOid != INT2_BTREE_OPS_OID);
    1743             : 
    1744             :     /*
    1745             :      * We have to fetch the pg_opclass row to determine its opfamily and
    1746             :      * opcintype, which are needed to look up related operators and functions.
    1747             :      * It'd be convenient to use the syscache here, but that probably doesn't
    1748             :      * work while bootstrapping.
    1749             :      */
    1750       94974 :     ScanKeyInit(&skey[0],
    1751             :                 Anum_pg_opclass_oid,
    1752             :                 BTEqualStrategyNumber, F_OIDEQ,
    1753             :                 ObjectIdGetDatum(operatorClassOid));
    1754       94974 :     rel = table_open(OperatorClassRelationId, AccessShareLock);
    1755       94974 :     scan = systable_beginscan(rel, OpclassOidIndexId, indexOK,
    1756             :                               NULL, 1, skey);
    1757             : 
    1758       94974 :     if (HeapTupleIsValid(htup = systable_getnext(scan)))
    1759             :     {
    1760       94974 :         Form_pg_opclass opclassform = (Form_pg_opclass) GETSTRUCT(htup);
    1761             : 
    1762       94974 :         opcentry->opcfamily = opclassform->opcfamily;
    1763       94974 :         opcentry->opcintype = opclassform->opcintype;
    1764             :     }
    1765             :     else
    1766           0 :         elog(ERROR, "could not find tuple for opclass %u", operatorClassOid);
    1767             : 
    1768       94974 :     systable_endscan(scan);
    1769       94974 :     table_close(rel, AccessShareLock);
    1770             : 
    1771             :     /*
    1772             :      * Scan pg_amproc to obtain support procs for the opclass.  We only fetch
    1773             :      * the default ones (those with lefttype = righttype = opcintype).
    1774             :      */
    1775       94974 :     if (numSupport > 0)
    1776             :     {
    1777       94974 :         ScanKeyInit(&skey[0],
    1778             :                     Anum_pg_amproc_amprocfamily,
    1779             :                     BTEqualStrategyNumber, F_OIDEQ,
    1780             :                     ObjectIdGetDatum(opcentry->opcfamily));
    1781       94974 :         ScanKeyInit(&skey[1],
    1782             :                     Anum_pg_amproc_amproclefttype,
    1783             :                     BTEqualStrategyNumber, F_OIDEQ,
    1784             :                     ObjectIdGetDatum(opcentry->opcintype));
    1785       94974 :         ScanKeyInit(&skey[2],
    1786             :                     Anum_pg_amproc_amprocrighttype,
    1787             :                     BTEqualStrategyNumber, F_OIDEQ,
    1788             :                     ObjectIdGetDatum(opcentry->opcintype));
    1789       94974 :         rel = table_open(AccessMethodProcedureRelationId, AccessShareLock);
    1790       94974 :         scan = systable_beginscan(rel, AccessMethodProcedureIndexId, indexOK,
    1791             :                                   NULL, 3, skey);
    1792             : 
    1793      455888 :         while (HeapTupleIsValid(htup = systable_getnext(scan)))
    1794             :         {
    1795      360914 :             Form_pg_amproc amprocform = (Form_pg_amproc) GETSTRUCT(htup);
    1796             : 
    1797      360914 :             if (amprocform->amprocnum <= 0 ||
    1798      360914 :                 (StrategyNumber) amprocform->amprocnum > numSupport)
    1799           0 :                 elog(ERROR, "invalid amproc number %d for opclass %u",
    1800             :                      amprocform->amprocnum, operatorClassOid);
    1801             : 
    1802      360914 :             opcentry->supportProcs[amprocform->amprocnum - 1] =
    1803      360914 :                 amprocform->amproc;
    1804             :         }
    1805             : 
    1806       94972 :         systable_endscan(scan);
    1807       94972 :         table_close(rel, AccessShareLock);
    1808             :     }
    1809             : 
    1810       94972 :     opcentry->valid = true;
    1811       94972 :     return opcentry;
    1812             : }
    1813             : 
    1814             : /*
    1815             :  * Fill in the TableAmRoutine for a relation
    1816             :  *
    1817             :  * relation's rd_amhandler must be valid already.
    1818             :  */
    1819             : static void
    1820     2405002 : InitTableAmRoutine(Relation relation)
    1821             : {
    1822     2405002 :     relation->rd_tableam = GetTableAmRoutine(relation->rd_amhandler);
    1823     2405002 : }
    1824             : 
    1825             : /*
    1826             :  * Initialize table access method support for a table like relation
    1827             :  */
    1828             : void
    1829     2405002 : RelationInitTableAccessMethod(Relation relation)
    1830             : {
    1831             :     HeapTuple   tuple;
    1832             :     Form_pg_am  aform;
    1833             : 
    1834     2405002 :     if (relation->rd_rel->relkind == RELKIND_SEQUENCE)
    1835             :     {
    1836             :         /*
    1837             :          * Sequences are currently accessed like heap tables, but it doesn't
    1838             :          * seem prudent to show that in the catalog. So just overwrite it
    1839             :          * here.
    1840             :          */
    1841             :         Assert(relation->rd_rel->relam == InvalidOid);
    1842        8598 :         relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
    1843             :     }
    1844     2396404 :     else if (IsCatalogRelation(relation))
    1845             :     {
    1846             :         /*
    1847             :          * Avoid doing a syscache lookup for catalog tables.
    1848             :          */
    1849             :         Assert(relation->rd_rel->relam == HEAP_TABLE_AM_OID);
    1850     1919312 :         relation->rd_amhandler = F_HEAP_TABLEAM_HANDLER;
    1851             :     }
    1852             :     else
    1853             :     {
    1854             :         /*
    1855             :          * Look up the table access method, save the OID of its handler
    1856             :          * function.
    1857             :          */
    1858             :         Assert(relation->rd_rel->relam != InvalidOid);
    1859      477092 :         tuple = SearchSysCache1(AMOID,
    1860      477092 :                                 ObjectIdGetDatum(relation->rd_rel->relam));
    1861      477092 :         if (!HeapTupleIsValid(tuple))
    1862           0 :             elog(ERROR, "cache lookup failed for access method %u",
    1863             :                  relation->rd_rel->relam);
    1864      477092 :         aform = (Form_pg_am) GETSTRUCT(tuple);
    1865      477092 :         relation->rd_amhandler = aform->amhandler;
    1866      477092 :         ReleaseSysCache(tuple);
    1867             :     }
    1868             : 
    1869             :     /*
    1870             :      * Now we can fetch the table AM's API struct
    1871             :      */
    1872     2405002 :     InitTableAmRoutine(relation);
    1873     2405002 : }
    1874             : 
    1875             : /*
    1876             :  *      formrdesc
    1877             :  *
    1878             :  *      This is a special cut-down version of RelationBuildDesc(),
    1879             :  *      used while initializing the relcache.
    1880             :  *      The relation descriptor is built just from the supplied parameters,
    1881             :  *      without actually looking at any system table entries.  We cheat
    1882             :  *      quite a lot since we only need to work for a few basic system
    1883             :  *      catalogs.
    1884             :  *
    1885             :  * The catalogs this is used for can't have constraints (except attnotnull),
    1886             :  * default values, rules, or triggers, since we don't cope with any of that.
    1887             :  * (Well, actually, this only matters for properties that need to be valid
    1888             :  * during bootstrap or before RelationCacheInitializePhase3 runs, and none of
    1889             :  * these properties matter then...)
    1890             :  *
    1891             :  * NOTE: we assume we are already switched into CacheMemoryContext.
    1892             :  */
    1893             : static void
    1894       33680 : formrdesc(const char *relationName, Oid relationReltype,
    1895             :           bool isshared,
    1896             :           int natts, const FormData_pg_attribute *attrs)
    1897             : {
    1898             :     Relation    relation;
    1899             :     int         i;
    1900             :     bool        has_not_null;
    1901             : 
    1902             :     /*
    1903             :      * allocate new relation desc, clear all fields of reldesc
    1904             :      */
    1905       33680 :     relation = (Relation) palloc0(sizeof(RelationData));
    1906             : 
    1907             :     /* make sure relation is marked as having no open file yet */
    1908       33680 :     relation->rd_smgr = NULL;
    1909             : 
    1910             :     /*
    1911             :      * initialize reference count: 1 because it is nailed in cache
    1912             :      */
    1913       33680 :     relation->rd_refcnt = 1;
    1914             : 
    1915             :     /*
    1916             :      * all entries built with this routine are nailed-in-cache; none are for
    1917             :      * new or temp relations.
    1918             :      */
    1919       33680 :     relation->rd_isnailed = true;
    1920       33680 :     relation->rd_createSubid = InvalidSubTransactionId;
    1921       33680 :     relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    1922       33680 :     relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    1923       33680 :     relation->rd_droppedSubid = InvalidSubTransactionId;
    1924       33680 :     relation->rd_backend = INVALID_PROC_NUMBER;
    1925       33680 :     relation->rd_islocaltemp = false;
    1926             : 
    1927             :     /*
    1928             :      * initialize relation tuple form
    1929             :      *
    1930             :      * The data we insert here is pretty incomplete/bogus, but it'll serve to
    1931             :      * get us launched.  RelationCacheInitializePhase3() will read the real
    1932             :      * data from pg_class and replace what we've done here.  Note in
    1933             :      * particular that relowner is left as zero; this cues
    1934             :      * RelationCacheInitializePhase3 that the real data isn't there yet.
    1935             :      */
    1936       33680 :     relation->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);
    1937             : 
    1938       33680 :     namestrcpy(&relation->rd_rel->relname, relationName);
    1939       33680 :     relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
    1940       33680 :     relation->rd_rel->reltype = relationReltype;
    1941             : 
    1942             :     /*
    1943             :      * It's important to distinguish between shared and non-shared relations,
    1944             :      * even at bootstrap time, to make sure we know where they are stored.
    1945             :      */
    1946       33680 :     relation->rd_rel->relisshared = isshared;
    1947       33680 :     if (isshared)
    1948       21120 :         relation->rd_rel->reltablespace = GLOBALTABLESPACE_OID;
    1949             : 
    1950             :     /* formrdesc is used only for permanent relations */
    1951       33680 :     relation->rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;
    1952             : 
    1953             :     /* ... and they're always populated, too */
    1954       33680 :     relation->rd_rel->relispopulated = true;
    1955             : 
    1956       33680 :     relation->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
    1957       33680 :     relation->rd_rel->relpages = 0;
    1958       33680 :     relation->rd_rel->reltuples = -1;
    1959       33680 :     relation->rd_rel->relallvisible = 0;
    1960       33680 :     relation->rd_rel->relallfrozen = 0;
    1961       33680 :     relation->rd_rel->relkind = RELKIND_RELATION;
    1962       33680 :     relation->rd_rel->relnatts = (int16) natts;
    1963             : 
    1964             :     /*
    1965             :      * initialize attribute tuple form
    1966             :      *
    1967             :      * Unlike the case with the relation tuple, this data had better be right
    1968             :      * because it will never be replaced.  The data comes from
    1969             :      * src/include/catalog/ headers via genbki.pl.
    1970             :      */
    1971       33680 :     relation->rd_att = CreateTemplateTupleDesc(natts);
    1972       33680 :     relation->rd_att->tdrefcount = 1; /* mark as refcounted */
    1973             : 
    1974       33680 :     relation->rd_att->tdtypeid = relationReltype;
    1975       33680 :     relation->rd_att->tdtypmod = -1;  /* just to be sure */
    1976             : 
    1977             :     /*
    1978             :      * initialize tuple desc info
    1979             :      */
    1980       33680 :     has_not_null = false;
    1981      662836 :     for (i = 0; i < natts; i++)
    1982             :     {
    1983     1258312 :         memcpy(TupleDescAttr(relation->rd_att, i),
    1984      629156 :                &attrs[i],
    1985             :                ATTRIBUTE_FIXED_PART_SIZE);
    1986      629156 :         has_not_null |= attrs[i].attnotnull;
    1987             : 
    1988      629156 :         populate_compact_attribute(relation->rd_att, i);
    1989             :     }
    1990             : 
    1991             :     /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
    1992       33680 :     TupleDescCompactAttr(relation->rd_att, 0)->attcacheoff = 0;
    1993             : 
    1994             :     /* mark not-null status */
    1995       33680 :     if (has_not_null)
    1996             :     {
    1997       33680 :         TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
    1998             : 
    1999       33680 :         constr->has_not_null = true;
    2000       33680 :         relation->rd_att->constr = constr;
    2001             :     }
    2002             : 
    2003             :     /*
    2004             :      * initialize relation id from info in att array (my, this is ugly)
    2005             :      */
    2006       33680 :     RelationGetRelid(relation) = TupleDescAttr(relation->rd_att, 0)->attrelid;
    2007             : 
    2008             :     /*
    2009             :      * All relations made with formrdesc are mapped.  This is necessarily so
    2010             :      * because there is no other way to know what filenumber they currently
    2011             :      * have.  In bootstrap mode, add them to the initial relation mapper data,
    2012             :      * specifying that the initial filenumber is the same as the OID.
    2013             :      */
    2014       33680 :     relation->rd_rel->relfilenode = InvalidRelFileNumber;
    2015       33680 :     if (IsBootstrapProcessingMode())
    2016         392 :         RelationMapUpdateMap(RelationGetRelid(relation),
    2017             :                              RelationGetRelid(relation),
    2018             :                              isshared, true);
    2019             : 
    2020             :     /*
    2021             :      * initialize the relation lock manager information
    2022             :      */
    2023       33680 :     RelationInitLockInfo(relation); /* see lmgr.c */
    2024             : 
    2025             :     /*
    2026             :      * initialize physical addressing information for the relation
    2027             :      */
    2028       33680 :     RelationInitPhysicalAddr(relation);
    2029             : 
    2030             :     /*
    2031             :      * initialize the table am handler
    2032             :      */
    2033       33680 :     relation->rd_rel->relam = HEAP_TABLE_AM_OID;
    2034       33680 :     relation->rd_tableam = GetHeapamTableAmRoutine();
    2035             : 
    2036             :     /*
    2037             :      * initialize the rel-has-index flag, using hardwired knowledge
    2038             :      */
    2039       33680 :     if (IsBootstrapProcessingMode())
    2040             :     {
    2041             :         /* In bootstrap mode, we have no indexes */
    2042         392 :         relation->rd_rel->relhasindex = false;
    2043             :     }
    2044             :     else
    2045             :     {
    2046             :         /* Otherwise, all the rels formrdesc is used for have indexes */
    2047       33288 :         relation->rd_rel->relhasindex = true;
    2048             :     }
    2049             : 
    2050             :     /*
    2051             :      * add new reldesc to relcache
    2052             :      */
    2053       33680 :     RelationCacheInsert(relation, false);
    2054             : 
    2055             :     /* It's fully valid */
    2056       33680 :     relation->rd_isvalid = true;
    2057       33680 : }
    2058             : 
    2059             : #ifdef USE_ASSERT_CHECKING
    2060             : /*
    2061             :  *      AssertCouldGetRelation
    2062             :  *
    2063             :  *      Check safety of calling RelationIdGetRelation().
    2064             :  *
    2065             :  *      In code that reads catalogs in the event of a cache miss, call this
    2066             :  *      before checking the cache.
    2067             :  */
    2068             : void
    2069             : AssertCouldGetRelation(void)
    2070             : {
    2071             :     Assert(IsTransactionState());
    2072             :     AssertBufferLocksPermitCatalogRead();
    2073             : }
    2074             : #endif
    2075             : 
    2076             : 
    2077             : /* ----------------------------------------------------------------
    2078             :  *               Relation Descriptor Lookup Interface
    2079             :  * ----------------------------------------------------------------
    2080             :  */
    2081             : 
    2082             : /*
    2083             :  *      RelationIdGetRelation
    2084             :  *
    2085             :  *      Lookup a reldesc by OID; make one if not already in cache.
    2086             :  *
    2087             :  *      Returns NULL if no pg_class row could be found for the given relid
    2088             :  *      (suggesting we are trying to access a just-deleted relation).
    2089             :  *      Any other error is reported via elog.
    2090             :  *
    2091             :  *      NB: caller should already have at least AccessShareLock on the
    2092             :  *      relation ID, else there are nasty race conditions.
    2093             :  *
    2094             :  *      NB: relation ref count is incremented, or set to 1 if new entry.
    2095             :  *      Caller should eventually decrement count.  (Usually,
    2096             :  *      that happens by calling RelationClose().)
    2097             :  */
    2098             : Relation
    2099    42243600 : RelationIdGetRelation(Oid relationId)
    2100             : {
    2101             :     Relation    rd;
    2102             : 
    2103    42243600 :     AssertCouldGetRelation();
    2104             : 
    2105             :     /*
    2106             :      * first try to find reldesc in the cache
    2107             :      */
    2108    42243600 :     RelationIdCacheLookup(relationId, rd);
    2109             : 
    2110    42243600 :     if (RelationIsValid(rd))
    2111             :     {
    2112             :         /* return NULL for dropped relations */
    2113    41147806 :         if (rd->rd_droppedSubid != InvalidSubTransactionId)
    2114             :         {
    2115             :             Assert(!rd->rd_isvalid);
    2116           4 :             return NULL;
    2117             :         }
    2118             : 
    2119    41147802 :         RelationIncrementReferenceCount(rd);
    2120             :         /* revalidate cache entry if necessary */
    2121    41147802 :         if (!rd->rd_isvalid)
    2122             :         {
    2123      168776 :             RelationRebuildRelation(rd);
    2124             : 
    2125             :             /*
    2126             :              * Normally entries need to be valid here, but before the relcache
    2127             :              * has been initialized, not enough infrastructure exists to
    2128             :              * perform pg_class lookups. The structure of such entries doesn't
    2129             :              * change, but we still want to update the rd_rel entry. So
    2130             :              * rd_isvalid = false is left in place for a later lookup.
    2131             :              */
    2132             :             Assert(rd->rd_isvalid ||
    2133             :                    (rd->rd_isnailed && !criticalRelcachesBuilt));
    2134             :         }
    2135    41147790 :         return rd;
    2136             :     }
    2137             : 
    2138             :     /*
    2139             :      * no reldesc in the cache, so have RelationBuildDesc() build one and add
    2140             :      * it.
    2141             :      */
    2142     1095794 :     rd = RelationBuildDesc(relationId, true);
    2143     1095794 :     if (RelationIsValid(rd))
    2144     1095784 :         RelationIncrementReferenceCount(rd);
    2145     1095794 :     return rd;
    2146             : }
    2147             : 
    2148             : /* ----------------------------------------------------------------
    2149             :  *              cache invalidation support routines
    2150             :  * ----------------------------------------------------------------
    2151             :  */
    2152             : 
    2153             : /* ResourceOwner callbacks to track relcache references */
    2154             : static void ResOwnerReleaseRelation(Datum res);
    2155             : static char *ResOwnerPrintRelCache(Datum res);
    2156             : 
    2157             : static const ResourceOwnerDesc relref_resowner_desc =
    2158             : {
    2159             :     .name = "relcache reference",
    2160             :     .release_phase = RESOURCE_RELEASE_BEFORE_LOCKS,
    2161             :     .release_priority = RELEASE_PRIO_RELCACHE_REFS,
    2162             :     .ReleaseResource = ResOwnerReleaseRelation,
    2163             :     .DebugPrint = ResOwnerPrintRelCache
    2164             : };
    2165             : 
    2166             : /* Convenience wrappers over ResourceOwnerRemember/Forget */
    2167             : static inline void
    2168    62357926 : ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel)
    2169             : {
    2170    62357926 :     ResourceOwnerRemember(owner, PointerGetDatum(rel), &relref_resowner_desc);
    2171    62357926 : }
    2172             : static inline void
    2173    62314546 : ResourceOwnerForgetRelationRef(ResourceOwner owner, Relation rel)
    2174             : {
    2175    62314546 :     ResourceOwnerForget(owner, PointerGetDatum(rel), &relref_resowner_desc);
    2176    62314546 : }
    2177             : 
    2178             : /*
    2179             :  * RelationIncrementReferenceCount
    2180             :  *      Increments relation reference count.
    2181             :  *
    2182             :  * Note: bootstrap mode has its own weird ideas about relation refcount
    2183             :  * behavior; we ought to fix it someday, but for now, just disable
    2184             :  * reference count ownership tracking in bootstrap mode.
    2185             :  */
    2186             : void
    2187    62910058 : RelationIncrementReferenceCount(Relation rel)
    2188             : {
    2189    62910058 :     ResourceOwnerEnlarge(CurrentResourceOwner);
    2190    62910058 :     rel->rd_refcnt += 1;
    2191    62910058 :     if (!IsBootstrapProcessingMode())
    2192    62357926 :         ResourceOwnerRememberRelationRef(CurrentResourceOwner, rel);
    2193    62910058 : }
    2194             : 
    2195             : /*
    2196             :  * RelationDecrementReferenceCount
    2197             :  *      Decrements relation reference count.
    2198             :  */
    2199             : void
    2200    62866678 : RelationDecrementReferenceCount(Relation rel)
    2201             : {
    2202             :     Assert(rel->rd_refcnt > 0);
    2203    62866678 :     rel->rd_refcnt -= 1;
    2204    62866678 :     if (!IsBootstrapProcessingMode())
    2205    62314546 :         ResourceOwnerForgetRelationRef(CurrentResourceOwner, rel);
    2206    62866678 : }
    2207             : 
    2208             : /*
    2209             :  * RelationClose - close an open relation
    2210             :  *
    2211             :  *  Actually, we just decrement the refcount.
    2212             :  *
    2213             :  *  NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries
    2214             :  *  will be freed as soon as their refcount goes to zero.  In combination
    2215             :  *  with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
    2216             :  *  to catch references to already-released relcache entries.  It slows
    2217             :  *  things down quite a bit, however.
    2218             :  */
    2219             : void
    2220    42345116 : RelationClose(Relation relation)
    2221             : {
    2222             :     /* Note: no locking manipulations needed */
    2223    42345116 :     RelationDecrementReferenceCount(relation);
    2224             : 
    2225    42345116 :     RelationCloseCleanup(relation);
    2226    42345116 : }
    2227             : 
    2228             : static void
    2229    42388496 : RelationCloseCleanup(Relation relation)
    2230             : {
    2231             :     /*
    2232             :      * If the relation is no longer open in this session, we can clean up any
    2233             :      * stale partition descriptors it has.  This is unlikely, so check to see
    2234             :      * if there are child contexts before expending a call to mcxt.c.
    2235             :      */
    2236    42388496 :     if (RelationHasReferenceCountZero(relation))
    2237             :     {
    2238    24508474 :         if (relation->rd_pdcxt != NULL &&
    2239      104018 :             relation->rd_pdcxt->firstchild != NULL)
    2240        4510 :             MemoryContextDeleteChildren(relation->rd_pdcxt);
    2241             : 
    2242    24508474 :         if (relation->rd_pddcxt != NULL &&
    2243         108 :             relation->rd_pddcxt->firstchild != NULL)
    2244           0 :             MemoryContextDeleteChildren(relation->rd_pddcxt);
    2245             :     }
    2246             : 
    2247             : #ifdef RELCACHE_FORCE_RELEASE
    2248             :     if (RelationHasReferenceCountZero(relation) &&
    2249             :         relation->rd_createSubid == InvalidSubTransactionId &&
    2250             :         relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)
    2251             :         RelationClearRelation(relation);
    2252             : #endif
    2253    42388496 : }
    2254             : 
    2255             : /*
    2256             :  * RelationReloadIndexInfo - reload minimal information for an open index
    2257             :  *
    2258             :  *  This function is used only for indexes.  A relcache inval on an index
    2259             :  *  can mean that its pg_class or pg_index row changed.  There are only
    2260             :  *  very limited changes that are allowed to an existing index's schema,
    2261             :  *  so we can update the relcache entry without a complete rebuild; which
    2262             :  *  is fortunate because we can't rebuild an index entry that is "nailed"
    2263             :  *  and/or in active use.  We support full replacement of the pg_class row,
    2264             :  *  as well as updates of a few simple fields of the pg_index row.
    2265             :  *
    2266             :  *  We assume that at the time we are called, we have at least AccessShareLock
    2267             :  *  on the target index.
    2268             :  *
    2269             :  *  If the target index is an index on pg_class or pg_index, we'd better have
    2270             :  *  previously gotten at least AccessShareLock on its underlying catalog,
    2271             :  *  else we are at risk of deadlock against someone trying to exclusive-lock
    2272             :  *  the heap and index in that order.  This is ensured in current usage by
    2273             :  *  only applying this to indexes being opened or having positive refcount.
    2274             :  */
    2275             : static void
    2276      115338 : RelationReloadIndexInfo(Relation relation)
    2277             : {
    2278             :     bool        indexOK;
    2279             :     HeapTuple   pg_class_tuple;
    2280             :     Form_pg_class relp;
    2281             : 
    2282             :     /* Should be called only for invalidated, live indexes */
    2283             :     Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
    2284             :             relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
    2285             :            !relation->rd_isvalid &&
    2286             :            relation->rd_droppedSubid == InvalidSubTransactionId);
    2287             : 
    2288             :     /*
    2289             :      * If it's a shared index, we might be called before backend startup has
    2290             :      * finished selecting a database, in which case we have no way to read
    2291             :      * pg_class yet.  However, a shared index can never have any significant
    2292             :      * schema updates, so it's okay to mostly ignore the invalidation signal.
    2293             :      * Its physical relfilenumber might've changed, but that's all.  Update
    2294             :      * the physical relfilenumber, mark it valid and return without doing
    2295             :      * anything more.
    2296             :      */
    2297      115338 :     if (relation->rd_rel->relisshared && !criticalRelcachesBuilt)
    2298             :     {
    2299           0 :         RelationInitPhysicalAddr(relation);
    2300           0 :         relation->rd_isvalid = true;
    2301           0 :         return;
    2302             :     }
    2303             : 
    2304             :     /*
    2305             :      * Read the pg_class row
    2306             :      *
    2307             :      * Don't try to use an indexscan of pg_class_oid_index to reload the info
    2308             :      * for pg_class_oid_index ...
    2309             :      */
    2310      115338 :     indexOK = (RelationGetRelid(relation) != ClassOidIndexId);
    2311      115338 :     pg_class_tuple = ScanPgRelation(RelationGetRelid(relation), indexOK, false);
    2312      115332 :     if (!HeapTupleIsValid(pg_class_tuple))
    2313           0 :         elog(ERROR, "could not find pg_class tuple for index %u",
    2314             :              RelationGetRelid(relation));
    2315      115332 :     relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
    2316      115332 :     memcpy(relation->rd_rel, relp, CLASS_TUPLE_SIZE);
    2317             :     /* Reload reloptions in case they changed */
    2318      115332 :     if (relation->rd_options)
    2319        1182 :         pfree(relation->rd_options);
    2320      115332 :     RelationParseRelOptions(relation, pg_class_tuple);
    2321             :     /* done with pg_class tuple */
    2322      115332 :     heap_freetuple(pg_class_tuple);
    2323             :     /* We must recalculate physical address in case it changed */
    2324      115332 :     RelationInitPhysicalAddr(relation);
    2325             : 
    2326             :     /*
    2327             :      * For a non-system index, there are fields of the pg_index row that are
    2328             :      * allowed to change, so re-read that row and update the relcache entry.
    2329             :      * Most of the info derived from pg_index (such as support function lookup
    2330             :      * info) cannot change, and indeed the whole point of this routine is to
    2331             :      * update the relcache entry without clobbering that data; so wholesale
    2332             :      * replacement is not appropriate.
    2333             :      */
    2334      115332 :     if (!IsSystemRelation(relation))
    2335             :     {
    2336             :         HeapTuple   tuple;
    2337             :         Form_pg_index index;
    2338             : 
    2339       42642 :         tuple = SearchSysCache1(INDEXRELID,
    2340             :                                 ObjectIdGetDatum(RelationGetRelid(relation)));
    2341       42642 :         if (!HeapTupleIsValid(tuple))
    2342           0 :             elog(ERROR, "cache lookup failed for index %u",
    2343             :                  RelationGetRelid(relation));
    2344       42642 :         index = (Form_pg_index) GETSTRUCT(tuple);
    2345             : 
    2346             :         /*
    2347             :          * Basically, let's just copy all the bool fields.  There are one or
    2348             :          * two of these that can't actually change in the current code, but
    2349             :          * it's not worth it to track exactly which ones they are.  None of
    2350             :          * the array fields are allowed to change, though.
    2351             :          */
    2352       42642 :         relation->rd_index->indisunique = index->indisunique;
    2353       42642 :         relation->rd_index->indnullsnotdistinct = index->indnullsnotdistinct;
    2354       42642 :         relation->rd_index->indisprimary = index->indisprimary;
    2355       42642 :         relation->rd_index->indisexclusion = index->indisexclusion;
    2356       42642 :         relation->rd_index->indimmediate = index->indimmediate;
    2357       42642 :         relation->rd_index->indisclustered = index->indisclustered;
    2358       42642 :         relation->rd_index->indisvalid = index->indisvalid;
    2359       42642 :         relation->rd_index->indcheckxmin = index->indcheckxmin;
    2360       42642 :         relation->rd_index->indisready = index->indisready;
    2361       42642 :         relation->rd_index->indislive = index->indislive;
    2362       42642 :         relation->rd_index->indisreplident = index->indisreplident;
    2363             : 
    2364             :         /* Copy xmin too, as that is needed to make sense of indcheckxmin */
    2365       42642 :         HeapTupleHeaderSetXmin(relation->rd_indextuple->t_data,
    2366       42642 :                                HeapTupleHeaderGetXmin(tuple->t_data));
    2367             : 
    2368       42642 :         ReleaseSysCache(tuple);
    2369             :     }
    2370             : 
    2371             :     /* Okay, now it's valid again */
    2372      115332 :     relation->rd_isvalid = true;
    2373             : }
    2374             : 
    2375             : /*
    2376             :  * RelationReloadNailed - reload minimal information for nailed relations.
    2377             :  *
    2378             :  * The structure of a nailed relation can never change (which is good, because
    2379             :  * we rely on knowing their structure to be able to read catalog content). But
    2380             :  * some parts, e.g. pg_class.relfrozenxid, are still important to have
    2381             :  * accurate content for. Therefore those need to be reloaded after the arrival
    2382             :  * of invalidations.
    2383             :  */
    2384             : static void
    2385      155410 : RelationReloadNailed(Relation relation)
    2386             : {
    2387             :     /* Should be called only for invalidated, nailed relations */
    2388             :     Assert(!relation->rd_isvalid);
    2389             :     Assert(relation->rd_isnailed);
    2390             :     /* nailed indexes are handled by RelationReloadIndexInfo() */
    2391             :     Assert(relation->rd_rel->relkind == RELKIND_RELATION);
    2392      155410 :     AssertCouldGetRelation();
    2393             : 
    2394             :     /*
    2395             :      * Redo RelationInitPhysicalAddr in case it is a mapped relation whose
    2396             :      * mapping changed.
    2397             :      */
    2398      155410 :     RelationInitPhysicalAddr(relation);
    2399             : 
    2400             :     /*
    2401             :      * Reload a non-index entry.  We can't easily do so if relcaches aren't
    2402             :      * yet built, but that's fine because at that stage the attributes that
    2403             :      * need to be current (like relfrozenxid) aren't yet accessed.  To ensure
    2404             :      * the entry will later be revalidated, we leave it in invalid state, but
    2405             :      * allow use (cf. RelationIdGetRelation()).
    2406             :      */
    2407      155410 :     if (criticalRelcachesBuilt)
    2408             :     {
    2409             :         HeapTuple   pg_class_tuple;
    2410             :         Form_pg_class relp;
    2411             : 
    2412             :         /*
    2413             :          * NB: Mark the entry as valid before starting to scan, to avoid
    2414             :          * self-recursion when re-building pg_class.
    2415             :          */
    2416       31354 :         relation->rd_isvalid = true;
    2417             : 
    2418       31354 :         pg_class_tuple = ScanPgRelation(RelationGetRelid(relation),
    2419             :                                         true, false);
    2420       31348 :         relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
    2421       31348 :         memcpy(relation->rd_rel, relp, CLASS_TUPLE_SIZE);
    2422       31348 :         heap_freetuple(pg_class_tuple);
    2423             : 
    2424             :         /*
    2425             :          * Again mark as valid, to protect against concurrently arriving
    2426             :          * invalidations.
    2427             :          */
    2428       31348 :         relation->rd_isvalid = true;
    2429             :     }
    2430      155404 : }
    2431             : 
    2432             : /*
    2433             :  * RelationDestroyRelation
    2434             :  *
    2435             :  *  Physically delete a relation cache entry and all subsidiary data.
    2436             :  *  Caller must already have unhooked the entry from the hash table.
    2437             :  */
    2438             : static void
    2439     1236808 : RelationDestroyRelation(Relation relation, bool remember_tupdesc)
    2440             : {
    2441             :     Assert(RelationHasReferenceCountZero(relation));
    2442             : 
    2443             :     /*
    2444             :      * Make sure smgr and lower levels close the relation's files, if they
    2445             :      * weren't closed already.  (This was probably done by caller, but let's
    2446             :      * just be real sure.)
    2447             :      */
    2448     1236808 :     RelationCloseSmgr(relation);
    2449             : 
    2450             :     /* break mutual link with stats entry */
    2451     1236808 :     pgstat_unlink_relation(relation);
    2452             : 
    2453             :     /*
    2454             :      * Free all the subsidiary data structures of the relcache entry, then the
    2455             :      * entry itself.
    2456             :      */
    2457     1236808 :     if (relation->rd_rel)
    2458     1236808 :         pfree(relation->rd_rel);
    2459             :     /* can't use DecrTupleDescRefCount here */
    2460             :     Assert(relation->rd_att->tdrefcount > 0);
    2461     1236808 :     if (--relation->rd_att->tdrefcount == 0)
    2462             :     {
    2463             :         /*
    2464             :          * If we Rebuilt a relcache entry during a transaction then its
    2465             :          * possible we did that because the TupDesc changed as the result of
    2466             :          * an ALTER TABLE that ran at less than AccessExclusiveLock. It's
    2467             :          * possible someone copied that TupDesc, in which case the copy would
    2468             :          * point to free'd memory. So if we rebuild an entry we keep the
    2469             :          * TupDesc around until end of transaction, to be safe.
    2470             :          */
    2471     1233708 :         if (remember_tupdesc)
    2472       21784 :             RememberToFreeTupleDescAtEOX(relation->rd_att);
    2473             :         else
    2474     1211924 :             FreeTupleDesc(relation->rd_att);
    2475             :     }
    2476     1236808 :     FreeTriggerDesc(relation->trigdesc);
    2477     1236808 :     list_free_deep(relation->rd_fkeylist);
    2478     1236808 :     list_free(relation->rd_indexlist);
    2479     1236808 :     list_free(relation->rd_statlist);
    2480     1236808 :     bms_free(relation->rd_keyattr);
    2481     1236808 :     bms_free(relation->rd_pkattr);
    2482     1236808 :     bms_free(relation->rd_idattr);
    2483     1236808 :     bms_free(relation->rd_hotblockingattr);
    2484     1236808 :     bms_free(relation->rd_summarizedattr);
    2485     1236808 :     if (relation->rd_pubdesc)
    2486        6602 :         pfree(relation->rd_pubdesc);
    2487     1236808 :     if (relation->rd_options)
    2488       11052 :         pfree(relation->rd_options);
    2489     1236808 :     if (relation->rd_indextuple)
    2490      334666 :         pfree(relation->rd_indextuple);
    2491     1236808 :     if (relation->rd_amcache)
    2492           0 :         pfree(relation->rd_amcache);
    2493     1236808 :     if (relation->rd_fdwroutine)
    2494         278 :         pfree(relation->rd_fdwroutine);
    2495     1236808 :     if (relation->rd_indexcxt)
    2496      334666 :         MemoryContextDelete(relation->rd_indexcxt);
    2497     1236808 :     if (relation->rd_rulescxt)
    2498       25460 :         MemoryContextDelete(relation->rd_rulescxt);
    2499     1236808 :     if (relation->rd_rsdesc)
    2500        1888 :         MemoryContextDelete(relation->rd_rsdesc->rscxt);
    2501     1236808 :     if (relation->rd_partkeycxt)
    2502       16722 :         MemoryContextDelete(relation->rd_partkeycxt);
    2503     1236808 :     if (relation->rd_pdcxt)
    2504       16064 :         MemoryContextDelete(relation->rd_pdcxt);
    2505     1236808 :     if (relation->rd_pddcxt)
    2506          60 :         MemoryContextDelete(relation->rd_pddcxt);
    2507     1236808 :     if (relation->rd_partcheckcxt)
    2508        3396 :         MemoryContextDelete(relation->rd_partcheckcxt);
    2509     1236808 :     pfree(relation);
    2510     1236808 : }
    2511             : 
    2512             : /*
    2513             :  * RelationInvalidateRelation - mark a relation cache entry as invalid
    2514             :  *
    2515             :  * An entry that's marked as invalid will be reloaded on next access.
    2516             :  */
    2517             : static void
    2518     1634582 : RelationInvalidateRelation(Relation relation)
    2519             : {
    2520             :     /*
    2521             :      * Make sure smgr and lower levels close the relation's files, if they
    2522             :      * weren't closed already.  If the relation is not getting deleted, the
    2523             :      * next smgr access should reopen the files automatically.  This ensures
    2524             :      * that the low-level file access state is updated after, say, a vacuum
    2525             :      * truncation.
    2526             :      */
    2527     1634582 :     RelationCloseSmgr(relation);
    2528             : 
    2529             :     /* Free AM cached data, if any */
    2530     1634582 :     if (relation->rd_amcache)
    2531       67554 :         pfree(relation->rd_amcache);
    2532     1634582 :     relation->rd_amcache = NULL;
    2533             : 
    2534     1634582 :     relation->rd_isvalid = false;
    2535     1634582 : }
    2536             : 
    2537             : /*
    2538             :  * RelationClearRelation - physically blow away a relation cache entry
    2539             :  *
    2540             :  * The caller must ensure that the entry is no longer needed, i.e. its
    2541             :  * reference count is zero.  Also, the rel or its storage must not be created
    2542             :  * in the current transaction (rd_createSubid and rd_firstRelfilelocatorSubid
    2543             :  * must not be set).
    2544             :  */
    2545             : static void
    2546      803208 : RelationClearRelation(Relation relation)
    2547             : {
    2548             :     Assert(RelationHasReferenceCountZero(relation));
    2549             :     Assert(!relation->rd_isnailed);
    2550             : 
    2551             :     /*
    2552             :      * Relations created in the same transaction must never be removed, see
    2553             :      * RelationFlushRelation.
    2554             :      */
    2555             :     Assert(relation->rd_createSubid == InvalidSubTransactionId);
    2556             :     Assert(relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId);
    2557             :     Assert(relation->rd_droppedSubid == InvalidSubTransactionId);
    2558             : 
    2559             :     /* first mark it as invalid */
    2560      803208 :     RelationInvalidateRelation(relation);
    2561             : 
    2562             :     /* Remove it from the hash table */
    2563      803208 :     RelationCacheDelete(relation);
    2564             : 
    2565             :     /* And release storage */
    2566      803208 :     RelationDestroyRelation(relation, false);
    2567      803208 : }
    2568             : 
    2569             : /*
    2570             :  * RelationRebuildRelation - rebuild a relation cache entry in place
    2571             :  *
    2572             :  * Reset and rebuild a relation cache entry from scratch (that is, from
    2573             :  * catalog entries).  This is used when we are notified of a change to an open
    2574             :  * relation (one with refcount > 0).  The entry is reconstructed without
    2575             :  * moving the physical RelationData record, so that the refcount holder's
    2576             :  * pointer is still valid.
    2577             :  *
    2578             :  * NB: when rebuilding, we'd better hold some lock on the relation, else the
    2579             :  * catalog data we need to read could be changing under us.  Also, a rel to be
    2580             :  * rebuilt had better have refcnt > 0.  This is because a sinval reset could
    2581             :  * happen while we're accessing the catalogs, and the rel would get blown away
    2582             :  * underneath us by RelationCacheInvalidate if it has zero refcnt.
    2583             :  */
    2584             : static void
    2585      704332 : RelationRebuildRelation(Relation relation)
    2586             : {
    2587             :     Assert(!RelationHasReferenceCountZero(relation));
    2588      704332 :     AssertCouldGetRelation();
    2589             :     /* there is no reason to ever rebuild a dropped relation */
    2590             :     Assert(relation->rd_droppedSubid == InvalidSubTransactionId);
    2591             : 
    2592             :     /* Close and mark it as invalid until we've finished the rebuild */
    2593      704332 :     RelationInvalidateRelation(relation);
    2594             : 
    2595             :     /*
    2596             :      * Indexes only have a limited number of possible schema changes, and we
    2597             :      * don't want to use the full-blown procedure because it's a headache for
    2598             :      * indexes that reload itself depends on.
    2599             :      *
    2600             :      * As an exception, use the full procedure if the index access info hasn't
    2601             :      * been initialized yet.  Index creation relies on that: it first builds
    2602             :      * the relcache entry with RelationBuildLocalRelation(), creates the
    2603             :      * pg_index tuple only after that, and then relies on
    2604             :      * CommandCounterIncrement to load the pg_index contents.
    2605             :      */
    2606      704332 :     if ((relation->rd_rel->relkind == RELKIND_INDEX ||
    2607      561734 :          relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
    2608      148078 :         relation->rd_indexcxt != NULL)
    2609             :     {
    2610      115338 :         RelationReloadIndexInfo(relation);
    2611      115332 :         return;
    2612             :     }
    2613             :     /* Nailed relations are handled separately. */
    2614      588994 :     else if (relation->rd_isnailed)
    2615             :     {
    2616      155410 :         RelationReloadNailed(relation);
    2617      155404 :         return;
    2618             :     }
    2619             :     else
    2620             :     {
    2621             :         /*
    2622             :          * Our strategy for rebuilding an open relcache entry is to build a
    2623             :          * new entry from scratch, swap its contents with the old entry, and
    2624             :          * finally delete the new entry (along with any infrastructure swapped
    2625             :          * over from the old entry).  This is to avoid trouble in case an
    2626             :          * error causes us to lose control partway through.  The old entry
    2627             :          * will still be marked !rd_isvalid, so we'll try to rebuild it again
    2628             :          * on next access.  Meanwhile it's not any less valid than it was
    2629             :          * before, so any code that might expect to continue accessing it
    2630             :          * isn't hurt by the rebuild failure.  (Consider for example a
    2631             :          * subtransaction that ALTERs a table and then gets canceled partway
    2632             :          * through the cache entry rebuild.  The outer transaction should
    2633             :          * still see the not-modified cache entry as valid.)  The worst
    2634             :          * consequence of an error is leaking the necessarily-unreferenced new
    2635             :          * entry, and this shouldn't happen often enough for that to be a big
    2636             :          * problem.
    2637             :          *
    2638             :          * When rebuilding an open relcache entry, we must preserve ref count,
    2639             :          * rd_*Subid, and rd_toastoid state.  Also attempt to preserve the
    2640             :          * pg_class entry (rd_rel), tupledesc, rewrite-rule, partition key,
    2641             :          * and partition descriptor substructures in place, because various
    2642             :          * places assume that these structures won't move while they are
    2643             :          * working with an open relcache entry.  (Note:  the refcount
    2644             :          * mechanism for tupledescs might someday allow us to remove this hack
    2645             :          * for the tupledesc.)
    2646             :          *
    2647             :          * Note that this process does not touch CurrentResourceOwner; which
    2648             :          * is good because whatever ref counts the entry may have do not
    2649             :          * necessarily belong to that resource owner.
    2650             :          */
    2651             :         Relation    newrel;
    2652      433584 :         Oid         save_relid = RelationGetRelid(relation);
    2653             :         bool        keep_tupdesc;
    2654             :         bool        keep_rules;
    2655             :         bool        keep_policies;
    2656             :         bool        keep_partkey;
    2657             : 
    2658             :         /* Build temporary entry, but don't link it into hashtable */
    2659      433584 :         newrel = RelationBuildDesc(save_relid, false);
    2660             : 
    2661             :         /*
    2662             :          * Between here and the end of the swap, don't add code that does or
    2663             :          * reasonably could read system catalogs.  That range must be free
    2664             :          * from invalidation processing.  See RelationBuildDesc() manipulation
    2665             :          * of in_progress_list.
    2666             :          */
    2667             : 
    2668      433578 :         if (newrel == NULL)
    2669             :         {
    2670             :             /*
    2671             :              * We can validly get here, if we're using a historic snapshot in
    2672             :              * which a relation, accessed from outside logical decoding, is
    2673             :              * still invisible. In that case it's fine to just mark the
    2674             :              * relation as invalid and return - it'll fully get reloaded by
    2675             :              * the cache reset at the end of logical decoding (or at the next
    2676             :              * access).  During normal processing we don't want to ignore this
    2677             :              * case as it shouldn't happen there, as explained below.
    2678             :              */
    2679           0 :             if (HistoricSnapshotActive())
    2680           0 :                 return;
    2681             : 
    2682             :             /*
    2683             :              * This shouldn't happen as dropping a relation is intended to be
    2684             :              * impossible if still referenced (cf. CheckTableNotInUse()). But
    2685             :              * if we get here anyway, we can't just delete the relcache entry,
    2686             :              * as it possibly could get accessed later (as e.g. the error
    2687             :              * might get trapped and handled via a subtransaction rollback).
    2688             :              */
    2689           0 :             elog(ERROR, "relation %u deleted while still in use", save_relid);
    2690             :         }
    2691             : 
    2692             :         /*
    2693             :          * If we were to, again, have cases of the relkind of a relcache entry
    2694             :          * changing, we would need to ensure that pgstats does not get
    2695             :          * confused.
    2696             :          */
    2697             :         Assert(relation->rd_rel->relkind == newrel->rd_rel->relkind);
    2698             : 
    2699      433578 :         keep_tupdesc = equalTupleDescs(relation->rd_att, newrel->rd_att);
    2700      433578 :         keep_rules = equalRuleLocks(relation->rd_rules, newrel->rd_rules);
    2701      433578 :         keep_policies = equalRSDesc(relation->rd_rsdesc, newrel->rd_rsdesc);
    2702             :         /* partkey is immutable once set up, so we can always keep it */
    2703      433578 :         keep_partkey = (relation->rd_partkey != NULL);
    2704             : 
    2705             :         /*
    2706             :          * Perform swapping of the relcache entry contents.  Within this
    2707             :          * process the old entry is momentarily invalid, so there *must* be no
    2708             :          * possibility of CHECK_FOR_INTERRUPTS within this sequence. Do it in
    2709             :          * all-in-line code for safety.
    2710             :          *
    2711             :          * Since the vast majority of fields should be swapped, our method is
    2712             :          * to swap the whole structures and then re-swap those few fields we
    2713             :          * didn't want swapped.
    2714             :          */
    2715             : #define SWAPFIELD(fldtype, fldname) \
    2716             :         do { \
    2717             :             fldtype _tmp = newrel->fldname; \
    2718             :             newrel->fldname = relation->fldname; \
    2719             :             relation->fldname = _tmp; \
    2720             :         } while (0)
    2721             : 
    2722             :         /* swap all Relation struct fields */
    2723             :         {
    2724             :             RelationData tmpstruct;
    2725             : 
    2726      433578 :             memcpy(&tmpstruct, newrel, sizeof(RelationData));
    2727      433578 :             memcpy(newrel, relation, sizeof(RelationData));
    2728      433578 :             memcpy(relation, &tmpstruct, sizeof(RelationData));
    2729             :         }
    2730             : 
    2731             :         /* rd_smgr must not be swapped, due to back-links from smgr level */
    2732      433578 :         SWAPFIELD(SMgrRelation, rd_smgr);
    2733             :         /* rd_refcnt must be preserved */
    2734      433578 :         SWAPFIELD(int, rd_refcnt);
    2735             :         /* isnailed shouldn't change */
    2736             :         Assert(newrel->rd_isnailed == relation->rd_isnailed);
    2737             :         /* creation sub-XIDs must be preserved */
    2738      433578 :         SWAPFIELD(SubTransactionId, rd_createSubid);
    2739      433578 :         SWAPFIELD(SubTransactionId, rd_newRelfilelocatorSubid);
    2740      433578 :         SWAPFIELD(SubTransactionId, rd_firstRelfilelocatorSubid);
    2741      433578 :         SWAPFIELD(SubTransactionId, rd_droppedSubid);
    2742             :         /* un-swap rd_rel pointers, swap contents instead */
    2743      433578 :         SWAPFIELD(Form_pg_class, rd_rel);
    2744             :         /* ... but actually, we don't have to update newrel->rd_rel */
    2745      433578 :         memcpy(relation->rd_rel, newrel->rd_rel, CLASS_TUPLE_SIZE);
    2746             :         /* preserve old tupledesc, rules, policies if no logical change */
    2747      433578 :         if (keep_tupdesc)
    2748      411582 :             SWAPFIELD(TupleDesc, rd_att);
    2749      433578 :         if (keep_rules)
    2750             :         {
    2751      416388 :             SWAPFIELD(RuleLock *, rd_rules);
    2752      416388 :             SWAPFIELD(MemoryContext, rd_rulescxt);
    2753             :         }
    2754      433578 :         if (keep_policies)
    2755      433260 :             SWAPFIELD(RowSecurityDesc *, rd_rsdesc);
    2756             :         /* toast OID override must be preserved */
    2757      433578 :         SWAPFIELD(Oid, rd_toastoid);
    2758             :         /* pgstat_info / enabled must be preserved */
    2759      433578 :         SWAPFIELD(struct PgStat_TableStatus *, pgstat_info);
    2760      433578 :         SWAPFIELD(bool, pgstat_enabled);
    2761             :         /* preserve old partition key if we have one */
    2762      433578 :         if (keep_partkey)
    2763             :         {
    2764       15352 :             SWAPFIELD(PartitionKey, rd_partkey);
    2765       15352 :             SWAPFIELD(MemoryContext, rd_partkeycxt);
    2766             :         }
    2767      433578 :         if (newrel->rd_pdcxt != NULL || newrel->rd_pddcxt != NULL)
    2768             :         {
    2769             :             /*
    2770             :              * We are rebuilding a partitioned relation with a non-zero
    2771             :              * reference count, so we must keep the old partition descriptor
    2772             :              * around, in case there's a PartitionDirectory with a pointer to
    2773             :              * it.  This means we can't free the old rd_pdcxt yet.  (This is
    2774             :              * necessary because RelationGetPartitionDesc hands out direct
    2775             :              * pointers to the relcache's data structure, unlike our usual
    2776             :              * practice which is to hand out copies.  We'd have the same
    2777             :              * problem with rd_partkey, except that we always preserve that
    2778             :              * once created.)
    2779             :              *
    2780             :              * To ensure that it's not leaked completely, re-attach it to the
    2781             :              * new reldesc, or make it a child of the new reldesc's rd_pdcxt
    2782             :              * in the unlikely event that there is one already.  (Compare hack
    2783             :              * in RelationBuildPartitionDesc.)  RelationClose will clean up
    2784             :              * any such contexts once the reference count reaches zero.
    2785             :              *
    2786             :              * In the case where the reference count is zero, this code is not
    2787             :              * reached, which should be OK because in that case there should
    2788             :              * be no PartitionDirectory with a pointer to the old entry.
    2789             :              *
    2790             :              * Note that newrel and relation have already been swapped, so the
    2791             :              * "old" partition descriptor is actually the one hanging off of
    2792             :              * newrel.
    2793             :              */
    2794       11974 :             relation->rd_partdesc = NULL;    /* ensure rd_partdesc is invalid */
    2795       11974 :             relation->rd_partdesc_nodetached = NULL;
    2796       11974 :             relation->rd_partdesc_nodetached_xmin = InvalidTransactionId;
    2797       11974 :             if (relation->rd_pdcxt != NULL) /* probably never happens */
    2798           0 :                 MemoryContextSetParent(newrel->rd_pdcxt, relation->rd_pdcxt);
    2799             :             else
    2800       11974 :                 relation->rd_pdcxt = newrel->rd_pdcxt;
    2801       11974 :             if (relation->rd_pddcxt != NULL)
    2802           0 :                 MemoryContextSetParent(newrel->rd_pddcxt, relation->rd_pddcxt);
    2803             :             else
    2804       11974 :                 relation->rd_pddcxt = newrel->rd_pddcxt;
    2805             :             /* drop newrel's pointers so we don't destroy it below */
    2806       11974 :             newrel->rd_partdesc = NULL;
    2807       11974 :             newrel->rd_partdesc_nodetached = NULL;
    2808       11974 :             newrel->rd_partdesc_nodetached_xmin = InvalidTransactionId;
    2809       11974 :             newrel->rd_pdcxt = NULL;
    2810       11974 :             newrel->rd_pddcxt = NULL;
    2811             :         }
    2812             : 
    2813             : #undef SWAPFIELD
    2814             : 
    2815             :         /* And now we can throw away the temporary entry */
    2816      433578 :         RelationDestroyRelation(newrel, !keep_tupdesc);
    2817             :     }
    2818             : }
    2819             : 
    2820             : /*
    2821             :  * RelationFlushRelation
    2822             :  *
    2823             :  *   Rebuild the relation if it is open (refcount > 0), else blow it away.
    2824             :  *   This is used when we receive a cache invalidation event for the rel.
    2825             :  */
    2826             : static void
    2827      892654 : RelationFlushRelation(Relation relation)
    2828             : {
    2829      892654 :     if (relation->rd_createSubid != InvalidSubTransactionId ||
    2830      548910 :         relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
    2831             :     {
    2832             :         /*
    2833             :          * New relcache entries are always rebuilt, not flushed; else we'd
    2834             :          * forget the "new" status of the relation.  Ditto for the
    2835             :          * new-relfilenumber status.
    2836             :          */
    2837      361912 :         if (IsTransactionState() && relation->rd_droppedSubid == InvalidSubTransactionId)
    2838             :         {
    2839             :             /*
    2840             :              * The rel could have zero refcnt here, so temporarily increment
    2841             :              * the refcnt to ensure it's safe to rebuild it.  We can assume
    2842             :              * that the current transaction has some lock on the rel already.
    2843             :              */
    2844      360020 :             RelationIncrementReferenceCount(relation);
    2845      360020 :             RelationRebuildRelation(relation);
    2846      360014 :             RelationDecrementReferenceCount(relation);
    2847             :         }
    2848             :         else
    2849        1892 :             RelationInvalidateRelation(relation);
    2850             :     }
    2851             :     else
    2852             :     {
    2853             :         /*
    2854             :          * Pre-existing rels can be dropped from the relcache if not open.
    2855             :          *
    2856             :          * If the entry is in use, rebuild it if possible.  If we're not
    2857             :          * inside a valid transaction, we can't do any catalog access so it's
    2858             :          * not possible to rebuild yet.  Just mark it as invalid in that case,
    2859             :          * so that the rebuild will occur when the entry is next opened.
    2860             :          *
    2861             :          * Note: it's possible that we come here during subtransaction abort,
    2862             :          * and the reason for wanting to rebuild is that the rel is open in
    2863             :          * the outer transaction.  In that case it might seem unsafe to not
    2864             :          * rebuild immediately, since whatever code has the rel already open
    2865             :          * will keep on using the relcache entry as-is.  However, in such a
    2866             :          * case the outer transaction should be holding a lock that's
    2867             :          * sufficient to prevent any significant change in the rel's schema,
    2868             :          * so the existing entry contents should be good enough for its
    2869             :          * purposes; at worst we might be behind on statistics updates or the
    2870             :          * like.  (See also CheckTableNotInUse() and its callers.)
    2871             :          */
    2872      530742 :         if (RelationHasReferenceCountZero(relation))
    2873      330602 :             RelationClearRelation(relation);
    2874      200140 :         else if (!IsTransactionState())
    2875       21380 :             RelationInvalidateRelation(relation);
    2876      178760 :         else if (relation->rd_isnailed && relation->rd_refcnt == 1)
    2877             :         {
    2878             :             /*
    2879             :              * A nailed relation with refcnt == 1 is unused.  We cannot clear
    2880             :              * it, but there's also no need no need to rebuild it immediately.
    2881             :              */
    2882        3468 :             RelationInvalidateRelation(relation);
    2883             :         }
    2884             :         else
    2885      175292 :             RelationRebuildRelation(relation);
    2886             :     }
    2887      892648 : }
    2888             : 
    2889             : /*
    2890             :  * RelationForgetRelation - caller reports that it dropped the relation
    2891             :  */
    2892             : void
    2893       71488 : RelationForgetRelation(Oid rid)
    2894             : {
    2895             :     Relation    relation;
    2896             : 
    2897       71488 :     RelationIdCacheLookup(rid, relation);
    2898             : 
    2899       71488 :     if (!PointerIsValid(relation))
    2900           0 :         return;                 /* not in cache, nothing to do */
    2901             : 
    2902       71488 :     if (!RelationHasReferenceCountZero(relation))
    2903           0 :         elog(ERROR, "relation %u is still open", rid);
    2904             : 
    2905             :     Assert(relation->rd_droppedSubid == InvalidSubTransactionId);
    2906       71488 :     if (relation->rd_createSubid != InvalidSubTransactionId ||
    2907       69906 :         relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
    2908             :     {
    2909             :         /*
    2910             :          * In the event of subtransaction rollback, we must not forget
    2911             :          * rd_*Subid.  Mark the entry "dropped" and invalidate it, instead of
    2912             :          * destroying it right away.  (If we're in a top transaction, we could
    2913             :          * opt to destroy the entry.)
    2914             :          */
    2915        1610 :         relation->rd_droppedSubid = GetCurrentSubTransactionId();
    2916        1610 :         RelationInvalidateRelation(relation);
    2917             :     }
    2918             :     else
    2919       69878 :         RelationClearRelation(relation);
    2920             : }
    2921             : 
    2922             : /*
    2923             :  *      RelationCacheInvalidateEntry
    2924             :  *
    2925             :  *      This routine is invoked for SI cache flush messages.
    2926             :  *
    2927             :  * Any relcache entry matching the relid must be flushed.  (Note: caller has
    2928             :  * already determined that the relid belongs to our database or is a shared
    2929             :  * relation.)
    2930             :  *
    2931             :  * We used to skip local relations, on the grounds that they could
    2932             :  * not be targets of cross-backend SI update messages; but it seems
    2933             :  * safer to process them, so that our *own* SI update messages will
    2934             :  * have the same effects during CommandCounterIncrement for both
    2935             :  * local and nonlocal relations.
    2936             :  */
    2937             : void
    2938     2828886 : RelationCacheInvalidateEntry(Oid relationId)
    2939             : {
    2940             :     Relation    relation;
    2941             : 
    2942     2828886 :     RelationIdCacheLookup(relationId, relation);
    2943             : 
    2944     2828886 :     if (PointerIsValid(relation))
    2945             :     {
    2946      892654 :         relcacheInvalsReceived++;
    2947      892654 :         RelationFlushRelation(relation);
    2948             :     }
    2949             :     else
    2950             :     {
    2951             :         int         i;
    2952             : 
    2953     1974408 :         for (i = 0; i < in_progress_list_len; i++)
    2954       38176 :             if (in_progress_list[i].reloid == relationId)
    2955          18 :                 in_progress_list[i].invalidated = true;
    2956             :     }
    2957     2828880 : }
    2958             : 
    2959             : /*
    2960             :  * RelationCacheInvalidate
    2961             :  *   Blow away cached relation descriptors that have zero reference counts,
    2962             :  *   and rebuild those with positive reference counts.  Also reset the smgr
    2963             :  *   relation cache and re-read relation mapping data.
    2964             :  *
    2965             :  *   Apart from debug_discard_caches, this is currently used only to recover
    2966             :  *   from SI message buffer overflow, so we do not touch relations having
    2967             :  *   new-in-transaction relfilenumbers; they cannot be targets of cross-backend
    2968             :  *   SI updates (and our own updates now go through a separate linked list
    2969             :  *   that isn't limited by the SI message buffer size).
    2970             :  *
    2971             :  *   We do this in two phases: the first pass deletes deletable items, and
    2972             :  *   the second one rebuilds the rebuildable items.  This is essential for
    2973             :  *   safety, because hash_seq_search only copes with concurrent deletion of
    2974             :  *   the element it is currently visiting.  If a second SI overflow were to
    2975             :  *   occur while we are walking the table, resulting in recursive entry to
    2976             :  *   this routine, we could crash because the inner invocation blows away
    2977             :  *   the entry next to be visited by the outer scan.  But this way is OK,
    2978             :  *   because (a) during the first pass we won't process any more SI messages,
    2979             :  *   so hash_seq_search will complete safely; (b) during the second pass we
    2980             :  *   only hold onto pointers to nondeletable entries.
    2981             :  *
    2982             :  *   The two-phase approach also makes it easy to update relfilenumbers for
    2983             :  *   mapped relations before we do anything else, and to ensure that the
    2984             :  *   second pass processes nailed-in-cache items before other nondeletable
    2985             :  *   items.  This should ensure that system catalogs are up to date before
    2986             :  *   we attempt to use them to reload information about other open relations.
    2987             :  *
    2988             :  *   After those two phases of work having immediate effects, we normally
    2989             :  *   signal any RelationBuildDesc() on the stack to start over.  However, we
    2990             :  *   don't do this if called as part of debug_discard_caches.  Otherwise,
    2991             :  *   RelationBuildDesc() would become an infinite loop.
    2992             :  */
    2993             : void
    2994        4602 : RelationCacheInvalidate(bool debug_discard)
    2995             : {
    2996             :     HASH_SEQ_STATUS status;
    2997             :     RelIdCacheEnt *idhentry;
    2998             :     Relation    relation;
    2999        4602 :     List       *rebuildFirstList = NIL;
    3000        4602 :     List       *rebuildList = NIL;
    3001             :     ListCell   *l;
    3002             :     int         i;
    3003             : 
    3004             :     /*
    3005             :      * Reload relation mapping data before starting to reconstruct cache.
    3006             :      */
    3007        4602 :     RelationMapInvalidateAll();
    3008             : 
    3009             :     /* Phase 1 */
    3010        4602 :     hash_seq_init(&status, RelationIdCache);
    3011             : 
    3012      500740 :     while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    3013             :     {
    3014      496138 :         relation = idhentry->reldesc;
    3015             : 
    3016             :         /*
    3017             :          * Ignore new relations; no other backend will manipulate them before
    3018             :          * we commit.  Likewise, before replacing a relation's relfilelocator,
    3019             :          * we shall have acquired AccessExclusiveLock and drained any
    3020             :          * applicable pending invalidations.
    3021             :          */
    3022      496138 :         if (relation->rd_createSubid != InvalidSubTransactionId ||
    3023      496064 :             relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId)
    3024          90 :             continue;
    3025             : 
    3026      496048 :         relcacheInvalsReceived++;
    3027             : 
    3028      496048 :         if (RelationHasReferenceCountZero(relation))
    3029             :         {
    3030             :             /* Delete this entry immediately */
    3031      397112 :             RelationClearRelation(relation);
    3032             :         }
    3033             :         else
    3034             :         {
    3035             :             /*
    3036             :              * If it's a mapped relation, immediately update its rd_locator in
    3037             :              * case its relfilenumber changed.  We must do this during phase 1
    3038             :              * in case the relation is consulted during rebuild of other
    3039             :              * relcache entries in phase 2.  It's safe since consulting the
    3040             :              * map doesn't involve any access to relcache entries.
    3041             :              */
    3042       98936 :             if (RelationIsMapped(relation))
    3043             :             {
    3044       76460 :                 RelationCloseSmgr(relation);
    3045       76460 :                 RelationInitPhysicalAddr(relation);
    3046             :             }
    3047             : 
    3048             :             /*
    3049             :              * Add this entry to list of stuff to rebuild in second pass.
    3050             :              * pg_class goes to the front of rebuildFirstList while
    3051             :              * pg_class_oid_index goes to the back of rebuildFirstList, so
    3052             :              * they are done first and second respectively.  Other nailed
    3053             :              * relations go to the front of rebuildList, so they'll be done
    3054             :              * next in no particular order; and everything else goes to the
    3055             :              * back of rebuildList.
    3056             :              */
    3057       98936 :             if (RelationGetRelid(relation) == RelationRelationId)
    3058        4456 :                 rebuildFirstList = lcons(relation, rebuildFirstList);
    3059       94480 :             else if (RelationGetRelid(relation) == ClassOidIndexId)
    3060        4456 :                 rebuildFirstList = lappend(rebuildFirstList, relation);
    3061       90024 :             else if (relation->rd_isnailed)
    3062       89818 :                 rebuildList = lcons(relation, rebuildList);
    3063             :             else
    3064         206 :                 rebuildList = lappend(rebuildList, relation);
    3065             :         }
    3066             :     }
    3067             : 
    3068             :     /*
    3069             :      * We cannot destroy the SMgrRelations as there might still be references
    3070             :      * to them, but close the underlying file descriptors.
    3071             :      */
    3072        4602 :     smgrreleaseall();
    3073             : 
    3074             :     /*
    3075             :      * Phase 2: rebuild (or invalidate) the items found to need rebuild in
    3076             :      * phase 1
    3077             :      */
    3078       13514 :     foreach(l, rebuildFirstList)
    3079             :     {
    3080        8912 :         relation = (Relation) lfirst(l);
    3081        8912 :         if (!IsTransactionState() || (relation->rd_isnailed && relation->rd_refcnt == 1))
    3082        8910 :             RelationInvalidateRelation(relation);
    3083             :         else
    3084           2 :             RelationRebuildRelation(relation);
    3085             :     }
    3086        4602 :     list_free(rebuildFirstList);
    3087       94626 :     foreach(l, rebuildList)
    3088             :     {
    3089       90024 :         relation = (Relation) lfirst(l);
    3090       90024 :         if (!IsTransactionState() || (relation->rd_isnailed && relation->rd_refcnt == 1))
    3091       89782 :             RelationInvalidateRelation(relation);
    3092             :         else
    3093         242 :             RelationRebuildRelation(relation);
    3094             :     }
    3095        4602 :     list_free(rebuildList);
    3096             : 
    3097        4602 :     if (!debug_discard)
    3098             :         /* Any RelationBuildDesc() on the stack must start over. */
    3099        4616 :         for (i = 0; i < in_progress_list_len; i++)
    3100          14 :             in_progress_list[i].invalidated = true;
    3101        4602 : }
    3102             : 
    3103             : static void
    3104       21784 : RememberToFreeTupleDescAtEOX(TupleDesc td)
    3105             : {
    3106       21784 :     if (EOXactTupleDescArray == NULL)
    3107             :     {
    3108             :         MemoryContext oldcxt;
    3109             : 
    3110       12438 :         oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    3111             : 
    3112       12438 :         EOXactTupleDescArray = (TupleDesc *) palloc(16 * sizeof(TupleDesc));
    3113       12438 :         EOXactTupleDescArrayLen = 16;
    3114       12438 :         NextEOXactTupleDescNum = 0;
    3115       12438 :         MemoryContextSwitchTo(oldcxt);
    3116             :     }
    3117        9346 :     else if (NextEOXactTupleDescNum >= EOXactTupleDescArrayLen)
    3118             :     {
    3119          64 :         int32       newlen = EOXactTupleDescArrayLen * 2;
    3120             : 
    3121             :         Assert(EOXactTupleDescArrayLen > 0);
    3122             : 
    3123          64 :         EOXactTupleDescArray = (TupleDesc *) repalloc(EOXactTupleDescArray,
    3124             :                                                       newlen * sizeof(TupleDesc));
    3125          64 :         EOXactTupleDescArrayLen = newlen;
    3126             :     }
    3127             : 
    3128       21784 :     EOXactTupleDescArray[NextEOXactTupleDescNum++] = td;
    3129       21784 : }
    3130             : 
    3131             : #ifdef USE_ASSERT_CHECKING
    3132             : static void
    3133             : AssertPendingSyncConsistency(Relation relation)
    3134             : {
    3135             :     bool        relcache_verdict =
    3136             :         RelationIsPermanent(relation) &&
    3137             :         ((relation->rd_createSubid != InvalidSubTransactionId &&
    3138             :           RELKIND_HAS_STORAGE(relation->rd_rel->relkind)) ||
    3139             :          relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId);
    3140             : 
    3141             :     Assert(relcache_verdict == RelFileLocatorSkippingWAL(relation->rd_locator));
    3142             : 
    3143             :     if (relation->rd_droppedSubid != InvalidSubTransactionId)
    3144             :         Assert(!relation->rd_isvalid &&
    3145             :                (relation->rd_createSubid != InvalidSubTransactionId ||
    3146             :                 relation->rd_firstRelfilelocatorSubid != InvalidSubTransactionId));
    3147             : }
    3148             : 
    3149             : /*
    3150             :  * AssertPendingSyncs_RelationCache
    3151             :  *
    3152             :  *  Assert that relcache.c and storage.c agree on whether to skip WAL.
    3153             :  */
    3154             : void
    3155             : AssertPendingSyncs_RelationCache(void)
    3156             : {
    3157             :     HASH_SEQ_STATUS status;
    3158             :     LOCALLOCK  *locallock;
    3159             :     Relation   *rels;
    3160             :     int         maxrels;
    3161             :     int         nrels;
    3162             :     RelIdCacheEnt *idhentry;
    3163             :     int         i;
    3164             : 
    3165             :     /*
    3166             :      * Open every relation that this transaction has locked.  If, for some
    3167             :      * relation, storage.c is skipping WAL and relcache.c is not skipping WAL,
    3168             :      * a CommandCounterIncrement() typically yields a local invalidation
    3169             :      * message that destroys the relcache entry.  By recreating such entries
    3170             :      * here, we detect the problem.
    3171             :      */
    3172             :     PushActiveSnapshot(GetTransactionSnapshot());
    3173             :     maxrels = 1;
    3174             :     rels = palloc(maxrels * sizeof(*rels));
    3175             :     nrels = 0;
    3176             :     hash_seq_init(&status, GetLockMethodLocalHash());
    3177             :     while ((locallock = (LOCALLOCK *) hash_seq_search(&status)) != NULL)
    3178             :     {
    3179             :         Oid         relid;
    3180             :         Relation    r;
    3181             : 
    3182             :         if (locallock->nLocks <= 0)
    3183             :             continue;
    3184             :         if ((LockTagType) locallock->tag.lock.locktag_type !=
    3185             :             LOCKTAG_RELATION)
    3186             :             continue;
    3187             :         relid = ObjectIdGetDatum(locallock->tag.lock.locktag_field2);
    3188             :         r = RelationIdGetRelation(relid);
    3189             :         if (!RelationIsValid(r))
    3190             :             continue;
    3191             :         if (nrels >= maxrels)
    3192             :         {
    3193             :             maxrels *= 2;
    3194             :             rels = repalloc(rels, maxrels * sizeof(*rels));
    3195             :         }
    3196             :         rels[nrels++] = r;
    3197             :     }
    3198             : 
    3199             :     hash_seq_init(&status, RelationIdCache);
    3200             :     while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    3201             :         AssertPendingSyncConsistency(idhentry->reldesc);
    3202             : 
    3203             :     for (i = 0; i < nrels; i++)
    3204             :         RelationClose(rels[i]);
    3205             :     PopActiveSnapshot();
    3206             : }
    3207             : #endif
    3208             : 
    3209             : /*
    3210             :  * AtEOXact_RelationCache
    3211             :  *
    3212             :  *  Clean up the relcache at main-transaction commit or abort.
    3213             :  *
    3214             :  * Note: this must be called *before* processing invalidation messages.
    3215             :  * In the case of abort, we don't want to try to rebuild any invalidated
    3216             :  * cache entries (since we can't safely do database accesses).  Therefore
    3217             :  * we must reset refcnts before handling pending invalidations.
    3218             :  *
    3219             :  * As of PostgreSQL 8.1, relcache refcnts should get released by the
    3220             :  * ResourceOwner mechanism.  This routine just does a debugging
    3221             :  * cross-check that no pins remain.  However, we also need to do special
    3222             :  * cleanup when the current transaction created any relations or made use
    3223             :  * of forced index lists.
    3224             :  */
    3225             : void
    3226      862980 : AtEOXact_RelationCache(bool isCommit)
    3227             : {
    3228             :     HASH_SEQ_STATUS status;
    3229             :     RelIdCacheEnt *idhentry;
    3230             :     int         i;
    3231             : 
    3232             :     /*
    3233             :      * Forget in_progress_list.  This is relevant when we're aborting due to
    3234             :      * an error during RelationBuildDesc().
    3235             :      */
    3236             :     Assert(in_progress_list_len == 0 || !isCommit);
    3237      862980 :     in_progress_list_len = 0;
    3238             : 
    3239             :     /*
    3240             :      * Unless the eoxact_list[] overflowed, we only need to examine the rels
    3241             :      * listed in it.  Otherwise fall back on a hash_seq_search scan.
    3242             :      *
    3243             :      * For simplicity, eoxact_list[] entries are not deleted till end of
    3244             :      * top-level transaction, even though we could remove them at
    3245             :      * subtransaction end in some cases, or remove relations from the list if
    3246             :      * they are cleared for other reasons.  Therefore we should expect the
    3247             :      * case that list entries are not found in the hashtable; if not, there's
    3248             :      * nothing to do for them.
    3249             :      */
    3250      862980 :     if (eoxact_list_overflowed)
    3251             :     {
    3252         162 :         hash_seq_init(&status, RelationIdCache);
    3253       45018 :         while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    3254             :         {
    3255       44856 :             AtEOXact_cleanup(idhentry->reldesc, isCommit);
    3256             :         }
    3257             :     }
    3258             :     else
    3259             :     {
    3260      985406 :         for (i = 0; i < eoxact_list_len; i++)
    3261             :         {
    3262      122588 :             idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
    3263      122588 :                                                      &eoxact_list[i],
    3264             :                                                      HASH_FIND,
    3265             :                                                      NULL);
    3266      122588 :             if (idhentry != NULL)
    3267      120366 :                 AtEOXact_cleanup(idhentry->reldesc, isCommit);
    3268             :         }
    3269             :     }
    3270             : 
    3271      862980 :     if (EOXactTupleDescArrayLen > 0)
    3272             :     {
    3273             :         Assert(EOXactTupleDescArray != NULL);
    3274       34222 :         for (i = 0; i < NextEOXactTupleDescNum; i++)
    3275       21784 :             FreeTupleDesc(EOXactTupleDescArray[i]);
    3276       12438 :         pfree(EOXactTupleDescArray);
    3277       12438 :         EOXactTupleDescArray = NULL;
    3278             :     }
    3279             : 
    3280             :     /* Now we're out of the transaction and can clear the lists */
    3281      862980 :     eoxact_list_len = 0;
    3282      862980 :     eoxact_list_overflowed = false;
    3283      862980 :     NextEOXactTupleDescNum = 0;
    3284      862980 :     EOXactTupleDescArrayLen = 0;
    3285      862980 : }
    3286             : 
    3287             : /*
    3288             :  * AtEOXact_cleanup
    3289             :  *
    3290             :  *  Clean up a single rel at main-transaction commit or abort
    3291             :  *
    3292             :  * NB: this processing must be idempotent, because EOXactListAdd() doesn't
    3293             :  * bother to prevent duplicate entries in eoxact_list[].
    3294             :  */
    3295             : static void
    3296      165222 : AtEOXact_cleanup(Relation relation, bool isCommit)
    3297             : {
    3298      165222 :     bool        clear_relcache = false;
    3299             : 
    3300             :     /*
    3301             :      * The relcache entry's ref count should be back to its normal
    3302             :      * not-in-a-transaction state: 0 unless it's nailed in cache.
    3303             :      *
    3304             :      * In bootstrap mode, this is NOT true, so don't check it --- the
    3305             :      * bootstrap code expects relations to stay open across start/commit
    3306             :      * transaction calls.  (That seems bogus, but it's not worth fixing.)
    3307             :      *
    3308             :      * Note: ideally this check would be applied to every relcache entry, not
    3309             :      * just those that have eoxact work to do.  But it's not worth forcing a
    3310             :      * scan of the whole relcache just for this.  (Moreover, doing so would
    3311             :      * mean that assert-enabled testing never tests the hash_search code path
    3312             :      * above, which seems a bad idea.)
    3313             :      */
    3314             : #ifdef USE_ASSERT_CHECKING
    3315             :     if (!IsBootstrapProcessingMode())
    3316             :     {
    3317             :         int         expected_refcnt;
    3318             : 
    3319             :         expected_refcnt = relation->rd_isnailed ? 1 : 0;
    3320             :         Assert(relation->rd_refcnt == expected_refcnt);
    3321             :     }
    3322             : #endif
    3323             : 
    3324             :     /*
    3325             :      * Is the relation live after this transaction ends?
    3326             :      *
    3327             :      * During commit, clear the relcache entry if it is preserved after
    3328             :      * relation drop, in order not to orphan the entry.  During rollback,
    3329             :      * clear the relcache entry if the relation is created in the current
    3330             :      * transaction since it isn't interesting any longer once we are out of
    3331             :      * the transaction.
    3332             :      */
    3333      165222 :     clear_relcache =
    3334             :         (isCommit ?
    3335      165222 :          relation->rd_droppedSubid != InvalidSubTransactionId :
    3336        4692 :          relation->rd_createSubid != InvalidSubTransactionId);
    3337             : 
    3338             :     /*
    3339             :      * Since we are now out of the transaction, reset the subids to zero. That
    3340             :      * also lets RelationClearRelation() drop the relcache entry.
    3341             :      */
    3342      165222 :     relation->rd_createSubid = InvalidSubTransactionId;
    3343      165222 :     relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    3344      165222 :     relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    3345      165222 :     relation->rd_droppedSubid = InvalidSubTransactionId;
    3346             : 
    3347      165222 :     if (clear_relcache)
    3348             :     {
    3349        5492 :         if (RelationHasReferenceCountZero(relation))
    3350             :         {
    3351        5492 :             RelationClearRelation(relation);
    3352        5492 :             return;
    3353             :         }
    3354             :         else
    3355             :         {
    3356             :             /*
    3357             :              * Hmm, somewhere there's a (leaked?) reference to the relation.
    3358             :              * We daren't remove the entry for fear of dereferencing a
    3359             :              * dangling pointer later.  Bleat, and mark it as not belonging to
    3360             :              * the current transaction.  Hopefully it'll get cleaned up
    3361             :              * eventually.  This must be just a WARNING to avoid
    3362             :              * error-during-error-recovery loops.
    3363             :              */
    3364           0 :             elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
    3365             :                  RelationGetRelationName(relation));
    3366             :         }
    3367             :     }
    3368             : }
    3369             : 
    3370             : /*
    3371             :  * AtEOSubXact_RelationCache
    3372             :  *
    3373             :  *  Clean up the relcache at sub-transaction commit or abort.
    3374             :  *
    3375             :  * Note: this must be called *before* processing invalidation messages.
    3376             :  */
    3377             : void
    3378       20052 : AtEOSubXact_RelationCache(bool isCommit, SubTransactionId mySubid,
    3379             :                           SubTransactionId parentSubid)
    3380             : {
    3381             :     HASH_SEQ_STATUS status;
    3382             :     RelIdCacheEnt *idhentry;
    3383             :     int         i;
    3384             : 
    3385             :     /*
    3386             :      * Forget in_progress_list.  This is relevant when we're aborting due to
    3387             :      * an error during RelationBuildDesc().  We don't commit subtransactions
    3388             :      * during RelationBuildDesc().
    3389             :      */
    3390             :     Assert(in_progress_list_len == 0 || !isCommit);
    3391       20052 :     in_progress_list_len = 0;
    3392             : 
    3393             :     /*
    3394             :      * Unless the eoxact_list[] overflowed, we only need to examine the rels
    3395             :      * listed in it.  Otherwise fall back on a hash_seq_search scan.  Same
    3396             :      * logic as in AtEOXact_RelationCache.
    3397             :      */
    3398       20052 :     if (eoxact_list_overflowed)
    3399             :     {
    3400           0 :         hash_seq_init(&status, RelationIdCache);
    3401           0 :         while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    3402             :         {
    3403           0 :             AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
    3404             :                                 mySubid, parentSubid);
    3405             :         }
    3406             :     }
    3407             :     else
    3408             :     {
    3409       29570 :         for (i = 0; i < eoxact_list_len; i++)
    3410             :         {
    3411        9518 :             idhentry = (RelIdCacheEnt *) hash_search(RelationIdCache,
    3412        9518 :                                                      &eoxact_list[i],
    3413             :                                                      HASH_FIND,
    3414             :                                                      NULL);
    3415        9518 :             if (idhentry != NULL)
    3416        8574 :                 AtEOSubXact_cleanup(idhentry->reldesc, isCommit,
    3417             :                                     mySubid, parentSubid);
    3418             :         }
    3419             :     }
    3420             : 
    3421             :     /* Don't reset the list; we still need more cleanup later */
    3422       20052 : }
    3423             : 
    3424             : /*
    3425             :  * AtEOSubXact_cleanup
    3426             :  *
    3427             :  *  Clean up a single rel at subtransaction commit or abort
    3428             :  *
    3429             :  * NB: this processing must be idempotent, because EOXactListAdd() doesn't
    3430             :  * bother to prevent duplicate entries in eoxact_list[].
    3431             :  */
    3432             : static void
    3433        8574 : AtEOSubXact_cleanup(Relation relation, bool isCommit,
    3434             :                     SubTransactionId mySubid, SubTransactionId parentSubid)
    3435             : {
    3436             :     /*
    3437             :      * Is it a relation created in the current subtransaction?
    3438             :      *
    3439             :      * During subcommit, mark it as belonging to the parent, instead, as long
    3440             :      * as it has not been dropped. Otherwise simply delete the relcache entry.
    3441             :      * --- it isn't interesting any longer.
    3442             :      */
    3443        8574 :     if (relation->rd_createSubid == mySubid)
    3444             :     {
    3445             :         /*
    3446             :          * Valid rd_droppedSubid means the corresponding relation is dropped
    3447             :          * but the relcache entry is preserved for at-commit pending sync. We
    3448             :          * need to drop it explicitly here not to make the entry orphan.
    3449             :          */
    3450             :         Assert(relation->rd_droppedSubid == mySubid ||
    3451             :                relation->rd_droppedSubid == InvalidSubTransactionId);
    3452         198 :         if (isCommit && relation->rd_droppedSubid == InvalidSubTransactionId)
    3453          74 :             relation->rd_createSubid = parentSubid;
    3454         124 :         else if (RelationHasReferenceCountZero(relation))
    3455             :         {
    3456             :             /* allow the entry to be removed */
    3457         124 :             relation->rd_createSubid = InvalidSubTransactionId;
    3458         124 :             relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    3459         124 :             relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    3460         124 :             relation->rd_droppedSubid = InvalidSubTransactionId;
    3461         124 :             RelationClearRelation(relation);
    3462         124 :             return;
    3463             :         }
    3464             :         else
    3465             :         {
    3466             :             /*
    3467             :              * Hmm, somewhere there's a (leaked?) reference to the relation.
    3468             :              * We daren't remove the entry for fear of dereferencing a
    3469             :              * dangling pointer later.  Bleat, and transfer it to the parent
    3470             :              * subtransaction so we can try again later.  This must be just a
    3471             :              * WARNING to avoid error-during-error-recovery loops.
    3472             :              */
    3473           0 :             relation->rd_createSubid = parentSubid;
    3474           0 :             elog(WARNING, "cannot remove relcache entry for \"%s\" because it has nonzero refcount",
    3475             :                  RelationGetRelationName(relation));
    3476             :         }
    3477             :     }
    3478             : 
    3479             :     /*
    3480             :      * Likewise, update or drop any new-relfilenumber-in-subtransaction record
    3481             :      * or drop record.
    3482             :      */
    3483        8450 :     if (relation->rd_newRelfilelocatorSubid == mySubid)
    3484             :     {
    3485         142 :         if (isCommit)
    3486          74 :             relation->rd_newRelfilelocatorSubid = parentSubid;
    3487             :         else
    3488          68 :             relation->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    3489             :     }
    3490             : 
    3491        8450 :     if (relation->rd_firstRelfilelocatorSubid == mySubid)
    3492             :     {
    3493          98 :         if (isCommit)
    3494          34 :             relation->rd_firstRelfilelocatorSubid = parentSubid;
    3495             :         else
    3496          64 :             relation->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    3497             :     }
    3498             : 
    3499        8450 :     if (relation->rd_droppedSubid == mySubid)
    3500             :     {
    3501          20 :         if (isCommit)
    3502           2 :             relation->rd_droppedSubid = parentSubid;
    3503             :         else
    3504          18 :             relation->rd_droppedSubid = InvalidSubTransactionId;
    3505             :     }
    3506             : }
    3507             : 
    3508             : 
    3509             : /*
    3510             :  *      RelationBuildLocalRelation
    3511             :  *          Build a relcache entry for an about-to-be-created relation,
    3512             :  *          and enter it into the relcache.
    3513             :  */
    3514             : Relation
    3515      137452 : RelationBuildLocalRelation(const char *relname,
    3516             :                            Oid relnamespace,
    3517             :                            TupleDesc tupDesc,
    3518             :                            Oid relid,
    3519             :                            Oid accessmtd,
    3520             :                            RelFileNumber relfilenumber,
    3521             :                            Oid reltablespace,
    3522             :                            bool shared_relation,
    3523             :                            bool mapped_relation,
    3524             :                            char relpersistence,
    3525             :                            char relkind)
    3526             : {
    3527             :     Relation    rel;
    3528             :     MemoryContext oldcxt;
    3529      137452 :     int         natts = tupDesc->natts;
    3530             :     int         i;
    3531             :     bool        has_not_null;
    3532             :     bool        nailit;
    3533             : 
    3534             :     Assert(natts >= 0);
    3535             : 
    3536             :     /*
    3537             :      * check for creation of a rel that must be nailed in cache.
    3538             :      *
    3539             :      * XXX this list had better match the relations specially handled in
    3540             :      * RelationCacheInitializePhase2/3.
    3541             :      */
    3542      137452 :     switch (relid)
    3543             :     {
    3544         686 :         case DatabaseRelationId:
    3545             :         case AuthIdRelationId:
    3546             :         case AuthMemRelationId:
    3547             :         case RelationRelationId:
    3548             :         case AttributeRelationId:
    3549             :         case ProcedureRelationId:
    3550             :         case TypeRelationId:
    3551         686 :             nailit = true;
    3552         686 :             break;
    3553      136766 :         default:
    3554      136766 :             nailit = false;
    3555      136766 :             break;
    3556             :     }
    3557             : 
    3558             :     /*
    3559             :      * check that hardwired list of shared rels matches what's in the
    3560             :      * bootstrap .bki file.  If you get a failure here during initdb, you
    3561             :      * probably need to fix IsSharedRelation() to match whatever you've done
    3562             :      * to the set of shared relations.
    3563             :      */
    3564      137452 :     if (shared_relation != IsSharedRelation(relid))
    3565           0 :         elog(ERROR, "shared_relation flag for \"%s\" does not match IsSharedRelation(%u)",
    3566             :              relname, relid);
    3567             : 
    3568             :     /* Shared relations had better be mapped, too */
    3569             :     Assert(mapped_relation || !shared_relation);
    3570             : 
    3571             :     /*
    3572             :      * switch to the cache context to create the relcache entry.
    3573             :      */
    3574      137452 :     if (!CacheMemoryContext)
    3575           0 :         CreateCacheMemoryContext();
    3576             : 
    3577      137452 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    3578             : 
    3579             :     /*
    3580             :      * allocate a new relation descriptor and fill in basic state fields.
    3581             :      */
    3582      137452 :     rel = (Relation) palloc0(sizeof(RelationData));
    3583             : 
    3584             :     /* make sure relation is marked as having no open file yet */
    3585      137452 :     rel->rd_smgr = NULL;
    3586             : 
    3587             :     /* mark it nailed if appropriate */
    3588      137452 :     rel->rd_isnailed = nailit;
    3589             : 
    3590      137452 :     rel->rd_refcnt = nailit ? 1 : 0;
    3591             : 
    3592             :     /* it's being created in this transaction */
    3593      137452 :     rel->rd_createSubid = GetCurrentSubTransactionId();
    3594      137452 :     rel->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    3595      137452 :     rel->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    3596      137452 :     rel->rd_droppedSubid = InvalidSubTransactionId;
    3597             : 
    3598             :     /*
    3599             :      * create a new tuple descriptor from the one passed in.  We do this
    3600             :      * partly to copy it into the cache context, and partly because the new
    3601             :      * relation can't have any defaults or constraints yet; they have to be
    3602             :      * added in later steps, because they require additions to multiple system
    3603             :      * catalogs.  We can copy attnotnull constraints here, however.
    3604             :      */
    3605      137452 :     rel->rd_att = CreateTupleDescCopy(tupDesc);
    3606      137452 :     rel->rd_att->tdrefcount = 1;  /* mark as refcounted */
    3607      137452 :     has_not_null = false;
    3608      591312 :     for (i = 0; i < natts; i++)
    3609             :     {
    3610      453860 :         Form_pg_attribute satt = TupleDescAttr(tupDesc, i);
    3611      453860 :         Form_pg_attribute datt = TupleDescAttr(rel->rd_att, i);
    3612             : 
    3613      453860 :         datt->attidentity = satt->attidentity;
    3614      453860 :         datt->attgenerated = satt->attgenerated;
    3615      453860 :         datt->attnotnull = satt->attnotnull;
    3616      453860 :         has_not_null |= satt->attnotnull;
    3617      453860 :         populate_compact_attribute(rel->rd_att, i);
    3618             : 
    3619      453860 :         if (satt->attnotnull)
    3620             :         {
    3621       75372 :             CompactAttribute *scatt = TupleDescCompactAttr(tupDesc, i);
    3622       75372 :             CompactAttribute *dcatt = TupleDescCompactAttr(rel->rd_att, i);
    3623             : 
    3624       75372 :             dcatt->attnullability = scatt->attnullability;
    3625             :         }
    3626             :     }
    3627             : 
    3628      137452 :     if (has_not_null)
    3629             :     {
    3630       20862 :         TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
    3631             : 
    3632       20862 :         constr->has_not_null = true;
    3633       20862 :         rel->rd_att->constr = constr;
    3634             :     }
    3635             : 
    3636             :     /*
    3637             :      * initialize relation tuple form (caller may add/override data later)
    3638             :      */
    3639      137452 :     rel->rd_rel = (Form_pg_class) palloc0(CLASS_TUPLE_SIZE);
    3640             : 
    3641      137452 :     namestrcpy(&rel->rd_rel->relname, relname);
    3642      137452 :     rel->rd_rel->relnamespace = relnamespace;
    3643             : 
    3644      137452 :     rel->rd_rel->relkind = relkind;
    3645      137452 :     rel->rd_rel->relnatts = natts;
    3646      137452 :     rel->rd_rel->reltype = InvalidOid;
    3647             :     /* needed when bootstrapping: */
    3648      137452 :     rel->rd_rel->relowner = BOOTSTRAP_SUPERUSERID;
    3649             : 
    3650             :     /* set up persistence and relcache fields dependent on it */
    3651      137452 :     rel->rd_rel->relpersistence = relpersistence;
    3652      137452 :     switch (relpersistence)
    3653             :     {
    3654      131322 :         case RELPERSISTENCE_UNLOGGED:
    3655             :         case RELPERSISTENCE_PERMANENT:
    3656      131322 :             rel->rd_backend = INVALID_PROC_NUMBER;
    3657      131322 :             rel->rd_islocaltemp = false;
    3658      131322 :             break;
    3659        6130 :         case RELPERSISTENCE_TEMP:
    3660             :             Assert(isTempOrTempToastNamespace(relnamespace));
    3661        6130 :             rel->rd_backend = ProcNumberForTempRelations();
    3662        6130 :             rel->rd_islocaltemp = true;
    3663        6130 :             break;
    3664           0 :         default:
    3665           0 :             elog(ERROR, "invalid relpersistence: %c", relpersistence);
    3666             :             break;
    3667             :     }
    3668             : 
    3669             :     /* if it's a materialized view, it's not populated initially */
    3670      137452 :     if (relkind == RELKIND_MATVIEW)
    3671         478 :         rel->rd_rel->relispopulated = false;
    3672             :     else
    3673      136974 :         rel->rd_rel->relispopulated = true;
    3674             : 
    3675             :     /* set replica identity -- system catalogs and non-tables don't have one */
    3676      137452 :     if (!IsCatalogNamespace(relnamespace) &&
    3677       75272 :         (relkind == RELKIND_RELATION ||
    3678       74794 :          relkind == RELKIND_MATVIEW ||
    3679             :          relkind == RELKIND_PARTITIONED_TABLE))
    3680       41584 :         rel->rd_rel->relreplident = REPLICA_IDENTITY_DEFAULT;
    3681             :     else
    3682       95868 :         rel->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
    3683             : 
    3684             :     /*
    3685             :      * Insert relation physical and logical identifiers (OIDs) into the right
    3686             :      * places.  For a mapped relation, we set relfilenumber to zero and rely
    3687             :      * on RelationInitPhysicalAddr to consult the map.
    3688             :      */
    3689      137452 :     rel->rd_rel->relisshared = shared_relation;
    3690             : 
    3691      137452 :     RelationGetRelid(rel) = relid;
    3692             : 
    3693      591312 :     for (i = 0; i < natts; i++)
    3694      453860 :         TupleDescAttr(rel->rd_att, i)->attrelid = relid;
    3695             : 
    3696      137452 :     rel->rd_rel->reltablespace = reltablespace;
    3697             : 
    3698      137452 :     if (mapped_relation)
    3699             :     {
    3700        6344 :         rel->rd_rel->relfilenode = InvalidRelFileNumber;
    3701             :         /* Add it to the active mapping information */
    3702        6344 :         RelationMapUpdateMap(relid, relfilenumber, shared_relation, true);
    3703             :     }
    3704             :     else
    3705      131108 :         rel->rd_rel->relfilenode = relfilenumber;
    3706             : 
    3707      137452 :     RelationInitLockInfo(rel);  /* see lmgr.c */
    3708             : 
    3709      137452 :     RelationInitPhysicalAddr(rel);
    3710             : 
    3711      137452 :     rel->rd_rel->relam = accessmtd;
    3712             : 
    3713             :     /*
    3714             :      * RelationInitTableAccessMethod will do syscache lookups, so we mustn't
    3715             :      * run it in CacheMemoryContext.  Fortunately, the remaining steps don't
    3716             :      * require a long-lived current context.
    3717             :      */
    3718      137452 :     MemoryContextSwitchTo(oldcxt);
    3719             : 
    3720      137452 :     if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_SEQUENCE)
    3721       62718 :         RelationInitTableAccessMethod(rel);
    3722             : 
    3723             :     /*
    3724             :      * Leave index access method uninitialized, because the pg_index row has
    3725             :      * not been inserted at this stage of index creation yet.  The cache
    3726             :      * invalidation after pg_index row has been inserted will initialize it.
    3727             :      */
    3728             : 
    3729             :     /*
    3730             :      * Okay to insert into the relcache hash table.
    3731             :      *
    3732             :      * Ordinarily, there should certainly not be an existing hash entry for
    3733             :      * the same OID; but during bootstrap, when we create a "real" relcache
    3734             :      * entry for one of the bootstrap relations, we'll be overwriting the
    3735             :      * phony one created with formrdesc.  So allow that to happen for nailed
    3736             :      * rels.
    3737             :      */
    3738      137452 :     RelationCacheInsert(rel, nailit);
    3739             : 
    3740             :     /*
    3741             :      * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
    3742             :      * can't do this before storing relid in it.
    3743             :      */
    3744      137452 :     EOXactListAdd(rel);
    3745             : 
    3746             :     /* It's fully valid */
    3747      137452 :     rel->rd_isvalid = true;
    3748             : 
    3749             :     /*
    3750             :      * Caller expects us to pin the returned entry.
    3751             :      */
    3752      137452 :     RelationIncrementReferenceCount(rel);
    3753             : 
    3754      137452 :     return rel;
    3755             : }
    3756             : 
    3757             : 
    3758             : /*
    3759             :  * RelationSetNewRelfilenumber
    3760             :  *
    3761             :  * Assign a new relfilenumber (physical file name), and possibly a new
    3762             :  * persistence setting, to the relation.
    3763             :  *
    3764             :  * This allows a full rewrite of the relation to be done with transactional
    3765             :  * safety (since the filenumber assignment can be rolled back).  Note however
    3766             :  * that there is no simple way to access the relation's old data for the
    3767             :  * remainder of the current transaction.  This limits the usefulness to cases
    3768             :  * such as TRUNCATE or rebuilding an index from scratch.
    3769             :  *
    3770             :  * Caller must already hold exclusive lock on the relation.
    3771             :  */
    3772             : void
    3773       15212 : RelationSetNewRelfilenumber(Relation relation, char persistence)
    3774             : {
    3775             :     RelFileNumber newrelfilenumber;
    3776             :     Relation    pg_class;
    3777             :     ItemPointerData otid;
    3778             :     HeapTuple   tuple;
    3779             :     Form_pg_class classform;
    3780       15212 :     MultiXactId minmulti = InvalidMultiXactId;
    3781       15212 :     TransactionId freezeXid = InvalidTransactionId;
    3782             :     RelFileLocator newrlocator;
    3783             : 
    3784       15212 :     if (!IsBinaryUpgrade)
    3785             :     {
    3786             :         /* Allocate a new relfilenumber */
    3787       15116 :         newrelfilenumber = GetNewRelFileNumber(relation->rd_rel->reltablespace,
    3788             :                                                NULL, persistence);
    3789             :     }
    3790          96 :     else if (relation->rd_rel->relkind == RELKIND_INDEX)
    3791             :     {
    3792          48 :         if (!OidIsValid(binary_upgrade_next_index_pg_class_relfilenumber))
    3793           0 :             ereport(ERROR,
    3794             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    3795             :                      errmsg("index relfilenumber value not set when in binary upgrade mode")));
    3796             : 
    3797          48 :         newrelfilenumber = binary_upgrade_next_index_pg_class_relfilenumber;
    3798          48 :         binary_upgrade_next_index_pg_class_relfilenumber = InvalidOid;
    3799             :     }
    3800          48 :     else if (relation->rd_rel->relkind == RELKIND_RELATION)
    3801             :     {
    3802          48 :         if (!OidIsValid(binary_upgrade_next_heap_pg_class_relfilenumber))
    3803           0 :             ereport(ERROR,
    3804             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    3805             :                      errmsg("heap relfilenumber value not set when in binary upgrade mode")));
    3806             : 
    3807          48 :         newrelfilenumber = binary_upgrade_next_heap_pg_class_relfilenumber;
    3808          48 :         binary_upgrade_next_heap_pg_class_relfilenumber = InvalidOid;
    3809             :     }
    3810             :     else
    3811           0 :         ereport(ERROR,
    3812             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    3813             :                  errmsg("unexpected request for new relfilenumber in binary upgrade mode")));
    3814             : 
    3815             :     /*
    3816             :      * Get a writable copy of the pg_class tuple for the given relation.
    3817             :      */
    3818       15212 :     pg_class = table_open(RelationRelationId, RowExclusiveLock);
    3819             : 
    3820       15212 :     tuple = SearchSysCacheLockedCopy1(RELOID,
    3821             :                                       ObjectIdGetDatum(RelationGetRelid(relation)));
    3822       15212 :     if (!HeapTupleIsValid(tuple))
    3823           0 :         elog(ERROR, "could not find tuple for relation %u",
    3824             :              RelationGetRelid(relation));
    3825       15212 :     otid = tuple->t_self;
    3826       15212 :     classform = (Form_pg_class) GETSTRUCT(tuple);
    3827             : 
    3828             :     /*
    3829             :      * Schedule unlinking of the old storage at transaction commit, except
    3830             :      * when performing a binary upgrade, when we must do it immediately.
    3831             :      */
    3832       15212 :     if (IsBinaryUpgrade)
    3833             :     {
    3834             :         SMgrRelation srel;
    3835             : 
    3836             :         /*
    3837             :          * During a binary upgrade, we use this code path to ensure that
    3838             :          * pg_largeobject and its index have the same relfilenumbers as in the
    3839             :          * old cluster. This is necessary because pg_upgrade treats
    3840             :          * pg_largeobject like a user table, not a system table. It is however
    3841             :          * possible that a table or index may need to end up with the same
    3842             :          * relfilenumber in the new cluster as what it had in the old cluster.
    3843             :          * Hence, we can't wait until commit time to remove the old storage.
    3844             :          *
    3845             :          * In general, this function needs to have transactional semantics,
    3846             :          * and removing the old storage before commit time surely isn't.
    3847             :          * However, it doesn't really matter, because if a binary upgrade
    3848             :          * fails at this stage, the new cluster will need to be recreated
    3849             :          * anyway.
    3850             :          */
    3851          96 :         srel = smgropen(relation->rd_locator, relation->rd_backend);
    3852          96 :         smgrdounlinkall(&srel, 1, false);
    3853          96 :         smgrclose(srel);
    3854             :     }
    3855             :     else
    3856             :     {
    3857             :         /* Not a binary upgrade, so just schedule it to happen later. */
    3858       15116 :         RelationDropStorage(relation);
    3859             :     }
    3860             : 
    3861             :     /*
    3862             :      * Create storage for the main fork of the new relfilenumber.  If it's a
    3863             :      * table-like object, call into the table AM to do so, which'll also
    3864             :      * create the table's init fork if needed.
    3865             :      *
    3866             :      * NOTE: If relevant for the AM, any conflict in relfilenumber value will
    3867             :      * be caught here, if GetNewRelFileNumber messes up for any reason.
    3868             :      */
    3869       15212 :     newrlocator = relation->rd_locator;
    3870       15212 :     newrlocator.relNumber = newrelfilenumber;
    3871             : 
    3872       15212 :     if (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind))
    3873             :     {
    3874        6418 :         table_relation_set_new_filelocator(relation, &newrlocator,
    3875             :                                            persistence,
    3876             :                                            &freezeXid, &minmulti);
    3877             :     }
    3878        8794 :     else if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
    3879        8794 :     {
    3880             :         /* handle these directly, at least for now */
    3881             :         SMgrRelation srel;
    3882             : 
    3883        8794 :         srel = RelationCreateStorage(newrlocator, persistence, true);
    3884        8794 :         smgrclose(srel);
    3885             :     }
    3886             :     else
    3887             :     {
    3888             :         /* we shouldn't be called for anything else */
    3889           0 :         elog(ERROR, "relation \"%s\" does not have storage",
    3890             :              RelationGetRelationName(relation));
    3891             :     }
    3892             : 
    3893             :     /*
    3894             :      * If we're dealing with a mapped index, pg_class.relfilenode doesn't
    3895             :      * change; instead we have to send the update to the relation mapper.
    3896             :      *
    3897             :      * For mapped indexes, we don't actually change the pg_class entry at all;
    3898             :      * this is essential when reindexing pg_class itself.  That leaves us with
    3899             :      * possibly-inaccurate values of relpages etc, but those will be fixed up
    3900             :      * later.
    3901             :      */
    3902       15212 :     if (RelationIsMapped(relation))
    3903             :     {
    3904             :         /* This case is only supported for indexes */
    3905             :         Assert(relation->rd_rel->relkind == RELKIND_INDEX);
    3906             : 
    3907             :         /* Since we're not updating pg_class, these had better not change */
    3908             :         Assert(classform->relfrozenxid == freezeXid);
    3909             :         Assert(classform->relminmxid == minmulti);
    3910             :         Assert(classform->relpersistence == persistence);
    3911             : 
    3912             :         /*
    3913             :          * In some code paths it's possible that the tuple update we'd
    3914             :          * otherwise do here is the only thing that would assign an XID for
    3915             :          * the current transaction.  However, we must have an XID to delete
    3916             :          * files, so make sure one is assigned.
    3917             :          */
    3918         986 :         (void) GetCurrentTransactionId();
    3919             : 
    3920             :         /* Do the deed */
    3921         986 :         RelationMapUpdateMap(RelationGetRelid(relation),
    3922             :                              newrelfilenumber,
    3923         986 :                              relation->rd_rel->relisshared,
    3924             :                              false);
    3925             : 
    3926             :         /* Since we're not updating pg_class, must trigger inval manually */
    3927         986 :         CacheInvalidateRelcache(relation);
    3928             :     }
    3929             :     else
    3930             :     {
    3931             :         /* Normal case, update the pg_class entry */
    3932       14226 :         classform->relfilenode = newrelfilenumber;
    3933             : 
    3934             :         /* relpages etc. never change for sequences */
    3935       14226 :         if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
    3936             :         {
    3937       13944 :             classform->relpages = 0; /* it's empty until further notice */
    3938       13944 :             classform->reltuples = -1;
    3939       13944 :             classform->relallvisible = 0;
    3940       13944 :             classform->relallfrozen = 0;
    3941             :         }
    3942       14226 :         classform->relfrozenxid = freezeXid;
    3943       14226 :         classform->relminmxid = minmulti;
    3944       14226 :         classform->relpersistence = persistence;
    3945             : 
    3946       14226 :         CatalogTupleUpdate(pg_class, &otid, tuple);
    3947             :     }
    3948             : 
    3949       15212 :     UnlockTuple(pg_class, &otid, InplaceUpdateTupleLock);
    3950       15212 :     heap_freetuple(tuple);
    3951             : 
    3952       15212 :     table_close(pg_class, RowExclusiveLock);
    3953             : 
    3954             :     /*
    3955             :      * Make the pg_class row change or relation map change visible.  This will
    3956             :      * cause the relcache entry to get updated, too.
    3957             :      */
    3958       15212 :     CommandCounterIncrement();
    3959             : 
    3960       15212 :     RelationAssumeNewRelfilelocator(relation);
    3961       15212 : }
    3962             : 
    3963             : /*
    3964             :  * RelationAssumeNewRelfilelocator
    3965             :  *
    3966             :  * Code that modifies pg_class.reltablespace or pg_class.relfilenode must call
    3967             :  * this.  The call shall precede any code that might insert WAL records whose
    3968             :  * replay would modify bytes in the new RelFileLocator, and the call shall follow
    3969             :  * any WAL modifying bytes in the prior RelFileLocator.  See struct RelationData.
    3970             :  * Ideally, call this as near as possible to the CommandCounterIncrement()
    3971             :  * that makes the pg_class change visible (before it or after it); that
    3972             :  * minimizes the chance of future development adding a forbidden WAL insertion
    3973             :  * between RelationAssumeNewRelfilelocator() and CommandCounterIncrement().
    3974             :  */
    3975             : void
    3976       17790 : RelationAssumeNewRelfilelocator(Relation relation)
    3977             : {
    3978       17790 :     relation->rd_newRelfilelocatorSubid = GetCurrentSubTransactionId();
    3979       17790 :     if (relation->rd_firstRelfilelocatorSubid == InvalidSubTransactionId)
    3980       17696 :         relation->rd_firstRelfilelocatorSubid = relation->rd_newRelfilelocatorSubid;
    3981             : 
    3982             :     /* Flag relation as needing eoxact cleanup (to clear these fields) */
    3983       17790 :     EOXactListAdd(relation);
    3984       17790 : }
    3985             : 
    3986             : 
    3987             : /*
    3988             :  *      RelationCacheInitialize
    3989             :  *
    3990             :  *      This initializes the relation descriptor cache.  At the time
    3991             :  *      that this is invoked, we can't do database access yet (mainly
    3992             :  *      because the transaction subsystem is not up); all we are doing
    3993             :  *      is making an empty cache hashtable.  This must be done before
    3994             :  *      starting the initialization transaction, because otherwise
    3995             :  *      AtEOXact_RelationCache would crash if that transaction aborts
    3996             :  *      before we can get the relcache set up.
    3997             :  */
    3998             : 
    3999             : #define INITRELCACHESIZE        400
    4000             : 
    4001             : void
    4002       35356 : RelationCacheInitialize(void)
    4003             : {
    4004             :     HASHCTL     ctl;
    4005             :     int         allocsize;
    4006             : 
    4007             :     /*
    4008             :      * make sure cache memory context exists
    4009             :      */
    4010       35356 :     if (!CacheMemoryContext)
    4011       35356 :         CreateCacheMemoryContext();
    4012             : 
    4013             :     /*
    4014             :      * create hashtable that indexes the relcache
    4015             :      */
    4016       35356 :     ctl.keysize = sizeof(Oid);
    4017       35356 :     ctl.entrysize = sizeof(RelIdCacheEnt);
    4018       35356 :     RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
    4019             :                                   &ctl, HASH_ELEM | HASH_BLOBS);
    4020             : 
    4021             :     /*
    4022             :      * reserve enough in_progress_list slots for many cases
    4023             :      */
    4024       35356 :     allocsize = 4;
    4025       35356 :     in_progress_list =
    4026       35356 :         MemoryContextAlloc(CacheMemoryContext,
    4027             :                            allocsize * sizeof(*in_progress_list));
    4028       35356 :     in_progress_list_maxlen = allocsize;
    4029             : 
    4030             :     /*
    4031             :      * relation mapper needs to be initialized too
    4032             :      */
    4033       35356 :     RelationMapInitialize();
    4034       35356 : }
    4035             : 
    4036             : /*
    4037             :  *      RelationCacheInitializePhase2
    4038             :  *
    4039             :  *      This is called to prepare for access to shared catalogs during startup.
    4040             :  *      We must at least set up nailed reldescs for pg_database, pg_authid,
    4041             :  *      pg_auth_members, and pg_shseclabel. Ideally we'd like to have reldescs
    4042             :  *      for their indexes, too.  We attempt to load this information from the
    4043             :  *      shared relcache init file.  If that's missing or broken, just make
    4044             :  *      phony entries for the catalogs themselves.
    4045             :  *      RelationCacheInitializePhase3 will clean up as needed.
    4046             :  */
    4047             : void
    4048       35356 : RelationCacheInitializePhase2(void)
    4049             : {
    4050             :     MemoryContext oldcxt;
    4051             : 
    4052             :     /*
    4053             :      * relation mapper needs initialized too
    4054             :      */
    4055       35356 :     RelationMapInitializePhase2();
    4056             : 
    4057             :     /*
    4058             :      * In bootstrap mode, the shared catalogs aren't there yet anyway, so do
    4059             :      * nothing.
    4060             :      */
    4061       35356 :     if (IsBootstrapProcessingMode())
    4062          98 :         return;
    4063             : 
    4064             :     /*
    4065             :      * switch to cache memory context
    4066             :      */
    4067       35258 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    4068             : 
    4069             :     /*
    4070             :      * Try to load the shared relcache cache file.  If unsuccessful, bootstrap
    4071             :      * the cache with pre-made descriptors for the critical shared catalogs.
    4072             :      */
    4073       35258 :     if (!load_relcache_init_file(true))
    4074             :     {
    4075        4224 :         formrdesc("pg_database", DatabaseRelation_Rowtype_Id, true,
    4076             :                   Natts_pg_database, Desc_pg_database);
    4077        4224 :         formrdesc("pg_authid", AuthIdRelation_Rowtype_Id, true,
    4078             :                   Natts_pg_authid, Desc_pg_authid);
    4079        4224 :         formrdesc("pg_auth_members", AuthMemRelation_Rowtype_Id, true,
    4080             :                   Natts_pg_auth_members, Desc_pg_auth_members);
    4081        4224 :         formrdesc("pg_shseclabel", SharedSecLabelRelation_Rowtype_Id, true,
    4082             :                   Natts_pg_shseclabel, Desc_pg_shseclabel);
    4083        4224 :         formrdesc("pg_subscription", SubscriptionRelation_Rowtype_Id, true,
    4084             :                   Natts_pg_subscription, Desc_pg_subscription);
    4085             : 
    4086             : #define NUM_CRITICAL_SHARED_RELS    5   /* fix if you change list above */
    4087             :     }
    4088             : 
    4089       35258 :     MemoryContextSwitchTo(oldcxt);
    4090             : }
    4091             : 
    4092             : /*
    4093             :  *      RelationCacheInitializePhase3
    4094             :  *
    4095             :  *      This is called as soon as the catcache and transaction system
    4096             :  *      are functional and we have determined MyDatabaseId.  At this point
    4097             :  *      we can actually read data from the database's system catalogs.
    4098             :  *      We first try to read pre-computed relcache entries from the local
    4099             :  *      relcache init file.  If that's missing or broken, make phony entries
    4100             :  *      for the minimum set of nailed-in-cache relations.  Then (unless
    4101             :  *      bootstrapping) make sure we have entries for the critical system
    4102             :  *      indexes.  Once we've done all this, we have enough infrastructure to
    4103             :  *      open any system catalog or use any catcache.  The last step is to
    4104             :  *      rewrite the cache files if needed.
    4105             :  */
    4106             : void
    4107       32730 : RelationCacheInitializePhase3(void)
    4108             : {
    4109             :     HASH_SEQ_STATUS status;
    4110             :     RelIdCacheEnt *idhentry;
    4111             :     MemoryContext oldcxt;
    4112       32730 :     bool        needNewCacheFile = !criticalSharedRelcachesBuilt;
    4113             : 
    4114             :     /*
    4115             :      * relation mapper needs initialized too
    4116             :      */
    4117       32730 :     RelationMapInitializePhase3();
    4118             : 
    4119             :     /*
    4120             :      * switch to cache memory context
    4121             :      */
    4122       32730 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    4123             : 
    4124             :     /*
    4125             :      * Try to load the local relcache cache file.  If unsuccessful, bootstrap
    4126             :      * the cache with pre-made descriptors for the critical "nailed-in" system
    4127             :      * catalogs.
    4128             :      */
    4129       32730 :     if (IsBootstrapProcessingMode() ||
    4130       32632 :         !load_relcache_init_file(false))
    4131             :     {
    4132        3140 :         needNewCacheFile = true;
    4133             : 
    4134        3140 :         formrdesc("pg_class", RelationRelation_Rowtype_Id, false,
    4135             :                   Natts_pg_class, Desc_pg_class);
    4136        3140 :         formrdesc("pg_attribute", AttributeRelation_Rowtype_Id, false,
    4137             :                   Natts_pg_attribute, Desc_pg_attribute);
    4138        3140 :         formrdesc("pg_proc", ProcedureRelation_Rowtype_Id, false,
    4139             :                   Natts_pg_proc, Desc_pg_proc);
    4140        3140 :         formrdesc("pg_type", TypeRelation_Rowtype_Id, false,
    4141             :                   Natts_pg_type, Desc_pg_type);
    4142             : 
    4143             : #define NUM_CRITICAL_LOCAL_RELS 4   /* fix if you change list above */
    4144             :     }
    4145             : 
    4146       32730 :     MemoryContextSwitchTo(oldcxt);
    4147             : 
    4148             :     /* In bootstrap mode, the faked-up formrdesc info is all we'll have */
    4149       32730 :     if (IsBootstrapProcessingMode())
    4150          98 :         return;
    4151             : 
    4152             :     /*
    4153             :      * If we didn't get the critical system indexes loaded into relcache, do
    4154             :      * so now.  These are critical because the catcache and/or opclass cache
    4155             :      * depend on them for fetches done during relcache load.  Thus, we have an
    4156             :      * infinite-recursion problem.  We can break the recursion by doing
    4157             :      * heapscans instead of indexscans at certain key spots. To avoid hobbling
    4158             :      * performance, we only want to do that until we have the critical indexes
    4159             :      * loaded into relcache.  Thus, the flag criticalRelcachesBuilt is used to
    4160             :      * decide whether to do heapscan or indexscan at the key spots, and we set
    4161             :      * it true after we've loaded the critical indexes.
    4162             :      *
    4163             :      * The critical indexes are marked as "nailed in cache", partly to make it
    4164             :      * easy for load_relcache_init_file to count them, but mainly because we
    4165             :      * cannot flush and rebuild them once we've set criticalRelcachesBuilt to
    4166             :      * true.  (NOTE: perhaps it would be possible to reload them by
    4167             :      * temporarily setting criticalRelcachesBuilt to false again.  For now,
    4168             :      * though, we just nail 'em in.)
    4169             :      *
    4170             :      * RewriteRelRulenameIndexId and TriggerRelidNameIndexId are not critical
    4171             :      * in the same way as the others, because the critical catalogs don't
    4172             :      * (currently) have any rules or triggers, and so these indexes can be
    4173             :      * rebuilt without inducing recursion.  However they are used during
    4174             :      * relcache load when a rel does have rules or triggers, so we choose to
    4175             :      * nail them for performance reasons.
    4176             :      */
    4177       32632 :     if (!criticalRelcachesBuilt)
    4178             :     {
    4179        3042 :         load_critical_index(ClassOidIndexId,
    4180             :                             RelationRelationId);
    4181        3040 :         load_critical_index(AttributeRelidNumIndexId,
    4182             :                             AttributeRelationId);
    4183        3040 :         load_critical_index(IndexRelidIndexId,
    4184             :                             IndexRelationId);
    4185        3040 :         load_critical_index(OpclassOidIndexId,
    4186             :                             OperatorClassRelationId);
    4187        3040 :         load_critical_index(AccessMethodProcedureIndexId,
    4188             :                             AccessMethodProcedureRelationId);
    4189        3040 :         load_critical_index(RewriteRelRulenameIndexId,
    4190             :                             RewriteRelationId);
    4191        3040 :         load_critical_index(TriggerRelidNameIndexId,
    4192             :                             TriggerRelationId);
    4193             : 
    4194             : #define NUM_CRITICAL_LOCAL_INDEXES  7   /* fix if you change list above */
    4195             : 
    4196        3040 :         criticalRelcachesBuilt = true;
    4197             :     }
    4198             : 
    4199             :     /*
    4200             :      * Process critical shared indexes too.
    4201             :      *
    4202             :      * DatabaseNameIndexId isn't critical for relcache loading, but rather for
    4203             :      * initial lookup of MyDatabaseId, without which we'll never find any
    4204             :      * non-shared catalogs at all.  Autovacuum calls InitPostgres with a
    4205             :      * database OID, so it instead depends on DatabaseOidIndexId.  We also
    4206             :      * need to nail up some indexes on pg_authid and pg_auth_members for use
    4207             :      * during client authentication.  SharedSecLabelObjectIndexId isn't
    4208             :      * critical for the core system, but authentication hooks might be
    4209             :      * interested in it.
    4210             :      */
    4211       32630 :     if (!criticalSharedRelcachesBuilt)
    4212             :     {
    4213        2356 :         load_critical_index(DatabaseNameIndexId,
    4214             :                             DatabaseRelationId);
    4215        2356 :         load_critical_index(DatabaseOidIndexId,
    4216             :                             DatabaseRelationId);
    4217        2356 :         load_critical_index(AuthIdRolnameIndexId,
    4218             :                             AuthIdRelationId);
    4219        2356 :         load_critical_index(AuthIdOidIndexId,
    4220             :                             AuthIdRelationId);
    4221        2356 :         load_critical_index(AuthMemMemRoleIndexId,
    4222             :                             AuthMemRelationId);
    4223        2356 :         load_critical_index(SharedSecLabelObjectIndexId,
    4224             :                             SharedSecLabelRelationId);
    4225             : 
    4226             : #define NUM_CRITICAL_SHARED_INDEXES 6   /* fix if you change list above */
    4227             : 
    4228        2356 :         criticalSharedRelcachesBuilt = true;
    4229             :     }
    4230             : 
    4231             :     /*
    4232             :      * Now, scan all the relcache entries and update anything that might be
    4233             :      * wrong in the results from formrdesc or the relcache cache file. If we
    4234             :      * faked up relcache entries using formrdesc, then read the real pg_class
    4235             :      * rows and replace the fake entries with them. Also, if any of the
    4236             :      * relcache entries have rules, triggers, or security policies, load that
    4237             :      * info the hard way since it isn't recorded in the cache file.
    4238             :      *
    4239             :      * Whenever we access the catalogs to read data, there is a possibility of
    4240             :      * a shared-inval cache flush causing relcache entries to be removed.
    4241             :      * Since hash_seq_search only guarantees to still work after the *current*
    4242             :      * entry is removed, it's unsafe to continue the hashtable scan afterward.
    4243             :      * We handle this by restarting the scan from scratch after each access.
    4244             :      * This is theoretically O(N^2), but the number of entries that actually
    4245             :      * need to be fixed is small enough that it doesn't matter.
    4246             :      */
    4247       32630 :     hash_seq_init(&status, RelationIdCache);
    4248             : 
    4249     4678622 :     while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    4250             :     {
    4251     4645992 :         Relation    relation = idhentry->reldesc;
    4252     4645992 :         bool        restart = false;
    4253             : 
    4254             :         /*
    4255             :          * Make sure *this* entry doesn't get flushed while we work with it.
    4256             :          */
    4257     4645992 :         RelationIncrementReferenceCount(relation);
    4258             : 
    4259             :         /*
    4260             :          * If it's a faked-up entry, read the real pg_class tuple.
    4261             :          */
    4262     4645992 :         if (relation->rd_rel->relowner == InvalidOid)
    4263             :         {
    4264             :             HeapTuple   htup;
    4265             :             Form_pg_class relp;
    4266             : 
    4267       23932 :             htup = SearchSysCache1(RELOID,
    4268             :                                    ObjectIdGetDatum(RelationGetRelid(relation)));
    4269       23932 :             if (!HeapTupleIsValid(htup))
    4270           0 :                 ereport(FATAL,
    4271             :                         errcode(ERRCODE_UNDEFINED_OBJECT),
    4272             :                         errmsg_internal("cache lookup failed for relation %u",
    4273             :                                         RelationGetRelid(relation)));
    4274       23932 :             relp = (Form_pg_class) GETSTRUCT(htup);
    4275             : 
    4276             :             /*
    4277             :              * Copy tuple to relation->rd_rel. (See notes in
    4278             :              * AllocateRelationDesc())
    4279             :              */
    4280       23932 :             memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
    4281             : 
    4282             :             /* Update rd_options while we have the tuple */
    4283       23932 :             if (relation->rd_options)
    4284           0 :                 pfree(relation->rd_options);
    4285       23932 :             RelationParseRelOptions(relation, htup);
    4286             : 
    4287             :             /*
    4288             :              * Check the values in rd_att were set up correctly.  (We cannot
    4289             :              * just copy them over now: formrdesc must have set up the rd_att
    4290             :              * data correctly to start with, because it may already have been
    4291             :              * copied into one or more catcache entries.)
    4292             :              */
    4293             :             Assert(relation->rd_att->tdtypeid == relp->reltype);
    4294             :             Assert(relation->rd_att->tdtypmod == -1);
    4295             : 
    4296       23932 :             ReleaseSysCache(htup);
    4297             : 
    4298             :             /* relowner had better be OK now, else we'll loop forever */
    4299       23932 :             if (relation->rd_rel->relowner == InvalidOid)
    4300           0 :                 elog(ERROR, "invalid relowner in pg_class entry for \"%s\"",
    4301             :                      RelationGetRelationName(relation));
    4302             : 
    4303       23932 :             restart = true;
    4304             :         }
    4305             : 
    4306             :         /*
    4307             :          * Fix data that isn't saved in relcache cache file.
    4308             :          *
    4309             :          * relhasrules or relhastriggers could possibly be wrong or out of
    4310             :          * date.  If we don't actually find any rules or triggers, clear the
    4311             :          * local copy of the flag so that we don't get into an infinite loop
    4312             :          * here.  We don't make any attempt to fix the pg_class entry, though.
    4313             :          */
    4314     4645992 :         if (relation->rd_rel->relhasrules && relation->rd_rules == NULL)
    4315             :         {
    4316           0 :             RelationBuildRuleLock(relation);
    4317           0 :             if (relation->rd_rules == NULL)
    4318           0 :                 relation->rd_rel->relhasrules = false;
    4319           0 :             restart = true;
    4320             :         }
    4321     4645992 :         if (relation->rd_rel->relhastriggers && relation->trigdesc == NULL)
    4322             :         {
    4323           0 :             RelationBuildTriggers(relation);
    4324           0 :             if (relation->trigdesc == NULL)
    4325           0 :                 relation->rd_rel->relhastriggers = false;
    4326           0 :             restart = true;
    4327             :         }
    4328             : 
    4329             :         /*
    4330             :          * Re-load the row security policies if the relation has them, since
    4331             :          * they are not preserved in the cache.  Note that we can never NOT
    4332             :          * have a policy while relrowsecurity is true,
    4333             :          * RelationBuildRowSecurity will create a single default-deny policy
    4334             :          * if there is no policy defined in pg_policy.
    4335             :          */
    4336     4645992 :         if (relation->rd_rel->relrowsecurity && relation->rd_rsdesc == NULL)
    4337             :         {
    4338           0 :             RelationBuildRowSecurity(relation);
    4339             : 
    4340             :             Assert(relation->rd_rsdesc != NULL);
    4341           0 :             restart = true;
    4342             :         }
    4343             : 
    4344             :         /* Reload tableam data if needed */
    4345     4645992 :         if (relation->rd_tableam == NULL &&
    4346     2851662 :             (RELKIND_HAS_TABLE_AM(relation->rd_rel->relkind) || relation->rd_rel->relkind == RELKIND_SEQUENCE))
    4347             :         {
    4348           0 :             RelationInitTableAccessMethod(relation);
    4349             :             Assert(relation->rd_tableam != NULL);
    4350             : 
    4351           0 :             restart = true;
    4352             :         }
    4353             : 
    4354             :         /* Release hold on the relation */
    4355     4645992 :         RelationDecrementReferenceCount(relation);
    4356             : 
    4357             :         /* Now, restart the hashtable scan if needed */
    4358     4645992 :         if (restart)
    4359             :         {
    4360       23932 :             hash_seq_term(&status);
    4361       23932 :             hash_seq_init(&status, RelationIdCache);
    4362             :         }
    4363             :     }
    4364             : 
    4365             :     /*
    4366             :      * Lastly, write out new relcache cache files if needed.  We don't bother
    4367             :      * to distinguish cases where only one of the two needs an update.
    4368             :      */
    4369       32630 :     if (needNewCacheFile)
    4370             :     {
    4371             :         /*
    4372             :          * Force all the catcaches to finish initializing and thereby open the
    4373             :          * catalogs and indexes they use.  This will preload the relcache with
    4374             :          * entries for all the most important system catalogs and indexes, so
    4375             :          * that the init files will be most useful for future backends.
    4376             :          */
    4377        3424 :         InitCatalogCachePhase2();
    4378             : 
    4379             :         /* now write the files */
    4380        3422 :         write_relcache_init_file(true);
    4381        3422 :         write_relcache_init_file(false);
    4382             :     }
    4383             : }
    4384             : 
    4385             : /*
    4386             :  * Load one critical system index into the relcache
    4387             :  *
    4388             :  * indexoid is the OID of the target index, heapoid is the OID of the catalog
    4389             :  * it belongs to.
    4390             :  */
    4391             : static void
    4392       35418 : load_critical_index(Oid indexoid, Oid heapoid)
    4393             : {
    4394             :     Relation    ird;
    4395             : 
    4396             :     /*
    4397             :      * We must lock the underlying catalog before locking the index to avoid
    4398             :      * deadlock, since RelationBuildDesc might well need to read the catalog,
    4399             :      * and if anyone else is exclusive-locking this catalog and index they'll
    4400             :      * be doing it in that order.
    4401             :      */
    4402       35418 :     LockRelationOid(heapoid, AccessShareLock);
    4403       35418 :     LockRelationOid(indexoid, AccessShareLock);
    4404       35418 :     ird = RelationBuildDesc(indexoid, true);
    4405       35416 :     if (ird == NULL)
    4406           0 :         ereport(PANIC,
    4407             :                 errcode(ERRCODE_DATA_CORRUPTED),
    4408             :                 errmsg_internal("could not open critical system index %u", indexoid));
    4409       35416 :     ird->rd_isnailed = true;
    4410       35416 :     ird->rd_refcnt = 1;
    4411       35416 :     UnlockRelationOid(indexoid, AccessShareLock);
    4412       35416 :     UnlockRelationOid(heapoid, AccessShareLock);
    4413             : 
    4414       35416 :     (void) RelationGetIndexAttOptions(ird, false);
    4415       35416 : }
    4416             : 
    4417             : /*
    4418             :  * GetPgClassDescriptor -- get a predefined tuple descriptor for pg_class
    4419             :  * GetPgIndexDescriptor -- get a predefined tuple descriptor for pg_index
    4420             :  *
    4421             :  * We need this kluge because we have to be able to access non-fixed-width
    4422             :  * fields of pg_class and pg_index before we have the standard catalog caches
    4423             :  * available.  We use predefined data that's set up in just the same way as
    4424             :  * the bootstrapped reldescs used by formrdesc().  The resulting tupdesc is
    4425             :  * not 100% kosher: it does not have the correct rowtype OID in tdtypeid, nor
    4426             :  * does it have a TupleConstr field.  But it's good enough for the purpose of
    4427             :  * extracting fields.
    4428             :  */
    4429             : static TupleDesc
    4430       65460 : BuildHardcodedDescriptor(int natts, const FormData_pg_attribute *attrs)
    4431             : {
    4432             :     TupleDesc   result;
    4433             :     MemoryContext oldcxt;
    4434             :     int         i;
    4435             : 
    4436       65460 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    4437             : 
    4438       65460 :     result = CreateTemplateTupleDesc(natts);
    4439       65460 :     result->tdtypeid = RECORDOID;    /* not right, but we don't care */
    4440       65460 :     result->tdtypmod = -1;
    4441             : 
    4442     1865610 :     for (i = 0; i < natts; i++)
    4443             :     {
    4444     1800150 :         memcpy(TupleDescAttr(result, i), &attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
    4445             : 
    4446     1800150 :         populate_compact_attribute(result, i);
    4447             :     }
    4448             : 
    4449             :     /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
    4450       65460 :     TupleDescCompactAttr(result, 0)->attcacheoff = 0;
    4451             : 
    4452             :     /* Note: we don't bother to set up a TupleConstr entry */
    4453             : 
    4454       65460 :     MemoryContextSwitchTo(oldcxt);
    4455             : 
    4456       65460 :     return result;
    4457             : }
    4458             : 
    4459             : static TupleDesc
    4460     1685072 : GetPgClassDescriptor(void)
    4461             : {
    4462             :     static TupleDesc pgclassdesc = NULL;
    4463             : 
    4464             :     /* Already done? */
    4465     1685072 :     if (pgclassdesc == NULL)
    4466       32730 :         pgclassdesc = BuildHardcodedDescriptor(Natts_pg_class,
    4467             :                                                Desc_pg_class);
    4468             : 
    4469     1685072 :     return pgclassdesc;
    4470             : }
    4471             : 
    4472             : static TupleDesc
    4473     1962346 : GetPgIndexDescriptor(void)
    4474             : {
    4475             :     static TupleDesc pgindexdesc = NULL;
    4476             : 
    4477             :     /* Already done? */
    4478     1962346 :     if (pgindexdesc == NULL)
    4479       32730 :         pgindexdesc = BuildHardcodedDescriptor(Natts_pg_index,
    4480             :                                                Desc_pg_index);
    4481             : 
    4482     1962346 :     return pgindexdesc;
    4483             : }
    4484             : 
    4485             : /*
    4486             :  * Load any default attribute value definitions for the relation.
    4487             :  *
    4488             :  * ndef is the number of attributes that were marked atthasdef.
    4489             :  *
    4490             :  * Note: we don't make it a hard error to be missing some pg_attrdef records.
    4491             :  * We can limp along as long as nothing needs to use the default value.  Code
    4492             :  * that fails to find an expected AttrDefault record should throw an error.
    4493             :  */
    4494             : static void
    4495       38008 : AttrDefaultFetch(Relation relation, int ndef)
    4496             : {
    4497             :     AttrDefault *attrdef;
    4498             :     Relation    adrel;
    4499             :     SysScanDesc adscan;
    4500             :     ScanKeyData skey;
    4501             :     HeapTuple   htup;
    4502       38008 :     int         found = 0;
    4503             : 
    4504             :     /* Allocate array with room for as many entries as expected */
    4505             :     attrdef = (AttrDefault *)
    4506       38008 :         MemoryContextAllocZero(CacheMemoryContext,
    4507             :                                ndef * sizeof(AttrDefault));
    4508             : 
    4509             :     /* Search pg_attrdef for relevant entries */
    4510       38008 :     ScanKeyInit(&skey,
    4511             :                 Anum_pg_attrdef_adrelid,
    4512             :                 BTEqualStrategyNumber, F_OIDEQ,
    4513             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
    4514             : 
    4515       38008 :     adrel = table_open(AttrDefaultRelationId, AccessShareLock);
    4516       38008 :     adscan = systable_beginscan(adrel, AttrDefaultIndexId, true,
    4517             :                                 NULL, 1, &skey);
    4518             : 
    4519       91912 :     while (HeapTupleIsValid(htup = systable_getnext(adscan)))
    4520             :     {
    4521       53904 :         Form_pg_attrdef adform = (Form_pg_attrdef) GETSTRUCT(htup);
    4522             :         Datum       val;
    4523             :         bool        isnull;
    4524             : 
    4525             :         /* protect limited size of array */
    4526       53904 :         if (found >= ndef)
    4527             :         {
    4528           0 :             elog(WARNING, "unexpected pg_attrdef record found for attribute %d of relation \"%s\"",
    4529             :                  adform->adnum, RelationGetRelationName(relation));
    4530           0 :             break;
    4531             :         }
    4532             : 
    4533       53904 :         val = fastgetattr(htup,
    4534             :                           Anum_pg_attrdef_adbin,
    4535             :                           adrel->rd_att, &isnull);
    4536       53904 :         if (isnull)
    4537           0 :             elog(WARNING, "null adbin for attribute %d of relation \"%s\"",
    4538             :                  adform->adnum, RelationGetRelationName(relation));
    4539             :         else
    4540             :         {
    4541             :             /* detoast and convert to cstring in caller's context */
    4542       53904 :             char       *s = TextDatumGetCString(val);
    4543             : 
    4544       53904 :             attrdef[found].adnum = adform->adnum;
    4545       53904 :             attrdef[found].adbin = MemoryContextStrdup(CacheMemoryContext, s);
    4546       53904 :             pfree(s);
    4547       53904 :             found++;
    4548             :         }
    4549             :     }
    4550             : 
    4551       38008 :     systable_endscan(adscan);
    4552       38008 :     table_close(adrel, AccessShareLock);
    4553             : 
    4554       38008 :     if (found != ndef)
    4555           0 :         elog(WARNING, "%d pg_attrdef record(s) missing for relation \"%s\"",
    4556             :              ndef - found, RelationGetRelationName(relation));
    4557             : 
    4558             :     /*
    4559             :      * Sort the AttrDefault entries by adnum, for the convenience of
    4560             :      * equalTupleDescs().  (Usually, they already will be in order, but this
    4561             :      * might not be so if systable_getnext isn't using an index.)
    4562             :      */
    4563       38008 :     if (found > 1)
    4564        9026 :         qsort(attrdef, found, sizeof(AttrDefault), AttrDefaultCmp);
    4565             : 
    4566             :     /* Install array only after it's fully valid */
    4567       38008 :     relation->rd_att->constr->defval = attrdef;
    4568       38008 :     relation->rd_att->constr->num_defval = found;
    4569       38008 : }
    4570             : 
    4571             : /*
    4572             :  * qsort comparator to sort AttrDefault entries by adnum
    4573             :  */
    4574             : static int
    4575       15896 : AttrDefaultCmp(const void *a, const void *b)
    4576             : {
    4577       15896 :     const AttrDefault *ada = (const AttrDefault *) a;
    4578       15896 :     const AttrDefault *adb = (const AttrDefault *) b;
    4579             : 
    4580       15896 :     return pg_cmp_s16(ada->adnum, adb->adnum);
    4581             : }
    4582             : 
    4583             : /*
    4584             :  * Load any check constraints for the relation, and update not-null validity
    4585             :  * of invalid constraints.
    4586             :  *
    4587             :  * As with defaults, if we don't find the expected number of them, just warn
    4588             :  * here.  The executor should throw an error if an INSERT/UPDATE is attempted.
    4589             :  */
    4590             : static void
    4591      174740 : CheckNNConstraintFetch(Relation relation)
    4592             : {
    4593             :     ConstrCheck *check;
    4594      174740 :     int         ncheck = relation->rd_rel->relchecks;
    4595             :     Relation    conrel;
    4596             :     SysScanDesc conscan;
    4597             :     ScanKeyData skey[1];
    4598             :     HeapTuple   htup;
    4599      174740 :     int         found = 0;
    4600             : 
    4601             :     /* Allocate array with room for as many entries as expected, if needed */
    4602      174740 :     if (ncheck > 0)
    4603             :         check = (ConstrCheck *)
    4604       12948 :             MemoryContextAllocZero(CacheMemoryContext,
    4605             :                                    ncheck * sizeof(ConstrCheck));
    4606             :     else
    4607      161792 :         check = NULL;
    4608             : 
    4609             :     /* Search pg_constraint for relevant entries */
    4610      174740 :     ScanKeyInit(&skey[0],
    4611             :                 Anum_pg_constraint_conrelid,
    4612             :                 BTEqualStrategyNumber, F_OIDEQ,
    4613             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
    4614             : 
    4615      174740 :     conrel = table_open(ConstraintRelationId, AccessShareLock);
    4616      174740 :     conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
    4617             :                                  NULL, 1, skey);
    4618             : 
    4619      504440 :     while (HeapTupleIsValid(htup = systable_getnext(conscan)))
    4620             :     {
    4621      329700 :         Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(htup);
    4622             :         Datum       val;
    4623             :         bool        isnull;
    4624             : 
    4625             :         /*
    4626             :          * If this is a not-null constraint, then only look at it if it's
    4627             :          * invalid, and if so, mark the TupleDesc entry as known invalid.
    4628             :          * Otherwise move on.  We'll mark any remaining columns that are still
    4629             :          * in UNKNOWN state as known valid later.  This allows us not to have
    4630             :          * to extract the attnum from this constraint tuple in the vast
    4631             :          * majority of cases.
    4632             :          */
    4633      329700 :         if (conform->contype == CONSTRAINT_NOTNULL)
    4634             :         {
    4635      186418 :             if (!conform->convalidated)
    4636             :             {
    4637             :                 AttrNumber  attnum;
    4638             : 
    4639         864 :                 attnum = extractNotNullColumn(htup);
    4640             :                 Assert(relation->rd_att->compact_attrs[attnum - 1].attnullability ==
    4641             :                        ATTNULLABLE_UNKNOWN);
    4642         864 :                 relation->rd_att->compact_attrs[attnum - 1].attnullability =
    4643             :                     ATTNULLABLE_INVALID;
    4644             :             }
    4645             : 
    4646      309766 :             continue;
    4647             :         }
    4648             : 
    4649             :         /* For what follows, consider check constraints only */
    4650      143282 :         if (conform->contype != CONSTRAINT_CHECK)
    4651      123348 :             continue;
    4652             : 
    4653             :         /* protect limited size of array */
    4654       19934 :         if (found >= ncheck)
    4655             :         {
    4656           0 :             elog(WARNING, "unexpected pg_constraint record found for relation \"%s\"",
    4657             :                  RelationGetRelationName(relation));
    4658           0 :             break;
    4659             :         }
    4660             : 
    4661       19934 :         check[found].ccenforced = conform->conenforced;
    4662       19934 :         check[found].ccvalid = conform->convalidated;
    4663       19934 :         check[found].ccnoinherit = conform->connoinherit;
    4664       39868 :         check[found].ccname = MemoryContextStrdup(CacheMemoryContext,
    4665       19934 :                                                   NameStr(conform->conname));
    4666             : 
    4667             :         /* Grab and test conbin is actually set */
    4668       19934 :         val = fastgetattr(htup,
    4669             :                           Anum_pg_constraint_conbin,
    4670             :                           conrel->rd_att, &isnull);
    4671       19934 :         if (isnull)
    4672           0 :             elog(WARNING, "null conbin for relation \"%s\"",
    4673             :                  RelationGetRelationName(relation));
    4674             :         else
    4675             :         {
    4676             :             /* detoast and convert to cstring in caller's context */
    4677       19934 :             char       *s = TextDatumGetCString(val);
    4678             : 
    4679       19934 :             check[found].ccbin = MemoryContextStrdup(CacheMemoryContext, s);
    4680       19934 :             pfree(s);
    4681       19934 :             found++;
    4682             :         }
    4683             :     }
    4684             : 
    4685      174740 :     systable_endscan(conscan);
    4686      174740 :     table_close(conrel, AccessShareLock);
    4687             : 
    4688      174740 :     if (found != ncheck)
    4689           0 :         elog(WARNING, "%d pg_constraint record(s) missing for relation \"%s\"",
    4690             :              ncheck - found, RelationGetRelationName(relation));
    4691             : 
    4692             :     /*
    4693             :      * Sort the records by name.  This ensures that CHECKs are applied in a
    4694             :      * deterministic order, and it also makes equalTupleDescs() faster.
    4695             :      */
    4696      174740 :     if (found > 1)
    4697        3812 :         qsort(check, found, sizeof(ConstrCheck), CheckConstraintCmp);
    4698             : 
    4699             :     /* Install array only after it's fully valid */
    4700      174740 :     relation->rd_att->constr->check = check;
    4701      174740 :     relation->rd_att->constr->num_check = found;
    4702      174740 : }
    4703             : 
    4704             : /*
    4705             :  * qsort comparator to sort ConstrCheck entries by name
    4706             :  */
    4707             : static int
    4708        6986 : CheckConstraintCmp(const void *a, const void *b)
    4709             : {
    4710        6986 :     const ConstrCheck *ca = (const ConstrCheck *) a;
    4711        6986 :     const ConstrCheck *cb = (const ConstrCheck *) b;
    4712             : 
    4713        6986 :     return strcmp(ca->ccname, cb->ccname);
    4714             : }
    4715             : 
    4716             : /*
    4717             :  * RelationGetFKeyList -- get a list of foreign key info for the relation
    4718             :  *
    4719             :  * Returns a list of ForeignKeyCacheInfo structs, one per FK constraining
    4720             :  * the given relation.  This data is a direct copy of relevant fields from
    4721             :  * pg_constraint.  The list items are in no particular order.
    4722             :  *
    4723             :  * CAUTION: the returned list is part of the relcache's data, and could
    4724             :  * vanish in a relcache entry reset.  Callers must inspect or copy it
    4725             :  * before doing anything that might trigger a cache flush, such as
    4726             :  * system catalog accesses.  copyObject() can be used if desired.
    4727             :  * (We define it this way because current callers want to filter and
    4728             :  * modify the list entries anyway, so copying would be a waste of time.)
    4729             :  */
    4730             : List *
    4731      232316 : RelationGetFKeyList(Relation relation)
    4732             : {
    4733             :     List       *result;
    4734             :     Relation    conrel;
    4735             :     SysScanDesc conscan;
    4736             :     ScanKeyData skey;
    4737             :     HeapTuple   htup;
    4738             :     List       *oldlist;
    4739             :     MemoryContext oldcxt;
    4740             : 
    4741             :     /* Quick exit if we already computed the list. */
    4742      232316 :     if (relation->rd_fkeyvalid)
    4743      186970 :         return relation->rd_fkeylist;
    4744             : 
    4745             :     /*
    4746             :      * We build the list we intend to return (in the caller's context) while
    4747             :      * doing the scan.  After successfully completing the scan, we copy that
    4748             :      * list into the relcache entry.  This avoids cache-context memory leakage
    4749             :      * if we get some sort of error partway through.
    4750             :      */
    4751       45346 :     result = NIL;
    4752             : 
    4753             :     /* Prepare to scan pg_constraint for entries having conrelid = this rel. */
    4754       45346 :     ScanKeyInit(&skey,
    4755             :                 Anum_pg_constraint_conrelid,
    4756             :                 BTEqualStrategyNumber, F_OIDEQ,
    4757             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
    4758             : 
    4759       45346 :     conrel = table_open(ConstraintRelationId, AccessShareLock);
    4760       45346 :     conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
    4761             :                                  NULL, 1, &skey);
    4762             : 
    4763      141010 :     while (HeapTupleIsValid(htup = systable_getnext(conscan)))
    4764             :     {
    4765       95664 :         Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(htup);
    4766             :         ForeignKeyCacheInfo *info;
    4767             : 
    4768             :         /* consider only foreign keys */
    4769       95664 :         if (constraint->contype != CONSTRAINT_FOREIGN)
    4770       91982 :             continue;
    4771             : 
    4772        3682 :         info = makeNode(ForeignKeyCacheInfo);
    4773        3682 :         info->conoid = constraint->oid;
    4774        3682 :         info->conrelid = constraint->conrelid;
    4775        3682 :         info->confrelid = constraint->confrelid;
    4776        3682 :         info->conenforced = constraint->conenforced;
    4777             : 
    4778        3682 :         DeconstructFkConstraintRow(htup, &info->nkeys,
    4779        3682 :                                    info->conkey,
    4780        3682 :                                    info->confkey,
    4781        3682 :                                    info->conpfeqop,
    4782             :                                    NULL, NULL, NULL, NULL);
    4783             : 
    4784             :         /* Add FK's node to the result list */
    4785        3682 :         result = lappend(result, info);
    4786             :     }
    4787             : 
    4788       45346 :     systable_endscan(conscan);
    4789       45346 :     table_close(conrel, AccessShareLock);
    4790             : 
    4791             :     /* Now save a copy of the completed list in the relcache entry. */
    4792       45346 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    4793       45346 :     oldlist = relation->rd_fkeylist;
    4794       45346 :     relation->rd_fkeylist = copyObject(result);
    4795       45346 :     relation->rd_fkeyvalid = true;
    4796       45346 :     MemoryContextSwitchTo(oldcxt);
    4797             : 
    4798             :     /* Don't leak the old list, if there is one */
    4799       45346 :     list_free_deep(oldlist);
    4800             : 
    4801       45346 :     return result;
    4802             : }
    4803             : 
    4804             : /*
    4805             :  * RelationGetIndexList -- get a list of OIDs of indexes on this relation
    4806             :  *
    4807             :  * The index list is created only if someone requests it.  We scan pg_index
    4808             :  * to find relevant indexes, and add the list to the relcache entry so that
    4809             :  * we won't have to compute it again.  Note that shared cache inval of a
    4810             :  * relcache entry will delete the old list and set rd_indexvalid to false,
    4811             :  * so that we must recompute the index list on next request.  This handles
    4812             :  * creation or deletion of an index.
    4813             :  *
    4814             :  * Indexes that are marked not indislive are omitted from the returned list.
    4815             :  * Such indexes are expected to be dropped momentarily, and should not be
    4816             :  * touched at all by any caller of this function.
    4817             :  *
    4818             :  * The returned list is guaranteed to be sorted in order by OID.  This is
    4819             :  * needed by the executor, since for index types that we obtain exclusive
    4820             :  * locks on when updating the index, all backends must lock the indexes in
    4821             :  * the same order or we will get deadlocks (see ExecOpenIndices()).  Any
    4822             :  * consistent ordering would do, but ordering by OID is easy.
    4823             :  *
    4824             :  * Since shared cache inval causes the relcache's copy of the list to go away,
    4825             :  * we return a copy of the list palloc'd in the caller's context.  The caller
    4826             :  * may list_free() the returned list after scanning it. This is necessary
    4827             :  * since the caller will typically be doing syscache lookups on the relevant
    4828             :  * indexes, and syscache lookup could cause SI messages to be processed!
    4829             :  *
    4830             :  * In exactly the same way, we update rd_pkindex, which is the OID of the
    4831             :  * relation's primary key index if any, else InvalidOid; and rd_replidindex,
    4832             :  * which is the pg_class OID of an index to be used as the relation's
    4833             :  * replication identity index, or InvalidOid if there is no such index.
    4834             :  */
    4835             : List *
    4836     2376104 : RelationGetIndexList(Relation relation)
    4837             : {
    4838             :     Relation    indrel;
    4839             :     SysScanDesc indscan;
    4840             :     ScanKeyData skey;
    4841             :     HeapTuple   htup;
    4842             :     List       *result;
    4843             :     List       *oldlist;
    4844     2376104 :     char        replident = relation->rd_rel->relreplident;
    4845     2376104 :     Oid         pkeyIndex = InvalidOid;
    4846     2376104 :     Oid         candidateIndex = InvalidOid;
    4847     2376104 :     bool        pkdeferrable = false;
    4848             :     MemoryContext oldcxt;
    4849             : 
    4850             :     /* Quick exit if we already computed the list. */
    4851     2376104 :     if (relation->rd_indexvalid)
    4852     2084682 :         return list_copy(relation->rd_indexlist);
    4853             : 
    4854             :     /*
    4855             :      * We build the list we intend to return (in the caller's context) while
    4856             :      * doing the scan.  After successfully completing the scan, we copy that
    4857             :      * list into the relcache entry.  This avoids cache-context memory leakage
    4858             :      * if we get some sort of error partway through.
    4859             :      */
    4860      291422 :     result = NIL;
    4861             : 
    4862             :     /* Prepare to scan pg_index for entries having indrelid = this rel. */
    4863      291422 :     ScanKeyInit(&skey,
    4864             :                 Anum_pg_index_indrelid,
    4865             :                 BTEqualStrategyNumber, F_OIDEQ,
    4866             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
    4867             : 
    4868      291422 :     indrel = table_open(IndexRelationId, AccessShareLock);
    4869      291422 :     indscan = systable_beginscan(indrel, IndexIndrelidIndexId, true,
    4870             :                                  NULL, 1, &skey);
    4871             : 
    4872      720292 :     while (HeapTupleIsValid(htup = systable_getnext(indscan)))
    4873             :     {
    4874      428870 :         Form_pg_index index = (Form_pg_index) GETSTRUCT(htup);
    4875             : 
    4876             :         /*
    4877             :          * Ignore any indexes that are currently being dropped.  This will
    4878             :          * prevent them from being searched, inserted into, or considered in
    4879             :          * HOT-safety decisions.  It's unsafe to touch such an index at all
    4880             :          * since its catalog entries could disappear at any instant.
    4881             :          */
    4882      428870 :         if (!index->indislive)
    4883          66 :             continue;
    4884             : 
    4885             :         /* add index's OID to result list */
    4886      428804 :         result = lappend_oid(result, index->indexrelid);
    4887             : 
    4888             :         /*
    4889             :          * Non-unique or predicate indexes aren't interesting for either oid
    4890             :          * indexes or replication identity indexes, so don't check them.
    4891             :          * Deferred ones are not useful for replication identity either; but
    4892             :          * we do include them if they are PKs.
    4893             :          */
    4894      428804 :         if (!index->indisunique ||
    4895      362678 :             !heap_attisnull(htup, Anum_pg_index_indpred, NULL))
    4896       66290 :             continue;
    4897             : 
    4898             :         /*
    4899             :          * Remember primary key index, if any.  For regular tables we do this
    4900             :          * only if the index is valid; but for partitioned tables, then we do
    4901             :          * it even if it's invalid.
    4902             :          *
    4903             :          * The reason for returning invalid primary keys for partitioned
    4904             :          * tables is that we need it to prevent drop of not-null constraints
    4905             :          * that may underlie such a primary key, which is only a problem for
    4906             :          * partitioned tables.
    4907             :          */
    4908      362514 :         if (index->indisprimary &&
    4909      233312 :             (index->indisvalid ||
    4910          12 :              relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE))
    4911             :         {
    4912      233312 :             pkeyIndex = index->indexrelid;
    4913      233312 :             pkdeferrable = !index->indimmediate;
    4914             :         }
    4915             : 
    4916      362514 :         if (!index->indimmediate)
    4917         140 :             continue;
    4918             : 
    4919      362374 :         if (!index->indisvalid)
    4920          68 :             continue;
    4921             : 
    4922             :         /* remember explicitly chosen replica index */
    4923      362306 :         if (index->indisreplident)
    4924         552 :             candidateIndex = index->indexrelid;
    4925             :     }
    4926             : 
    4927      291422 :     systable_endscan(indscan);
    4928             : 
    4929      291422 :     table_close(indrel, AccessShareLock);
    4930             : 
    4931             :     /* Sort the result list into OID order, per API spec. */
    4932      291422 :     list_sort(result, list_oid_cmp);
    4933             : 
    4934             :     /* Now save a copy of the completed list in the relcache entry. */
    4935      291422 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    4936      291422 :     oldlist = relation->rd_indexlist;
    4937      291422 :     relation->rd_indexlist = list_copy(result);
    4938      291422 :     relation->rd_pkindex = pkeyIndex;
    4939      291422 :     relation->rd_ispkdeferrable = pkdeferrable;
    4940      291422 :     if (replident == REPLICA_IDENTITY_DEFAULT && OidIsValid(pkeyIndex) && !pkdeferrable)
    4941       26398 :         relation->rd_replidindex = pkeyIndex;
    4942      265024 :     else if (replident == REPLICA_IDENTITY_INDEX && OidIsValid(candidateIndex))
    4943         552 :         relation->rd_replidindex = candidateIndex;
    4944             :     else
    4945      264472 :         relation->rd_replidindex = InvalidOid;
    4946      291422 :     relation->rd_indexvalid = true;
    4947      291422 :     MemoryContextSwitchTo(oldcxt);
    4948             : 
    4949             :     /* Don't leak the old list, if there is one */
    4950      291422 :     list_free(oldlist);
    4951             : 
    4952      291422 :     return result;
    4953             : }
    4954             : 
    4955             : /*
    4956             :  * RelationGetStatExtList
    4957             :  *      get a list of OIDs of statistics objects on this relation
    4958             :  *
    4959             :  * The statistics list is created only if someone requests it, in a way
    4960             :  * similar to RelationGetIndexList().  We scan pg_statistic_ext to find
    4961             :  * relevant statistics, and add the list to the relcache entry so that we
    4962             :  * won't have to compute it again.  Note that shared cache inval of a
    4963             :  * relcache entry will delete the old list and set rd_statvalid to 0,
    4964             :  * so that we must recompute the statistics list on next request.  This
    4965             :  * handles creation or deletion of a statistics object.
    4966             :  *
    4967             :  * The returned list is guaranteed to be sorted in order by OID, although
    4968             :  * this is not currently needed.
    4969             :  *
    4970             :  * Since shared cache inval causes the relcache's copy of the list to go away,
    4971             :  * we return a copy of the list palloc'd in the caller's context.  The caller
    4972             :  * may list_free() the returned list after scanning it. This is necessary
    4973             :  * since the caller will typically be doing syscache lookups on the relevant
    4974             :  * statistics, and syscache lookup could cause SI messages to be processed!
    4975             :  */
    4976             : List *
    4977      476484 : RelationGetStatExtList(Relation relation)
    4978             : {
    4979             :     Relation    indrel;
    4980             :     SysScanDesc indscan;
    4981             :     ScanKeyData skey;
    4982             :     HeapTuple   htup;
    4983             :     List       *result;
    4984             :     List       *oldlist;
    4985             :     MemoryContext oldcxt;
    4986             : 
    4987             :     /* Quick exit if we already computed the list. */
    4988      476484 :     if (relation->rd_statvalid != 0)
    4989      355432 :         return list_copy(relation->rd_statlist);
    4990             : 
    4991             :     /*
    4992             :      * We build the list we intend to return (in the caller's context) while
    4993             :      * doing the scan.  After successfully completing the scan, we copy that
    4994             :      * list into the relcache entry.  This avoids cache-context memory leakage
    4995             :      * if we get some sort of error partway through.
    4996             :      */
    4997      121052 :     result = NIL;
    4998             : 
    4999             :     /*
    5000             :      * Prepare to scan pg_statistic_ext for entries having stxrelid = this
    5001             :      * rel.
    5002             :      */
    5003      121052 :     ScanKeyInit(&skey,
    5004             :                 Anum_pg_statistic_ext_stxrelid,
    5005             :                 BTEqualStrategyNumber, F_OIDEQ,
    5006             :                 ObjectIdGetDatum(RelationGetRelid(relation)));
    5007             : 
    5008      121052 :     indrel = table_open(StatisticExtRelationId, AccessShareLock);
    5009      121052 :     indscan = systable_beginscan(indrel, StatisticExtRelidIndexId, true,
    5010             :                                  NULL, 1, &skey);
    5011             : 
    5012      121462 :     while (HeapTupleIsValid(htup = systable_getnext(indscan)))
    5013             :     {
    5014         410 :         Oid         oid = ((Form_pg_statistic_ext) GETSTRUCT(htup))->oid;
    5015             : 
    5016         410 :         result = lappend_oid(result, oid);
    5017             :     }
    5018             : 
    5019      121052 :     systable_endscan(indscan);
    5020             : 
    5021      121052 :     table_close(indrel, AccessShareLock);
    5022             : 
    5023             :     /* Sort the result list into OID order, per API spec. */
    5024      121052 :     list_sort(result, list_oid_cmp);
    5025             : 
    5026             :     /* Now save a copy of the completed list in the relcache entry. */
    5027      121052 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    5028      121052 :     oldlist = relation->rd_statlist;
    5029      121052 :     relation->rd_statlist = list_copy(result);
    5030             : 
    5031      121052 :     relation->rd_statvalid = true;
    5032      121052 :     MemoryContextSwitchTo(oldcxt);
    5033             : 
    5034             :     /* Don't leak the old list, if there is one */
    5035      121052 :     list_free(oldlist);
    5036             : 
    5037      121052 :     return result;
    5038             : }
    5039             : 
    5040             : /*
    5041             :  * RelationGetPrimaryKeyIndex -- get OID of the relation's primary key index
    5042             :  *
    5043             :  * Returns InvalidOid if there is no such index, or if the primary key is
    5044             :  * DEFERRABLE and the caller isn't OK with that.
    5045             :  */
    5046             : Oid
    5047         430 : RelationGetPrimaryKeyIndex(Relation relation, bool deferrable_ok)
    5048             : {
    5049             :     List       *ilist;
    5050             : 
    5051         430 :     if (!relation->rd_indexvalid)
    5052             :     {
    5053             :         /* RelationGetIndexList does the heavy lifting. */
    5054          18 :         ilist = RelationGetIndexList(relation);
    5055          18 :         list_free(ilist);
    5056             :         Assert(relation->rd_indexvalid);
    5057             :     }
    5058             : 
    5059         430 :     if (deferrable_ok)
    5060          18 :         return relation->rd_pkindex;
    5061         412 :     else if (relation->rd_ispkdeferrable)
    5062           0 :         return InvalidOid;
    5063         412 :     return relation->rd_pkindex;
    5064             : }
    5065             : 
    5066             : /*
    5067             :  * RelationGetReplicaIndex -- get OID of the relation's replica identity index
    5068             :  *
    5069             :  * Returns InvalidOid if there is no such index.
    5070             :  */
    5071             : Oid
    5072      318666 : RelationGetReplicaIndex(Relation relation)
    5073             : {
    5074             :     List       *ilist;
    5075             : 
    5076      318666 :     if (!relation->rd_indexvalid)
    5077             :     {
    5078             :         /* RelationGetIndexList does the heavy lifting. */
    5079        5078 :         ilist = RelationGetIndexList(relation);
    5080        5078 :         list_free(ilist);
    5081             :         Assert(relation->rd_indexvalid);
    5082             :     }
    5083             : 
    5084      318666 :     return relation->rd_replidindex;
    5085             : }
    5086             : 
    5087             : /*
    5088             :  * RelationGetIndexExpressions -- get the index expressions for an index
    5089             :  *
    5090             :  * We cache the result of transforming pg_index.indexprs into a node tree.
    5091             :  * If the rel is not an index or has no expressional columns, we return NIL.
    5092             :  * Otherwise, the returned tree is copied into the caller's memory context.
    5093             :  * (We don't want to return a pointer to the relcache copy, since it could
    5094             :  * disappear due to relcache invalidation.)
    5095             :  */
    5096             : List *
    5097     4303082 : RelationGetIndexExpressions(Relation relation)
    5098             : {
    5099             :     List       *result;
    5100             :     Datum       exprsDatum;
    5101             :     bool        isnull;
    5102             :     char       *exprsString;
    5103             :     MemoryContext oldcxt;
    5104             : 
    5105             :     /* Quick exit if we already computed the result. */
    5106     4303082 :     if (relation->rd_indexprs)
    5107        3464 :         return copyObject(relation->rd_indexprs);
    5108             : 
    5109             :     /* Quick exit if there is nothing to do. */
    5110     8599236 :     if (relation->rd_indextuple == NULL ||
    5111     4299618 :         heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
    5112     4297952 :         return NIL;
    5113             : 
    5114             :     /*
    5115             :      * We build the tree we intend to return in the caller's context. After
    5116             :      * successfully completing the work, we copy it into the relcache entry.
    5117             :      * This avoids problems if we get some sort of error partway through.
    5118             :      */
    5119        1666 :     exprsDatum = heap_getattr(relation->rd_indextuple,
    5120             :                               Anum_pg_index_indexprs,
    5121             :                               GetPgIndexDescriptor(),
    5122             :                               &isnull);
    5123             :     Assert(!isnull);
    5124        1666 :     exprsString = TextDatumGetCString(exprsDatum);
    5125        1666 :     result = (List *) stringToNode(exprsString);
    5126        1666 :     pfree(exprsString);
    5127             : 
    5128             :     /*
    5129             :      * Run the expressions through eval_const_expressions. This is not just an
    5130             :      * optimization, but is necessary, because the planner will be comparing
    5131             :      * them to similarly-processed qual clauses, and may fail to detect valid
    5132             :      * matches without this.  We must not use canonicalize_qual, however,
    5133             :      * since these aren't qual expressions.
    5134             :      */
    5135        1666 :     result = (List *) eval_const_expressions(NULL, (Node *) result);
    5136             : 
    5137             :     /* May as well fix opfuncids too */
    5138        1666 :     fix_opfuncids((Node *) result);
    5139             : 
    5140             :     /* Now save a copy of the completed tree in the relcache entry. */
    5141        1666 :     oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
    5142        1666 :     relation->rd_indexprs = copyObject(result);
    5143        1666 :     MemoryContextSwitchTo(oldcxt);
    5144             : 
    5145        1666 :     return result;
    5146             : }
    5147             : 
    5148             : /*
    5149             :  * RelationGetDummyIndexExpressions -- get dummy expressions for an index
    5150             :  *
    5151             :  * Return a list of dummy expressions (just Const nodes) with the same
    5152             :  * types/typmods/collations as the index's real expressions.  This is
    5153             :  * useful in situations where we don't want to run any user-defined code.
    5154             :  */
    5155             : List *
    5156         278 : RelationGetDummyIndexExpressions(Relation relation)
    5157             : {
    5158             :     List       *result;
    5159             :     Datum       exprsDatum;
    5160             :     bool        isnull;
    5161             :     char       *exprsString;
    5162             :     List       *rawExprs;
    5163             :     ListCell   *lc;
    5164             : 
    5165             :     /* Quick exit if there is nothing to do. */
    5166         556 :     if (relation->rd_indextuple == NULL ||
    5167         278 :         heap_attisnull(relation->rd_indextuple, Anum_pg_index_indexprs, NULL))
    5168         224 :         return NIL;
    5169             : 
    5170             :     /* Extract raw node tree(s) from index tuple. */
    5171          54 :     exprsDatum = heap_getattr(relation->rd_indextuple,
    5172             :                               Anum_pg_index_indexprs,
    5173             :                               GetPgIndexDescriptor(),
    5174             :                               &isnull);
    5175             :     Assert(!isnull);
    5176          54 :     exprsString = TextDatumGetCString(exprsDatum);
    5177          54 :     rawExprs = (List *) stringToNode(exprsString);
    5178          54 :     pfree(exprsString);
    5179             : 
    5180             :     /* Construct null Consts; the typlen and typbyval are arbitrary. */
    5181          54 :     result = NIL;
    5182         108 :     foreach(lc, rawExprs)
    5183             :     {
    5184          54 :         Node       *rawExpr = (Node *) lfirst(lc);
    5185             : 
    5186          54 :         result = lappend(result,
    5187          54 :                          makeConst(exprType(rawExpr),
    5188             :                                    exprTypmod(rawExpr),
    5189             :                                    exprCollation(rawExpr),
    5190             :                                    1,
    5191             :                                    (Datum) 0,
    5192             :                                    true,
    5193             :                                    true));
    5194             :     }
    5195             : 
    5196          54 :     return result;
    5197             : }
    5198             : 
    5199             : /*
    5200             :  * RelationGetIndexPredicate -- get the index predicate for an index
    5201             :  *
    5202             :  * We cache the result of transforming pg_index.indpred into an implicit-AND
    5203             :  * node tree (suitable for use in planning).
    5204             :  * If the rel is not an index or has no predicate, we return NIL.
    5205             :  * Otherwise, the returned tree is copied into the caller's memory context.
    5206             :  * (We don't want to return a pointer to the relcache copy, since it could
    5207             :  * disappear due to relcache invalidation.)
    5208             :  */
    5209             : List *
    5210     4302912 : RelationGetIndexPredicate(Relation relation)
    5211             : {
    5212             :     List       *result;
    5213             :     Datum       predDatum;
    5214             :     bool        isnull;
    5215             :     char       *predString;
    5216             :     MemoryContext oldcxt;
    5217             : 
    5218             :     /* Quick exit if we already computed the result. */
    5219     4302912 :     if (relation->rd_indpred)
    5220        1284 :         return copyObject(relation->rd_indpred);
    5221             : 
    5222             :     /* Quick exit if there is nothing to do. */
    5223     8603256 :     if (relation->rd_indextuple == NULL ||
    5224     4301628 :         heap_attisnull(relation->rd_indextuple, Anum_pg_index_indpred, NULL))
    5225     4300652 :         return NIL;
    5226             : 
    5227             :     /*
    5228             :      * We build the tree we intend to return in the caller's context. After
    5229             :      * successfully completing the work, we copy it into the relcache entry.
    5230             :      * This avoids problems if we get some sort of error partway through.
    5231             :      */
    5232         976 :     predDatum = heap_getattr(relation->rd_indextuple,
    5233             :                              Anum_pg_index_indpred,
    5234             :                              GetPgIndexDescriptor(),
    5235             :                              &isnull);
    5236             :     Assert(!isnull);
    5237         976 :     predString = TextDatumGetCString(predDatum);
    5238         976 :     result = (List *) stringToNode(predString);
    5239         976 :     pfree(predString);
    5240             : 
    5241             :     /*
    5242             :      * Run the expression through const-simplification and canonicalization.
    5243             :      * This is not just an optimization, but is necessary, because the planner
    5244             :      * will be comparing it to similarly-processed qual clauses, and may fail
    5245             :      * to detect valid matches without this.  This must match the processing
    5246             :      * done to qual clauses in preprocess_expression()!  (We can skip the
    5247             :      * stuff involving subqueries, however, since we don't allow any in index
    5248             :      * predicates.)
    5249             :      */
    5250         976 :     result = (List *) eval_const_expressions(NULL, (Node *) result);
    5251             : 
    5252         976 :     result = (List *) canonicalize_qual((Expr *) result, false);
    5253             : 
    5254             :     /* Also convert to implicit-AND format */
    5255         976 :     result = make_ands_implicit((Expr *) result);
    5256             : 
    5257             :     /* May as well fix opfuncids too */
    5258         976 :     fix_opfuncids((Node *) result);
    5259             : 
    5260             :     /* Now save a copy of the completed tree in the relcache entry. */
    5261         976 :     oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
    5262         976 :     relation->rd_indpred = copyObject(result);
    5263         976 :     MemoryContextSwitchTo(oldcxt);
    5264             : 
    5265         976 :     return result;
    5266             : }
    5267             : 
    5268             : /*
    5269             :  * RelationGetIndexAttrBitmap -- get a bitmap of index attribute numbers
    5270             :  *
    5271             :  * The result has a bit set for each attribute used anywhere in the index
    5272             :  * definitions of all the indexes on this relation.  (This includes not only
    5273             :  * simple index keys, but attributes used in expressions and partial-index
    5274             :  * predicates.)
    5275             :  *
    5276             :  * Depending on attrKind, a bitmap covering attnums for certain columns is
    5277             :  * returned:
    5278             :  *  INDEX_ATTR_BITMAP_KEY           Columns in non-partial unique indexes not
    5279             :  *                                  in expressions (i.e., usable for FKs)
    5280             :  *  INDEX_ATTR_BITMAP_PRIMARY_KEY   Columns in the table's primary key
    5281             :  *                                  (beware: even if PK is deferrable!)
    5282             :  *  INDEX_ATTR_BITMAP_IDENTITY_KEY  Columns in the table's replica identity
    5283             :  *                                  index (empty if FULL)
    5284             :  *  INDEX_ATTR_BITMAP_HOT_BLOCKING  Columns that block updates from being HOT
    5285             :  *  INDEX_ATTR_BITMAP_SUMMARIZED    Columns included in summarizing indexes
    5286             :  *
    5287             :  * Attribute numbers are offset by FirstLowInvalidHeapAttributeNumber so that
    5288             :  * we can include system attributes (e.g., OID) in the bitmap representation.
    5289             :  *
    5290             :  * Deferred indexes are considered for the primary key, but not for replica
    5291             :  * identity.
    5292             :  *
    5293             :  * Caller had better hold at least RowExclusiveLock on the target relation
    5294             :  * to ensure it is safe (deadlock-free) for us to take locks on the relation's
    5295             :  * indexes.  Note that since the introduction of CREATE INDEX CONCURRENTLY,
    5296             :  * that lock level doesn't guarantee a stable set of indexes, so we have to
    5297             :  * be prepared to retry here in case of a change in the set of indexes.
    5298             :  *
    5299             :  * The returned result is palloc'd in the caller's memory context and should
    5300             :  * be bms_free'd when not needed anymore.
    5301             :  */
    5302             : Bitmapset *
    5303     2759464 : RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
    5304             : {
    5305             :     Bitmapset  *uindexattrs;    /* columns in unique indexes */
    5306             :     Bitmapset  *pkindexattrs;   /* columns in the primary index */
    5307             :     Bitmapset  *idindexattrs;   /* columns in the replica identity */
    5308             :     Bitmapset  *hotblockingattrs;   /* columns with HOT blocking indexes */
    5309             :     Bitmapset  *summarizedattrs;    /* columns with summarizing indexes */
    5310             :     List       *indexoidlist;
    5311             :     List       *newindexoidlist;
    5312             :     Oid         relpkindex;
    5313             :     Oid         relreplindex;
    5314             :     ListCell   *l;
    5315             :     MemoryContext oldcxt;
    5316             : 
    5317             :     /* Quick exit if we already computed the result. */
    5318     2759464 :     if (relation->rd_attrsvalid)
    5319             :     {
    5320     2331204 :         switch (attrKind)
    5321             :         {
    5322      567092 :             case INDEX_ATTR_BITMAP_KEY:
    5323      567092 :                 return bms_copy(relation->rd_keyattr);
    5324          72 :             case INDEX_ATTR_BITMAP_PRIMARY_KEY:
    5325          72 :                 return bms_copy(relation->rd_pkattr);
    5326      654844 :             case INDEX_ATTR_BITMAP_IDENTITY_KEY:
    5327      654844 :                 return bms_copy(relation->rd_idattr);
    5328      548624 :             case INDEX_ATTR_BITMAP_HOT_BLOCKING:
    5329      548624 :                 return bms_copy(relation->rd_hotblockingattr);
    5330      560572 :             case INDEX_ATTR_BITMAP_SUMMARIZED:
    5331      560572 :                 return bms_copy(relation->rd_summarizedattr);
    5332           0 :             default:
    5333           0 :                 elog(ERROR, "unknown attrKind %u", attrKind);
    5334             :         }
    5335             :     }
    5336             : 
    5337             :     /* Fast path if definitely no indexes */
    5338      428260 :     if (!RelationGetForm(relation)->relhasindex)
    5339      412908 :         return NULL;
    5340             : 
    5341             :     /*
    5342             :      * Get cached list of index OIDs. If we have to start over, we do so here.
    5343             :      */
    5344       15352 : restart:
    5345       15352 :     indexoidlist = RelationGetIndexList(relation);
    5346             : 
    5347             :     /* Fall out if no indexes (but relhasindex was set) */
    5348       15352 :     if (indexoidlist == NIL)
    5349        1134 :         return NULL;
    5350             : 
    5351             :     /*
    5352             :      * Copy the rd_pkindex and rd_replidindex values computed by
    5353             :      * RelationGetIndexList before proceeding.  This is needed because a
    5354             :      * relcache flush could occur inside index_open below, resetting the
    5355             :      * fields managed by RelationGetIndexList.  We need to do the work with
    5356             :      * stable values of these fields.
    5357             :      */
    5358       14218 :     relpkindex = relation->rd_pkindex;
    5359       14218 :     relreplindex = relation->rd_replidindex;
    5360             : 
    5361             :     /*
    5362             :      * For each index, add referenced attributes to indexattrs.
    5363             :      *
    5364             :      * Note: we consider all indexes returned by RelationGetIndexList, even if
    5365             :      * they are not indisready or indisvalid.  This is important because an
    5366             :      * index for which CREATE INDEX CONCURRENTLY has just started must be
    5367             :      * included in HOT-safety decisions (see README.HOT).  If a DROP INDEX
    5368             :      * CONCURRENTLY is far enough along that we should ignore the index, it
    5369             :      * won't be returned at all by RelationGetIndexList.
    5370             :      */
    5371       14218 :     uindexattrs = NULL;
    5372       14218 :     pkindexattrs = NULL;
    5373       14218 :     idindexattrs = NULL;
    5374       14218 :     hotblockingattrs = NULL;
    5375       14218 :     summarizedattrs = NULL;
    5376       40194 :     foreach(l, indexoidlist)
    5377             :     {
    5378       25976 :         Oid         indexOid = lfirst_oid(l);
    5379             :         Relation    indexDesc;
    5380             :         Datum       datum;
    5381             :         bool        isnull;
    5382             :         Node       *indexExpressions;
    5383             :         Node       *indexPredicate;
    5384             :         int         i;
    5385             :         bool        isKey;      /* candidate key */
    5386             :         bool        isPK;       /* primary key */
    5387             :         bool        isIDKey;    /* replica identity index */
    5388             :         Bitmapset **attrs;
    5389             : 
    5390       25976 :         indexDesc = index_open(indexOid, AccessShareLock);
    5391             : 
    5392             :         /*
    5393             :          * Extract index expressions and index predicate.  Note: Don't use
    5394             :          * RelationGetIndexExpressions()/RelationGetIndexPredicate(), because
    5395             :          * those might run constant expressions evaluation, which needs a
    5396             :          * snapshot, which we might not have here.  (Also, it's probably more
    5397             :          * sound to collect the bitmaps before any transformations that might
    5398             :          * eliminate columns, but the practical impact of this is limited.)
    5399             :          */
    5400             : 
    5401       25976 :         datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indexprs,
    5402             :                              GetPgIndexDescriptor(), &isnull);
    5403       25976 :         if (!isnull)
    5404          38 :             indexExpressions = stringToNode(TextDatumGetCString(datum));
    5405             :         else
    5406       25938 :             indexExpressions = NULL;
    5407             : 
    5408       25976 :         datum = heap_getattr(indexDesc->rd_indextuple, Anum_pg_index_indpred,
    5409             :                              GetPgIndexDescriptor(), &isnull);
    5410       25976 :         if (!isnull)
    5411         102 :             indexPredicate = stringToNode(TextDatumGetCString(datum));
    5412             :         else
    5413       25874 :             indexPredicate = NULL;
    5414             : 
    5415             :         /* Can this index be referenced by a foreign key? */
    5416       20564 :         isKey = indexDesc->rd_index->indisunique &&
    5417       46540 :             indexExpressions == NULL &&
    5418             :             indexPredicate == NULL;
    5419             : 
    5420             :         /* Is this a primary key? */
    5421       25976 :         isPK = (indexOid == relpkindex);
    5422             : 
    5423             :         /* Is this index the configured (or default) replica identity? */
    5424       25976 :         isIDKey = (indexOid == relreplindex);
    5425             : 
    5426             :         /*
    5427             :          * If the index is summarizing, it doesn't block HOT updates, but we
    5428             :          * may still need to update it (if the attributes were modified). So
    5429             :          * decide which bitmap we'll update in the following loop.
    5430             :          */
    5431       25976 :         if (indexDesc->rd_indam->amsummarizing)
    5432          78 :             attrs = &summarizedattrs;
    5433             :         else
    5434       25898 :             attrs = &hotblockingattrs;
    5435             : 
    5436             :         /* Collect simple attribute references */
    5437       66738 :         for (i = 0; i < indexDesc->rd_index->indnatts; i++)
    5438             :         {
    5439       40762 :             int         attrnum = indexDesc->rd_index->indkey.values[i];
    5440             : 
    5441             :             /*
    5442             :              * Since we have covering indexes with non-key columns, we must
    5443             :              * handle them accurately here. non-key columns must be added into
    5444             :              * hotblockingattrs or summarizedattrs, since they are in index,
    5445             :              * and update shouldn't miss them.
    5446             :              *
    5447             :              * Summarizing indexes do not block HOT, but do need to be updated
    5448             :              * when the column value changes, thus require a separate
    5449             :              * attribute bitmapset.
    5450             :              *
    5451             :              * Obviously, non-key columns couldn't be referenced by foreign
    5452             :              * key or identity key. Hence we do not include them into
    5453             :              * uindexattrs, pkindexattrs and idindexattrs bitmaps.
    5454             :              */
    5455       40762 :             if (attrnum != 0)
    5456             :             {
    5457       40724 :                 *attrs = bms_add_member(*attrs,
    5458             :                                         attrnum - FirstLowInvalidHeapAttributeNumber);
    5459             : 
    5460       40724 :                 if (isKey && i < indexDesc->rd_index->indnkeyatts)
    5461       30678 :                     uindexattrs = bms_add_member(uindexattrs,
    5462             :                                                  attrnum - FirstLowInvalidHeapAttributeNumber);
    5463             : 
    5464       40724 :                 if (isPK && i < indexDesc->rd_index->indnkeyatts)
    5465       15548 :                     pkindexattrs = bms_add_member(pkindexattrs,
    5466             :                                                   attrnum - FirstLowInvalidHeapAttributeNumber);
    5467             : 
    5468       40724 :                 if (isIDKey && i < indexDesc->rd_index->indnkeyatts)
    5469        4248 :                     idindexattrs = bms_add_member(idindexattrs,
    5470             :                                                   attrnum - FirstLowInvalidHeapAttributeNumber);
    5471             :             }
    5472             :         }
    5473             : 
    5474             :         /* Collect all attributes used in expressions, too */
    5475       25976 :         pull_varattnos(indexExpressions, 1, attrs);
    5476             : 
    5477             :         /* Collect all attributes in the index predicate, too */
    5478       25976 :         pull_varattnos(indexPredicate, 1, attrs);
    5479             : 
    5480       25976 :         index_close(indexDesc, AccessShareLock);
    5481             :     }
    5482             : 
    5483             :     /*
    5484             :      * During one of the index_opens in the above loop, we might have received
    5485             :      * a relcache flush event on this relcache entry, which might have been
    5486             :      * signaling a change in the rel's index list.  If so, we'd better start
    5487             :      * over to ensure we deliver up-to-date attribute bitmaps.
    5488             :      */
    5489       14218 :     newindexoidlist = RelationGetIndexList(relation);
    5490       14218 :     if (equal(indexoidlist, newindexoidlist) &&
    5491       14218 :         relpkindex == relation->rd_pkindex &&
    5492       14218 :         relreplindex == relation->rd_replidindex)
    5493             :     {
    5494             :         /* Still the same index set, so proceed */
    5495       14218 :         list_free(newindexoidlist);
    5496       14218 :         list_free(indexoidlist);
    5497             :     }
    5498             :     else
    5499             :     {
    5500             :         /* Gotta do it over ... might as well not leak memory */
    5501           0 :         list_free(newindexoidlist);
    5502           0 :         list_free(indexoidlist);
    5503           0 :         bms_free(uindexattrs);
    5504           0 :         bms_free(pkindexattrs);
    5505           0 :         bms_free(idindexattrs);
    5506           0 :         bms_free(hotblockingattrs);
    5507           0 :         bms_free(summarizedattrs);
    5508             : 
    5509           0 :         goto restart;
    5510             :     }
    5511             : 
    5512             :     /* Don't leak the old values of these bitmaps, if any */
    5513       14218 :     relation->rd_attrsvalid = false;
    5514       14218 :     bms_free(relation->rd_keyattr);
    5515       14218 :     relation->rd_keyattr = NULL;
    5516       14218 :     bms_free(relation->rd_pkattr);
    5517       14218 :     relation->rd_pkattr = NULL;
    5518       14218 :     bms_free(relation->rd_idattr);
    5519       14218 :     relation->rd_idattr = NULL;
    5520       14218 :     bms_free(relation->rd_hotblockingattr);
    5521       14218 :     relation->rd_hotblockingattr = NULL;
    5522       14218 :     bms_free(relation->rd_summarizedattr);
    5523       14218 :     relation->rd_summarizedattr = NULL;
    5524             : 
    5525             :     /*
    5526             :      * Now save copies of the bitmaps in the relcache entry.  We intentionally
    5527             :      * set rd_attrsvalid last, because that's the one that signals validity of
    5528             :      * the values; if we run out of memory before making that copy, we won't
    5529             :      * leave the relcache entry looking like the other ones are valid but
    5530             :      * empty.
    5531             :      */
    5532       14218 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    5533       14218 :     relation->rd_keyattr = bms_copy(uindexattrs);
    5534       14218 :     relation->rd_pkattr = bms_copy(pkindexattrs);
    5535       14218 :     relation->rd_idattr = bms_copy(idindexattrs);
    5536       14218 :     relation->rd_hotblockingattr = bms_copy(hotblockingattrs);
    5537       14218 :     relation->rd_summarizedattr = bms_copy(summarizedattrs);
    5538       14218 :     relation->rd_attrsvalid = true;
    5539       14218 :     MemoryContextSwitchTo(oldcxt);
    5540             : 
    5541             :     /* We return our original working copy for caller to play with */
    5542       14218 :     switch (attrKind)
    5543             :     {
    5544         958 :         case INDEX_ATTR_BITMAP_KEY:
    5545         958 :             return uindexattrs;
    5546          54 :         case INDEX_ATTR_BITMAP_PRIMARY_KEY:
    5547          54 :             return pkindexattrs;
    5548        1258 :         case INDEX_ATTR_BITMAP_IDENTITY_KEY:
    5549        1258 :             return idindexattrs;
    5550       11948 :         case INDEX_ATTR_BITMAP_HOT_BLOCKING:
    5551       11948 :             return hotblockingattrs;
    5552           0 :         case INDEX_ATTR_BITMAP_SUMMARIZED:
    5553           0 :             return summarizedattrs;
    5554           0 :         default:
    5555           0 :             elog(ERROR, "unknown attrKind %u", attrKind);
    5556             :             return NULL;
    5557             :     }
    5558             : }
    5559             : 
    5560             : /*
    5561             :  * RelationGetIdentityKeyBitmap -- get a bitmap of replica identity attribute
    5562             :  * numbers
    5563             :  *
    5564             :  * A bitmap of index attribute numbers for the configured replica identity
    5565             :  * index is returned.
    5566             :  *
    5567             :  * See also comments of RelationGetIndexAttrBitmap().
    5568             :  *
    5569             :  * This is a special purpose function used during logical replication. Here,
    5570             :  * unlike RelationGetIndexAttrBitmap(), we don't acquire a lock on the required
    5571             :  * index as we build the cache entry using a historic snapshot and all the
    5572             :  * later changes are absorbed while decoding WAL. Due to this reason, we don't
    5573             :  * need to retry here in case of a change in the set of indexes.
    5574             :  */
    5575             : Bitmapset *
    5576         598 : RelationGetIdentityKeyBitmap(Relation relation)
    5577             : {
    5578         598 :     Bitmapset  *idindexattrs = NULL;    /* columns in the replica identity */
    5579             :     Relation    indexDesc;
    5580             :     int         i;
    5581             :     Oid         replidindex;
    5582             :     MemoryContext oldcxt;
    5583             : 
    5584             :     /* Quick exit if we already computed the result */
    5585         598 :     if (relation->rd_idattr != NULL)
    5586          94 :         return bms_copy(relation->rd_idattr);
    5587             : 
    5588             :     /* Fast path if definitely no indexes */
    5589         504 :     if (!RelationGetForm(relation)->relhasindex)
    5590         124 :         return NULL;
    5591             : 
    5592             :     /* Historic snapshot must be set. */
    5593             :     Assert(HistoricSnapshotActive());
    5594             : 
    5595         380 :     replidindex = RelationGetReplicaIndex(relation);
    5596             : 
    5597             :     /* Fall out if there is no replica identity index */
    5598         380 :     if (!OidIsValid(replidindex))
    5599          10 :         return NULL;
    5600             : 
    5601             :     /* Look up the description for the replica identity index */
    5602         370 :     indexDesc = RelationIdGetRelation(replidindex);
    5603             : 
    5604         370 :     if (!RelationIsValid(indexDesc))
    5605           0 :         elog(ERROR, "could not open relation with OID %u",
    5606             :              relation->rd_replidindex);
    5607             : 
    5608             :     /* Add referenced attributes to idindexattrs */
    5609         754 :     for (i = 0; i < indexDesc->rd_index->indnatts; i++)
    5610             :     {
    5611         384 :         int         attrnum = indexDesc->rd_index->indkey.values[i];
    5612             : 
    5613             :         /*
    5614             :          * We don't include non-key columns into idindexattrs bitmaps. See
    5615             :          * RelationGetIndexAttrBitmap.
    5616             :          */
    5617         384 :         if (attrnum != 0)
    5618             :         {
    5619         384 :             if (i < indexDesc->rd_index->indnkeyatts)
    5620         382 :                 idindexattrs = bms_add_member(idindexattrs,
    5621             :                                               attrnum - FirstLowInvalidHeapAttributeNumber);
    5622             :         }
    5623             :     }
    5624             : 
    5625         370 :     RelationClose(indexDesc);
    5626             : 
    5627             :     /* Don't leak the old values of these bitmaps, if any */
    5628         370 :     bms_free(relation->rd_idattr);
    5629         370 :     relation->rd_idattr = NULL;
    5630             : 
    5631             :     /* Now save copy of the bitmap in the relcache entry */
    5632         370 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    5633         370 :     relation->rd_idattr = bms_copy(idindexattrs);
    5634         370 :     MemoryContextSwitchTo(oldcxt);
    5635             : 
    5636             :     /* We return our original working copy for caller to play with */
    5637         370 :     return idindexattrs;
    5638             : }
    5639             : 
    5640             : /*
    5641             :  * RelationGetExclusionInfo -- get info about index's exclusion constraint
    5642             :  *
    5643             :  * This should be called only for an index that is known to have an associated
    5644             :  * exclusion constraint or primary key/unique constraint using WITHOUT
    5645             :  * OVERLAPS.
    5646             : 
    5647             :  * It returns arrays (palloc'd in caller's context) of the exclusion operator
    5648             :  * OIDs, their underlying functions' OIDs, and their strategy numbers in the
    5649             :  * index's opclasses.  We cache all this information since it requires a fair
    5650             :  * amount of work to get.
    5651             :  */
    5652             : void
    5653        2184 : RelationGetExclusionInfo(Relation indexRelation,
    5654             :                          Oid **operators,
    5655             :                          Oid **procs,
    5656             :                          uint16 **strategies)
    5657             : {
    5658             :     int         indnkeyatts;
    5659             :     Oid        *ops;
    5660             :     Oid        *funcs;
    5661             :     uint16     *strats;
    5662             :     Relation    conrel;
    5663             :     SysScanDesc conscan;
    5664             :     ScanKeyData skey[1];
    5665             :     HeapTuple   htup;
    5666             :     bool        found;
    5667             :     MemoryContext oldcxt;
    5668             :     int         i;
    5669             : 
    5670        2184 :     indnkeyatts = IndexRelationGetNumberOfKeyAttributes(indexRelation);
    5671             : 
    5672             :     /* Allocate result space in caller context */
    5673        2184 :     *operators = ops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
    5674        2184 :     *procs = funcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
    5675        2184 :     *strategies = strats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
    5676             : 
    5677             :     /* Quick exit if we have the data cached already */
    5678        2184 :     if (indexRelation->rd_exclstrats != NULL)
    5679             :     {
    5680        1552 :         memcpy(ops, indexRelation->rd_exclops, sizeof(Oid) * indnkeyatts);
    5681        1552 :         memcpy(funcs, indexRelation->rd_exclprocs, sizeof(Oid) * indnkeyatts);
    5682        1552 :         memcpy(strats, indexRelation->rd_exclstrats, sizeof(uint16) * indnkeyatts);
    5683        1552 :         return;
    5684             :     }
    5685             : 
    5686             :     /*
    5687             :      * Search pg_constraint for the constraint associated with the index. To
    5688             :      * make this not too painfully slow, we use the index on conrelid; that
    5689             :      * will hold the parent relation's OID not the index's own OID.
    5690             :      *
    5691             :      * Note: if we wanted to rely on the constraint name matching the index's
    5692             :      * name, we could just do a direct lookup using pg_constraint's unique
    5693             :      * index.  For the moment it doesn't seem worth requiring that.
    5694             :      */
    5695         632 :     ScanKeyInit(&skey[0],
    5696             :                 Anum_pg_constraint_conrelid,
    5697             :                 BTEqualStrategyNumber, F_OIDEQ,
    5698         632 :                 ObjectIdGetDatum(indexRelation->rd_index->indrelid));
    5699             : 
    5700         632 :     conrel = table_open(ConstraintRelationId, AccessShareLock);
    5701         632 :     conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
    5702             :                                  NULL, 1, skey);
    5703         632 :     found = false;
    5704             : 
    5705        2504 :     while (HeapTupleIsValid(htup = systable_getnext(conscan)))
    5706             :     {
    5707        1872 :         Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(htup);
    5708             :         Datum       val;
    5709             :         bool        isnull;
    5710             :         ArrayType  *arr;
    5711             :         int         nelem;
    5712             : 
    5713             :         /* We want the exclusion constraint owning the index */
    5714        1872 :         if ((conform->contype != CONSTRAINT_EXCLUSION &&
    5715        1642 :              !(conform->conperiod && (conform->contype == CONSTRAINT_PRIMARY
    5716         230 :                                       || conform->contype == CONSTRAINT_UNIQUE))) ||
    5717         764 :             conform->conindid != RelationGetRelid(indexRelation))
    5718        1240 :             continue;
    5719             : 
    5720             :         /* There should be only one */
    5721         632 :         if (found)
    5722           0 :             elog(ERROR, "unexpected exclusion constraint record found for rel %s",
    5723             :                  RelationGetRelationName(indexRelation));
    5724         632 :         found = true;
    5725             : 
    5726             :         /* Extract the operator OIDS from conexclop */
    5727         632 :         val = fastgetattr(htup,
    5728             :                           Anum_pg_constraint_conexclop,
    5729             :                           conrel->rd_att, &isnull);
    5730         632 :         if (isnull)
    5731           0 :             elog(ERROR, "null conexclop for rel %s",
    5732             :                  RelationGetRelationName(indexRelation));
    5733             : 
    5734         632 :         arr = DatumGetArrayTypeP(val);  /* ensure not toasted */
    5735         632 :         nelem = ARR_DIMS(arr)[0];
    5736         632 :         if (ARR_NDIM(arr) != 1 ||
    5737         632 :             nelem != indnkeyatts ||
    5738         632 :             ARR_HASNULL(arr) ||
    5739         632 :             ARR_ELEMTYPE(arr) != OIDOID)
    5740           0 :             elog(ERROR, "conexclop is not a 1-D Oid array");
    5741             : 
    5742         632 :         memcpy(ops, ARR_DATA_PTR(arr), sizeof(Oid) * indnkeyatts);
    5743             :     }
    5744             : 
    5745         632 :     systable_endscan(conscan);
    5746         632 :     table_close(conrel, AccessShareLock);
    5747             : 
    5748         632 :     if (!found)
    5749           0 :         elog(ERROR, "exclusion constraint record missing for rel %s",
    5750             :              RelationGetRelationName(indexRelation));
    5751             : 
    5752             :     /* We need the func OIDs and strategy numbers too */
    5753        1810 :     for (i = 0; i < indnkeyatts; i++)
    5754             :     {
    5755        1178 :         funcs[i] = get_opcode(ops[i]);
    5756        2356 :         strats[i] = get_op_opfamily_strategy(ops[i],
    5757        1178 :                                              indexRelation->rd_opfamily[i]);
    5758             :         /* shouldn't fail, since it was checked at index creation */
    5759        1178 :         if (strats[i] == InvalidStrategy)
    5760           0 :             elog(ERROR, "could not find strategy for operator %u in family %u",
    5761             :                  ops[i], indexRelation->rd_opfamily[i]);
    5762             :     }
    5763             : 
    5764             :     /* Save a copy of the results in the relcache entry. */
    5765         632 :     oldcxt = MemoryContextSwitchTo(indexRelation->rd_indexcxt);
    5766         632 :     indexRelation->rd_exclops = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
    5767         632 :     indexRelation->rd_exclprocs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
    5768         632 :     indexRelation->rd_exclstrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
    5769         632 :     memcpy(indexRelation->rd_exclops, ops, sizeof(Oid) * indnkeyatts);
    5770         632 :     memcpy(indexRelation->rd_exclprocs, funcs, sizeof(Oid) * indnkeyatts);
    5771         632 :     memcpy(indexRelation->rd_exclstrats, strats, sizeof(uint16) * indnkeyatts);
    5772         632 :     MemoryContextSwitchTo(oldcxt);
    5773             : }
    5774             : 
    5775             : /*
    5776             :  * Get the publication information for the given relation.
    5777             :  *
    5778             :  * Traverse all the publications which the relation is in to get the
    5779             :  * publication actions and validate:
    5780             :  * 1. The row filter expressions for such publications if any. We consider the
    5781             :  *    row filter expression as invalid if it references any column which is not
    5782             :  *    part of REPLICA IDENTITY.
    5783             :  * 2. The column list for such publication if any. We consider the column list
    5784             :  *    invalid if REPLICA IDENTITY contains any column that is not part of it.
    5785             :  * 3. The generated columns of the relation for such publications. We consider
    5786             :  *    any reference of an unpublished generated column in REPLICA IDENTITY as
    5787             :  *    invalid.
    5788             :  *
    5789             :  * To avoid fetching the publication information repeatedly, we cache the
    5790             :  * publication actions, row filter validation information, column list
    5791             :  * validation information, and generated column validation information.
    5792             :  */
    5793             : void
    5794      172480 : RelationBuildPublicationDesc(Relation relation, PublicationDesc *pubdesc)
    5795             : {
    5796             :     List       *puboids;
    5797             :     ListCell   *lc;
    5798             :     MemoryContext oldcxt;
    5799             :     Oid         schemaid;
    5800      172480 :     List       *ancestors = NIL;
    5801      172480 :     Oid         relid = RelationGetRelid(relation);
    5802             : 
    5803             :     /*
    5804             :      * If not publishable, it publishes no actions.  (pgoutput_change() will
    5805             :      * ignore it.)
    5806             :      */
    5807      172480 :     if (!is_publishable_relation(relation))
    5808             :     {
    5809        5736 :         memset(pubdesc, 0, sizeof(PublicationDesc));
    5810        5736 :         pubdesc->rf_valid_for_update = true;
    5811        5736 :         pubdesc->rf_valid_for_delete = true;
    5812        5736 :         pubdesc->cols_valid_for_update = true;
    5813        5736 :         pubdesc->cols_valid_for_delete = true;
    5814        5736 :         pubdesc->gencols_valid_for_update = true;
    5815        5736 :         pubdesc->gencols_valid_for_delete = true;
    5816        5736 :         return;
    5817             :     }
    5818             : 
    5819      166744 :     if (relation->rd_pubdesc)
    5820             :     {
    5821      158674 :         memcpy(pubdesc, relation->rd_pubdesc, sizeof(PublicationDesc));
    5822      158674 :         return;
    5823             :     }
    5824             : 
    5825        8070 :     memset(pubdesc, 0, sizeof(PublicationDesc));
    5826        8070 :     pubdesc->rf_valid_for_update = true;
    5827        8070 :     pubdesc->rf_valid_for_delete = true;
    5828        8070 :     pubdesc->cols_valid_for_update = true;
    5829        8070 :     pubdesc->cols_valid_for_delete = true;
    5830        8070 :     pubdesc->gencols_valid_for_update = true;
    5831        8070 :     pubdesc->gencols_valid_for_delete = true;
    5832             : 
    5833             :     /* Fetch the publication membership info. */
    5834        8070 :     puboids = GetRelationPublications(relid);
    5835        8070 :     schemaid = RelationGetNamespace(relation);
    5836        8070 :     puboids = list_concat_unique_oid(puboids, GetSchemaPublications(schemaid));
    5837             : 
    5838        8070 :     if (relation->rd_rel->relispartition)
    5839             :     {
    5840             :         /* Add publications that the ancestors are in too. */
    5841        1900 :         ancestors = get_partition_ancestors(relid);
    5842             : 
    5843        4432 :         foreach(lc, ancestors)
    5844             :         {
    5845        2532 :             Oid         ancestor = lfirst_oid(lc);
    5846             : 
    5847        2532 :             puboids = list_concat_unique_oid(puboids,
    5848        2532 :                                              GetRelationPublications(ancestor));
    5849        2532 :             schemaid = get_rel_namespace(ancestor);
    5850        2532 :             puboids = list_concat_unique_oid(puboids,
    5851        2532 :                                              GetSchemaPublications(schemaid));
    5852             :         }
    5853             :     }
    5854        8070 :     puboids = list_concat_unique_oid(puboids, GetAllTablesPublications());
    5855             : 
    5856        8786 :     foreach(lc, puboids)
    5857             :     {
    5858         908 :         Oid         pubid = lfirst_oid(lc);
    5859             :         HeapTuple   tup;
    5860             :         Form_pg_publication pubform;
    5861             :         bool        invalid_column_list;
    5862             :         bool        invalid_gen_col;
    5863             : 
    5864         908 :         tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
    5865             : 
    5866         908 :         if (!HeapTupleIsValid(tup))
    5867           0 :             elog(ERROR, "cache lookup failed for publication %u", pubid);
    5868             : 
    5869         908 :         pubform = (Form_pg_publication) GETSTRUCT(tup);
    5870             : 
    5871         908 :         pubdesc->pubactions.pubinsert |= pubform->pubinsert;
    5872         908 :         pubdesc->pubactions.pubupdate |= pubform->pubupdate;
    5873         908 :         pubdesc->pubactions.pubdelete |= pubform->pubdelete;
    5874         908 :         pubdesc->pubactions.pubtruncate |= pubform->pubtruncate;
    5875             : 
    5876             :         /*
    5877             :          * Check if all columns referenced in the filter expression are part
    5878             :          * of the REPLICA IDENTITY index or not.
    5879             :          *
    5880             :          * If the publication is FOR ALL TABLES then it means the table has no
    5881             :          * row filters and we can skip the validation.
    5882             :          */
    5883         908 :         if (!pubform->puballtables &&
    5884        1428 :             (pubform->pubupdate || pubform->pubdelete) &&
    5885         712 :             pub_rf_contains_invalid_column(pubid, relation, ancestors,
    5886         712 :                                            pubform->pubviaroot))
    5887             :         {
    5888          60 :             if (pubform->pubupdate)
    5889          60 :                 pubdesc->rf_valid_for_update = false;
    5890          60 :             if (pubform->pubdelete)
    5891          60 :                 pubdesc->rf_valid_for_delete = false;
    5892             :         }
    5893             : 
    5894             :         /*
    5895             :          * Check if all columns are part of the REPLICA IDENTITY index or not.
    5896             :          *
    5897             :          * Check if all generated columns included in the REPLICA IDENTITY are
    5898             :          * published.
    5899             :          */
    5900        1812 :         if ((pubform->pubupdate || pubform->pubdelete) &&
    5901         904 :             pub_contains_invalid_column(pubid, relation, ancestors,
    5902         904 :                                         pubform->pubviaroot,
    5903         904 :                                         pubform->pubgencols,
    5904             :                                         &invalid_column_list,
    5905             :                                         &invalid_gen_col))
    5906             :         {
    5907         132 :             if (pubform->pubupdate)
    5908             :             {
    5909         132 :                 pubdesc->cols_valid_for_update = !invalid_column_list;
    5910         132 :                 pubdesc->gencols_valid_for_update = !invalid_gen_col;
    5911             :             }
    5912             : 
    5913         132 :             if (pubform->pubdelete)
    5914             :             {
    5915         132 :                 pubdesc->cols_valid_for_delete = !invalid_column_list;
    5916         132 :                 pubdesc->gencols_valid_for_delete = !invalid_gen_col;
    5917             :             }
    5918             :         }
    5919             : 
    5920         908 :         ReleaseSysCache(tup);
    5921             : 
    5922             :         /*
    5923             :          * If we know everything is replicated and the row filter is invalid
    5924             :          * for update and delete, there is no point to check for other
    5925             :          * publications.
    5926             :          */
    5927         908 :         if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
    5928         902 :             pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
    5929         890 :             !pubdesc->rf_valid_for_update && !pubdesc->rf_valid_for_delete)
    5930         192 :             break;
    5931             : 
    5932             :         /*
    5933             :          * If we know everything is replicated and the column list is invalid
    5934             :          * for update and delete, there is no point to check for other
    5935             :          * publications.
    5936             :          */
    5937         848 :         if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
    5938         842 :             pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
    5939         830 :             !pubdesc->cols_valid_for_update && !pubdesc->cols_valid_for_delete)
    5940         108 :             break;
    5941             : 
    5942             :         /*
    5943             :          * If we know everything is replicated and replica identity has an
    5944             :          * unpublished generated column, there is no point to check for other
    5945             :          * publications.
    5946             :          */
    5947         740 :         if (pubdesc->pubactions.pubinsert && pubdesc->pubactions.pubupdate &&
    5948         734 :             pubdesc->pubactions.pubdelete && pubdesc->pubactions.pubtruncate &&
    5949         722 :             !pubdesc->gencols_valid_for_update &&
    5950          24 :             !pubdesc->gencols_valid_for_delete)
    5951          24 :             break;
    5952             :     }
    5953             : 
    5954        8070 :     if (relation->rd_pubdesc)
    5955             :     {
    5956           0 :         pfree(relation->rd_pubdesc);
    5957           0 :         relation->rd_pubdesc = NULL;
    5958             :     }
    5959             : 
    5960             :     /* Now save copy of the descriptor in the relcache entry. */
    5961        8070 :     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    5962        8070 :     relation->rd_pubdesc = palloc(sizeof(PublicationDesc));
    5963        8070 :     memcpy(relation->rd_pubdesc, pubdesc, sizeof(PublicationDesc));
    5964        8070 :     MemoryContextSwitchTo(oldcxt);
    5965             : }
    5966             : 
    5967             : static bytea **
    5968     1384170 : CopyIndexAttOptions(bytea **srcopts, int natts)
    5969             : {
    5970     1384170 :     bytea     **opts = palloc(sizeof(*opts) * natts);
    5971             : 
    5972     3883096 :     for (int i = 0; i < natts; i++)
    5973             :     {
    5974     2498926 :         bytea      *opt = srcopts[i];
    5975             : 
    5976     2591024 :         opts[i] = !opt ? NULL : (bytea *)
    5977       92098 :             DatumGetPointer(datumCopy(PointerGetDatum(opt), false, -1));
    5978             :     }
    5979             : 
    5980     1384170 :     return opts;
    5981             : }
    5982             : 
    5983             : /*
    5984             :  * RelationGetIndexAttOptions
    5985             :  *      get AM/opclass-specific options for an index parsed into a binary form
    5986             :  */
    5987             : bytea     **
    5988     2664422 : RelationGetIndexAttOptions(Relation relation, bool copy)
    5989             : {
    5990             :     MemoryContext oldcxt;
    5991     2664422 :     bytea     **opts = relation->rd_opcoptions;
    5992     2664422 :     Oid         relid = RelationGetRelid(relation);
    5993     2664422 :     int         natts = RelationGetNumberOfAttributes(relation);    /* XXX
    5994             :                                                                      * IndexRelationGetNumberOfKeyAttributes */
    5995             :     int         i;
    5996             : 
    5997             :     /* Try to copy cached options. */
    5998     2664422 :     if (opts)
    5999     2028524 :         return copy ? CopyIndexAttOptions(opts, natts) : opts;
    6000             : 
    6001             :     /* Get and parse opclass options. */
    6002      635898 :     opts = palloc0(sizeof(*opts) * natts);
    6003             : 
    6004     1721046 :     for (i = 0; i < natts; i++)
    6005             :     {
    6006     1085154 :         if (criticalRelcachesBuilt && relid != AttributeRelidNumIndexId)
    6007             :         {
    6008     1018680 :             Datum       attoptions = get_attoptions(relid, i + 1);
    6009             : 
    6010     1018680 :             opts[i] = index_opclass_options(relation, i + 1, attoptions, false);
    6011             : 
    6012     1018674 :             if (attoptions != (Datum) 0)
    6013         292 :                 pfree(DatumGetPointer(attoptions));
    6014             :         }
    6015             :     }
    6016             : 
    6017             :     /* Copy parsed options to the cache. */
    6018      635892 :     oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt);
    6019      635892 :     relation->rd_opcoptions = CopyIndexAttOptions(opts, natts);
    6020      635892 :     MemoryContextSwitchTo(oldcxt);
    6021             : 
    6022      635892 :     if (copy)
    6023           0 :         return opts;
    6024             : 
    6025     1721040 :     for (i = 0; i < natts; i++)
    6026             :     {
    6027     1085148 :         if (opts[i])
    6028        2102 :             pfree(opts[i]);
    6029             :     }
    6030             : 
    6031      635892 :     pfree(opts);
    6032             : 
    6033      635892 :     return relation->rd_opcoptions;
    6034             : }
    6035             : 
    6036             : /*
    6037             :  * Routines to support ereport() reports of relation-related errors
    6038             :  *
    6039             :  * These could have been put into elog.c, but it seems like a module layering
    6040             :  * violation to have elog.c calling relcache or syscache stuff --- and we
    6041             :  * definitely don't want elog.h including rel.h.  So we put them here.
    6042             :  */
    6043             : 
    6044             : /*
    6045             :  * errtable --- stores schema_name and table_name of a table
    6046             :  * within the current errordata.
    6047             :  */
    6048             : int
    6049        3546 : errtable(Relation rel)
    6050             : {
    6051        3546 :     err_generic_string(PG_DIAG_SCHEMA_NAME,
    6052        3546 :                        get_namespace_name(RelationGetNamespace(rel)));
    6053        3546 :     err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
    6054             : 
    6055        3546 :     return 0;                   /* return value does not matter */
    6056             : }
    6057             : 
    6058             : /*
    6059             :  * errtablecol --- stores schema_name, table_name and column_name
    6060             :  * of a table column within the current errordata.
    6061             :  *
    6062             :  * The column is specified by attribute number --- for most callers, this is
    6063             :  * easier and less error-prone than getting the column name for themselves.
    6064             :  */
    6065             : int
    6066         548 : errtablecol(Relation rel, int attnum)
    6067             : {
    6068         548 :     TupleDesc   reldesc = RelationGetDescr(rel);
    6069             :     const char *colname;
    6070             : 
    6071             :     /* Use reldesc if it's a user attribute, else consult the catalogs */
    6072         548 :     if (attnum > 0 && attnum <= reldesc->natts)
    6073         548 :         colname = NameStr(TupleDescAttr(reldesc, attnum - 1)->attname);
    6074             :     else
    6075           0 :         colname = get_attname(RelationGetRelid(rel), attnum, false);
    6076             : 
    6077         548 :     return errtablecolname(rel, colname);
    6078             : }
    6079             : 
    6080             : /*
    6081             :  * errtablecolname --- stores schema_name, table_name and column_name
    6082             :  * of a table column within the current errordata, where the column name is
    6083             :  * given directly rather than extracted from the relation's catalog data.
    6084             :  *
    6085             :  * Don't use this directly unless errtablecol() is inconvenient for some
    6086             :  * reason.  This might possibly be needed during intermediate states in ALTER
    6087             :  * TABLE, for instance.
    6088             :  */
    6089             : int
    6090         548 : errtablecolname(Relation rel, const char *colname)
    6091             : {
    6092         548 :     errtable(rel);
    6093         548 :     err_generic_string(PG_DIAG_COLUMN_NAME, colname);
    6094             : 
    6095         548 :     return 0;                   /* return value does not matter */
    6096             : }
    6097             : 
    6098             : /*
    6099             :  * errtableconstraint --- stores schema_name, table_name and constraint_name
    6100             :  * of a table-related constraint within the current errordata.
    6101             :  */
    6102             : int
    6103        2490 : errtableconstraint(Relation rel, const char *conname)
    6104             : {
    6105        2490 :     errtable(rel);
    6106        2490 :     err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);
    6107             : 
    6108        2490 :     return 0;                   /* return value does not matter */
    6109             : }
    6110             : 
    6111             : 
    6112             : /*
    6113             :  *  load_relcache_init_file, write_relcache_init_file
    6114             :  *
    6115             :  *      In late 1992, we started regularly having databases with more than
    6116             :  *      a thousand classes in them.  With this number of classes, it became
    6117             :  *      critical to do indexed lookups on the system catalogs.
    6118             :  *
    6119             :  *      Bootstrapping these lookups is very hard.  We want to be able to
    6120             :  *      use an index on pg_attribute, for example, but in order to do so,
    6121             :  *      we must have read pg_attribute for the attributes in the index,
    6122             :  *      which implies that we need to use the index.
    6123             :  *
    6124             :  *      In order to get around the problem, we do the following:
    6125             :  *
    6126             :  *         +  When the database system is initialized (at initdb time), we
    6127             :  *            don't use indexes.  We do sequential scans.
    6128             :  *
    6129             :  *         +  When the backend is started up in normal mode, we load an image
    6130             :  *            of the appropriate relation descriptors, in internal format,
    6131             :  *            from an initialization file in the data/base/... directory.
    6132             :  *
    6133             :  *         +  If the initialization file isn't there, then we create the
    6134             :  *            relation descriptors using sequential scans and write 'em to
    6135             :  *            the initialization file for use by subsequent backends.
    6136             :  *
    6137             :  *      As of Postgres 9.0, there is one local initialization file in each
    6138             :  *      database, plus one shared initialization file for shared catalogs.
    6139             :  *
    6140             :  *      We could dispense with the initialization files and just build the
    6141             :  *      critical reldescs the hard way on every backend startup, but that
    6142             :  *      slows down backend startup noticeably.
    6143             :  *
    6144             :  *      We can in fact go further, and save more relcache entries than
    6145             :  *      just the ones that are absolutely critical; this allows us to speed
    6146             :  *      up backend startup by not having to build such entries the hard way.
    6147             :  *      Presently, all the catalog and index entries that are referred to
    6148             :  *      by catcaches are stored in the initialization files.
    6149             :  *
    6150             :  *      The same mechanism that detects when catcache and relcache entries
    6151             :  *      need to be invalidated (due to catalog updates) also arranges to
    6152             :  *      unlink the initialization files when the contents may be out of date.
    6153             :  *      The files will then be rebuilt during the next backend startup.
    6154             :  */
    6155             : 
    6156             : /*
    6157             :  * load_relcache_init_file -- attempt to load cache from the shared
    6158             :  * or local cache init file
    6159             :  *
    6160             :  * If successful, return true and set criticalRelcachesBuilt or
    6161             :  * criticalSharedRelcachesBuilt to true.
    6162             :  * If not successful, return false.
    6163             :  *
    6164             :  * NOTE: we assume we are already switched into CacheMemoryContext.
    6165             :  */
    6166             : static bool
    6167       67890 : load_relcache_init_file(bool shared)
    6168             : {
    6169             :     FILE       *fp;
    6170             :     char        initfilename[MAXPGPATH];
    6171             :     Relation   *rels;
    6172             :     int         relno,
    6173             :                 num_rels,
    6174             :                 max_rels,
    6175             :                 nailed_rels,
    6176             :                 nailed_indexes,
    6177             :                 magic;
    6178             :     int         i;
    6179             : 
    6180       67890 :     if (shared)
    6181       35258 :         snprintf(initfilename, sizeof(initfilename), "global/%s",
    6182             :                  RELCACHE_INIT_FILENAME);
    6183             :     else
    6184       32632 :         snprintf(initfilename, sizeof(initfilename), "%s/%s",
    6185             :                  DatabasePath, RELCACHE_INIT_FILENAME);
    6186             : 
    6187       67890 :     fp = AllocateFile(initfilename, PG_BINARY_R);
    6188       67890 :     if (fp == NULL)
    6189        7266 :         return false;
    6190             : 
    6191             :     /*
    6192             :      * Read the index relcache entries from the file.  Note we will not enter
    6193             :      * any of them into the cache if the read fails partway through; this
    6194             :      * helps to guard against broken init files.
    6195             :      */
    6196       60624 :     max_rels = 100;
    6197       60624 :     rels = (Relation *) palloc(max_rels * sizeof(Relation));
    6198       60624 :     num_rels = 0;
    6199       60624 :     nailed_rels = nailed_indexes = 0;
    6200             : 
    6201             :     /* check for correct magic number (compatible version) */
    6202       60624 :     if (fread(&magic, 1, sizeof(magic), fp) != sizeof(magic))
    6203           0 :         goto read_failed;
    6204       60624 :     if (magic != RELCACHE_INIT_FILEMAGIC)
    6205           0 :         goto read_failed;
    6206             : 
    6207       60624 :     for (relno = 0;; relno++)
    6208     4085598 :     {
    6209             :         Size        len;
    6210             :         size_t      nread;
    6211             :         Relation    rel;
    6212             :         Form_pg_class relform;
    6213             :         bool        has_not_null;
    6214             : 
    6215             :         /* first read the relation descriptor length */
    6216     4146222 :         nread = fread(&len, 1, sizeof(len), fp);
    6217     4146222 :         if (nread != sizeof(len))
    6218             :         {
    6219       60624 :             if (nread == 0)
    6220       60624 :                 break;          /* end of file */
    6221           0 :             goto read_failed;
    6222             :         }
    6223             : 
    6224             :         /* safety check for incompatible relcache layout */
    6225     4085598 :         if (len != sizeof(RelationData))
    6226           0 :             goto read_failed;
    6227             : 
    6228             :         /* allocate another relcache header */
    6229     4085598 :         if (num_rels >= max_rels)
    6230             :         {
    6231       29590 :             max_rels *= 2;
    6232       29590 :             rels = (Relation *) repalloc(rels, max_rels * sizeof(Relation));
    6233             :         }
    6234             : 
    6235     4085598 :         rel = rels[num_rels++] = (Relation) palloc(len);
    6236             : 
    6237             :         /* then, read the Relation structure */
    6238     4085598 :         if (fread(rel, 1, len, fp) != len)
    6239           0 :             goto read_failed;
    6240             : 
    6241             :         /* next read the relation tuple form */
    6242     4085598 :         if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6243           0 :             goto read_failed;
    6244             : 
    6245     4085598 :         relform = (Form_pg_class) palloc(len);
    6246     4085598 :         if (fread(relform, 1, len, fp) != len)
    6247           0 :             goto read_failed;
    6248             : 
    6249     4085598 :         rel->rd_rel = relform;
    6250             : 
    6251             :         /* initialize attribute tuple forms */
    6252     4085598 :         rel->rd_att = CreateTemplateTupleDesc(relform->relnatts);
    6253     4085598 :         rel->rd_att->tdrefcount = 1;  /* mark as refcounted */
    6254             : 
    6255     4085598 :         rel->rd_att->tdtypeid = relform->reltype ? relform->reltype : RECORDOID;
    6256     4085598 :         rel->rd_att->tdtypmod = -1; /* just to be sure */
    6257             : 
    6258             :         /* next read all the attribute tuple form data entries */
    6259     4085598 :         has_not_null = false;
    6260    23952088 :         for (i = 0; i < relform->relnatts; i++)
    6261             :         {
    6262    19866490 :             Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i);
    6263             : 
    6264    19866490 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6265           0 :                 goto read_failed;
    6266    19866490 :             if (len != ATTRIBUTE_FIXED_PART_SIZE)
    6267           0 :                 goto read_failed;
    6268    19866490 :             if (fread(attr, 1, len, fp) != len)
    6269           0 :                 goto read_failed;
    6270             : 
    6271    19866490 :             has_not_null |= attr->attnotnull;
    6272             : 
    6273    19866490 :             populate_compact_attribute(rel->rd_att, i);
    6274             :         }
    6275             : 
    6276             :         /* next read the access method specific field */
    6277     4085598 :         if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6278           0 :             goto read_failed;
    6279     4085598 :         if (len > 0)
    6280             :         {
    6281           0 :             rel->rd_options = palloc(len);
    6282           0 :             if (fread(rel->rd_options, 1, len, fp) != len)
    6283           0 :                 goto read_failed;
    6284           0 :             if (len != VARSIZE(rel->rd_options))
    6285           0 :                 goto read_failed;   /* sanity check */
    6286             :         }
    6287             :         else
    6288             :         {
    6289     4085598 :             rel->rd_options = NULL;
    6290             :         }
    6291             : 
    6292             :         /* mark not-null status */
    6293     4085598 :         if (has_not_null)
    6294             :         {
    6295     1520642 :             TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
    6296             : 
    6297     1520642 :             constr->has_not_null = true;
    6298     1520642 :             rel->rd_att->constr = constr;
    6299             :         }
    6300             : 
    6301             :         /*
    6302             :          * If it's an index, there's more to do.  Note we explicitly ignore
    6303             :          * partitioned indexes here.
    6304             :          */
    6305     4085598 :         if (rel->rd_rel->relkind == RELKIND_INDEX)
    6306             :         {
    6307             :             MemoryContext indexcxt;
    6308             :             Oid        *opfamily;
    6309             :             Oid        *opcintype;
    6310             :             RegProcedure *support;
    6311             :             int         nsupport;
    6312             :             int16      *indoption;
    6313             :             Oid        *indcollation;
    6314             : 
    6315             :             /* Count nailed indexes to ensure we have 'em all */
    6316     2564956 :             if (rel->rd_isnailed)
    6317      393334 :                 nailed_indexes++;
    6318             : 
    6319             :             /* read the pg_index tuple */
    6320     2564956 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6321           0 :                 goto read_failed;
    6322             : 
    6323     2564956 :             rel->rd_indextuple = (HeapTuple) palloc(len);
    6324     2564956 :             if (fread(rel->rd_indextuple, 1, len, fp) != len)
    6325           0 :                 goto read_failed;
    6326             : 
    6327             :             /* Fix up internal pointers in the tuple -- see heap_copytuple */
    6328     2564956 :             rel->rd_indextuple->t_data = (HeapTupleHeader) ((char *) rel->rd_indextuple + HEAPTUPLESIZE);
    6329     2564956 :             rel->rd_index = (Form_pg_index) GETSTRUCT(rel->rd_indextuple);
    6330             : 
    6331             :             /*
    6332             :              * prepare index info context --- parameters should match
    6333             :              * RelationInitIndexAccessInfo
    6334             :              */
    6335     2564956 :             indexcxt = AllocSetContextCreate(CacheMemoryContext,
    6336             :                                              "index info",
    6337             :                                              ALLOCSET_SMALL_SIZES);
    6338     2564956 :             rel->rd_indexcxt = indexcxt;
    6339     2564956 :             MemoryContextCopyAndSetIdentifier(indexcxt,
    6340             :                                               RelationGetRelationName(rel));
    6341             : 
    6342             :             /*
    6343             :              * Now we can fetch the index AM's API struct.  (We can't store
    6344             :              * that in the init file, since it contains function pointers that
    6345             :              * might vary across server executions.  Fortunately, it should be
    6346             :              * safe to call the amhandler even while bootstrapping indexes.)
    6347             :              */
    6348     2564956 :             InitIndexAmRoutine(rel);
    6349             : 
    6350             :             /* read the vector of opfamily OIDs */
    6351     2564956 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6352           0 :                 goto read_failed;
    6353             : 
    6354     2564956 :             opfamily = (Oid *) MemoryContextAlloc(indexcxt, len);
    6355     2564956 :             if (fread(opfamily, 1, len, fp) != len)
    6356           0 :                 goto read_failed;
    6357             : 
    6358     2564956 :             rel->rd_opfamily = opfamily;
    6359             : 
    6360             :             /* read the vector of opcintype OIDs */
    6361     2564956 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6362           0 :                 goto read_failed;
    6363             : 
    6364     2564956 :             opcintype = (Oid *) MemoryContextAlloc(indexcxt, len);
    6365     2564956 :             if (fread(opcintype, 1, len, fp) != len)
    6366           0 :                 goto read_failed;
    6367             : 
    6368     2564956 :             rel->rd_opcintype = opcintype;
    6369             : 
    6370             :             /* read the vector of support procedure OIDs */
    6371     2564956 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6372           0 :                 goto read_failed;
    6373     2564956 :             support = (RegProcedure *) MemoryContextAlloc(indexcxt, len);
    6374     2564956 :             if (fread(support, 1, len, fp) != len)
    6375           0 :                 goto read_failed;
    6376             : 
    6377     2564956 :             rel->rd_support = support;
    6378             : 
    6379             :             /* read the vector of collation OIDs */
    6380     2564956 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6381           0 :                 goto read_failed;
    6382             : 
    6383     2564956 :             indcollation = (Oid *) MemoryContextAlloc(indexcxt, len);
    6384     2564956 :             if (fread(indcollation, 1, len, fp) != len)
    6385           0 :                 goto read_failed;
    6386             : 
    6387     2564956 :             rel->rd_indcollation = indcollation;
    6388             : 
    6389             :             /* read the vector of indoption values */
    6390     2564956 :             if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6391           0 :                 goto read_failed;
    6392             : 
    6393     2564956 :             indoption = (int16 *) MemoryContextAlloc(indexcxt, len);
    6394     2564956 :             if (fread(indoption, 1, len, fp) != len)
    6395           0 :                 goto read_failed;
    6396             : 
    6397     2564956 :             rel->rd_indoption = indoption;
    6398             : 
    6399             :             /* read the vector of opcoptions values */
    6400     2564956 :             rel->rd_opcoptions = (bytea **)
    6401     2564956 :                 MemoryContextAllocZero(indexcxt, sizeof(*rel->rd_opcoptions) * relform->relnatts);
    6402             : 
    6403     6767470 :             for (i = 0; i < relform->relnatts; i++)
    6404             :             {
    6405     4202514 :                 if (fread(&len, 1, sizeof(len), fp) != sizeof(len))
    6406           0 :                     goto read_failed;
    6407             : 
    6408     4202514 :                 if (len > 0)
    6409             :                 {
    6410           0 :                     rel->rd_opcoptions[i] = (bytea *) MemoryContextAlloc(indexcxt, len);
    6411           0 :                     if (fread(rel->rd_opcoptions[i], 1, len, fp) != len)
    6412           0 :                         goto read_failed;
    6413             :                 }
    6414             :             }
    6415             : 
    6416             :             /* set up zeroed fmgr-info vector */
    6417     2564956 :             nsupport = relform->relnatts * rel->rd_indam->amsupport;
    6418     2564956 :             rel->rd_supportinfo = (FmgrInfo *)
    6419     2564956 :                 MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo));
    6420             :         }
    6421             :         else
    6422             :         {
    6423             :             /* Count nailed rels to ensure we have 'em all */
    6424     1520642 :             if (rel->rd_isnailed)
    6425      273530 :                 nailed_rels++;
    6426             : 
    6427             :             /* Load table AM data */
    6428     1520642 :             if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind) || rel->rd_rel->relkind == RELKIND_SEQUENCE)
    6429     1520642 :                 RelationInitTableAccessMethod(rel);
    6430             : 
    6431             :             Assert(rel->rd_index == NULL);
    6432             :             Assert(rel->rd_indextuple == NULL);
    6433             :             Assert(rel->rd_indexcxt == NULL);
    6434             :             Assert(rel->rd_indam == NULL);
    6435             :             Assert(rel->rd_opfamily == NULL);
    6436             :             Assert(rel->rd_opcintype == NULL);
    6437             :             Assert(rel->rd_support == NULL);
    6438             :             Assert(rel->rd_supportinfo == NULL);
    6439             :             Assert(rel->rd_indoption == NULL);
    6440             :             Assert(rel->rd_indcollation == NULL);
    6441             :             Assert(rel->rd_opcoptions == NULL);
    6442             :         }
    6443             : 
    6444             :         /*
    6445             :          * Rules and triggers are not saved (mainly because the internal
    6446             :          * format is complex and subject to change).  They must be rebuilt if
    6447             :          * needed by RelationCacheInitializePhase3.  This is not expected to
    6448             :          * be a big performance hit since few system catalogs have such. Ditto
    6449             :          * for RLS policy data, partition info, index expressions, predicates,
    6450             :          * exclusion info, and FDW info.
    6451             :          */
    6452     4085598 :         rel->rd_rules = NULL;
    6453     4085598 :         rel->rd_rulescxt = NULL;
    6454     4085598 :         rel->trigdesc = NULL;
    6455     4085598 :         rel->rd_rsdesc = NULL;
    6456     4085598 :         rel->rd_partkey = NULL;
    6457     4085598 :         rel->rd_partkeycxt = NULL;
    6458     4085598 :         rel->rd_partdesc = NULL;
    6459     4085598 :         rel->rd_partdesc_nodetached = NULL;
    6460     4085598 :         rel->rd_partdesc_nodetached_xmin = InvalidTransactionId;
    6461     4085598 :         rel->rd_pdcxt = NULL;
    6462     4085598 :         rel->rd_pddcxt = NULL;
    6463     4085598 :         rel->rd_partcheck = NIL;
    6464     4085598 :         rel->rd_partcheckvalid = false;
    6465     4085598 :         rel->rd_partcheckcxt = NULL;
    6466     4085598 :         rel->rd_indexprs = NIL;
    6467     4085598 :         rel->rd_indpred = NIL;
    6468     4085598 :         rel->rd_exclops = NULL;
    6469     4085598 :         rel->rd_exclprocs = NULL;
    6470     4085598 :         rel->rd_exclstrats = NULL;
    6471     4085598 :         rel->rd_fdwroutine = NULL;
    6472             : 
    6473             :         /*
    6474             :          * Reset transient-state fields in the relcache entry
    6475             :          */
    6476     4085598 :         rel->rd_smgr = NULL;
    6477     4085598 :         if (rel->rd_isnailed)
    6478      666864 :             rel->rd_refcnt = 1;
    6479             :         else
    6480     3418734 :             rel->rd_refcnt = 0;
    6481     4085598 :         rel->rd_indexvalid = false;
    6482     4085598 :         rel->rd_indexlist = NIL;
    6483     4085598 :         rel->rd_pkindex = InvalidOid;
    6484     4085598 :         rel->rd_replidindex = InvalidOid;
    6485     4085598 :         rel->rd_attrsvalid = false;
    6486     4085598 :         rel->rd_keyattr = NULL;
    6487     4085598 :         rel->rd_pkattr = NULL;
    6488     4085598 :         rel->rd_idattr = NULL;
    6489     4085598 :         rel->rd_pubdesc = NULL;
    6490     4085598 :         rel->rd_statvalid = false;
    6491     4085598 :         rel->rd_statlist = NIL;
    6492     4085598 :         rel->rd_fkeyvalid = false;
    6493     4085598 :         rel->rd_fkeylist = NIL;
    6494     4085598 :         rel->rd_createSubid = InvalidSubTransactionId;
    6495     4085598 :         rel->rd_newRelfilelocatorSubid = InvalidSubTransactionId;
    6496     4085598 :         rel->rd_firstRelfilelocatorSubid = InvalidSubTransactionId;
    6497     4085598 :         rel->rd_droppedSubid = InvalidSubTransactionId;
    6498     4085598 :         rel->rd_amcache = NULL;
    6499     4085598 :         rel->pgstat_info = NULL;
    6500             : 
    6501             :         /*
    6502             :          * Recompute lock and physical addressing info.  This is needed in
    6503             :          * case the pg_internal.init file was copied from some other database
    6504             :          * by CREATE DATABASE.
    6505             :          */
    6506     4085598 :         RelationInitLockInfo(rel);
    6507     4085598 :         RelationInitPhysicalAddr(rel);
    6508             :     }
    6509             : 
    6510             :     /*
    6511             :      * We reached the end of the init file without apparent problem.  Did we
    6512             :      * get the right number of nailed items?  This is a useful crosscheck in
    6513             :      * case the set of critical rels or indexes changes.  However, that should
    6514             :      * not happen in a normally-running system, so let's bleat if it does.
    6515             :      *
    6516             :      * For the shared init file, we're called before client authentication is
    6517             :      * done, which means that elog(WARNING) will go only to the postmaster
    6518             :      * log, where it's easily missed.  To ensure that developers notice bad
    6519             :      * values of NUM_CRITICAL_SHARED_RELS/NUM_CRITICAL_SHARED_INDEXES, we put
    6520             :      * an Assert(false) there.
    6521             :      */
    6522       60624 :     if (shared)
    6523             :     {
    6524       31034 :         if (nailed_rels != NUM_CRITICAL_SHARED_RELS ||
    6525             :             nailed_indexes != NUM_CRITICAL_SHARED_INDEXES)
    6526             :         {
    6527           0 :             elog(WARNING, "found %d nailed shared rels and %d nailed shared indexes in init file, but expected %d and %d respectively",
    6528             :                  nailed_rels, nailed_indexes,
    6529             :                  NUM_CRITICAL_SHARED_RELS, NUM_CRITICAL_SHARED_INDEXES);
    6530             :             /* Make sure we get developers' attention about this */
    6531             :             Assert(false);
    6532             :             /* In production builds, recover by bootstrapping the relcache */
    6533           0 :             goto read_failed;
    6534             :         }
    6535             :     }
    6536             :     else
    6537             :     {
    6538       29590 :         if (nailed_rels != NUM_CRITICAL_LOCAL_RELS ||
    6539             :             nailed_indexes != NUM_CRITICAL_LOCAL_INDEXES)
    6540             :         {
    6541           0 :             elog(WARNING, "found %d nailed rels and %d nailed indexes in init file, but expected %d and %d respectively",
    6542             :                  nailed_rels, nailed_indexes,
    6543             :                  NUM_CRITICAL_LOCAL_RELS, NUM_CRITICAL_LOCAL_INDEXES);
    6544             :             /* We don't need an Assert() in this case */
    6545           0 :             goto read_failed;
    6546             :         }
    6547             :     }
    6548             : 
    6549             :     /*
    6550             :      * OK, all appears well.
    6551             :      *
    6552             :      * Now insert all the new relcache entries into the cache.
    6553             :      */
    6554     4146222 :     for (relno = 0; relno < num_rels; relno++)
    6555             :     {
    6556     4085598 :         RelationCacheInsert(rels[relno], false);
    6557             :     }
    6558             : 
    6559       60624 :     pfree(rels);
    6560       60624 :     FreeFile(fp);
    6561             : 
    6562       60624 :     if (shared)
    6563       31034 :         criticalSharedRelcachesBuilt = true;
    6564             :     else
    6565       29590 :         criticalRelcachesBuilt = true;
    6566       60624 :     return true;
    6567             : 
    6568             :     /*
    6569             :      * init file is broken, so do it the hard way.  We don't bother trying to
    6570             :      * free the clutter we just allocated; it's not in the relcache so it
    6571             :      * won't hurt.
    6572             :      */
    6573           0 : read_failed:
    6574           0 :     pfree(rels);
    6575           0 :     FreeFile(fp);
    6576             : 
    6577           0 :     return false;
    6578             : }
    6579             : 
    6580             : /*
    6581             :  * Write out a new initialization file with the current contents
    6582             :  * of the relcache (either shared rels or local rels, as indicated).
    6583             :  */
    6584             : static void
    6585        6844 : write_relcache_init_file(bool shared)
    6586             : {
    6587             :     FILE       *fp;
    6588             :     char        tempfilename[MAXPGPATH];
    6589             :     char        finalfilename[MAXPGPATH];
    6590             :     int         magic;
    6591             :     HASH_SEQ_STATUS status;
    6592             :     RelIdCacheEnt *idhentry;
    6593             :     int         i;
    6594             : 
    6595             :     /*
    6596             :      * If we have already received any relcache inval events, there's no
    6597             :      * chance of succeeding so we may as well skip the whole thing.
    6598             :      */
    6599        6844 :     if (relcacheInvalsReceived != 0L)
    6600          58 :         return;
    6601             : 
    6602             :     /*
    6603             :      * We must write a temporary file and rename it into place. Otherwise,
    6604             :      * another backend starting at about the same time might crash trying to
    6605             :      * read the partially-complete file.
    6606             :      */
    6607        6786 :     if (shared)
    6608             :     {
    6609        3394 :         snprintf(tempfilename, sizeof(tempfilename), "global/%s.%d",
    6610             :                  RELCACHE_INIT_FILENAME, MyProcPid);
    6611        3394 :         snprintf(finalfilename, sizeof(finalfilename), "global/%s",
    6612             :                  RELCACHE_INIT_FILENAME);
    6613             :     }
    6614             :     else
    6615             :     {
    6616        3392 :         snprintf(tempfilename, sizeof(tempfilename), "%s/%s.%d",
    6617             :                  DatabasePath, RELCACHE_INIT_FILENAME, MyProcPid);
    6618        3392 :         snprintf(finalfilename, sizeof(finalfilename), "%s/%s",
    6619             :                  DatabasePath, RELCACHE_INIT_FILENAME);
    6620             :     }
    6621             : 
    6622        6786 :     unlink(tempfilename);       /* in case it exists w/wrong permissions */
    6623             : 
    6624        6786 :     fp = AllocateFile(tempfilename, PG_BINARY_W);
    6625        6786 :     if (fp == NULL)
    6626             :     {
    6627             :         /*
    6628             :          * We used to consider this a fatal error, but we might as well
    6629             :          * continue with backend startup ...
    6630             :          */
    6631           0 :         ereport(WARNING,
    6632             :                 (errcode_for_file_access(),
    6633             :                  errmsg("could not create relation-cache initialization file \"%s\": %m",
    6634             :                         tempfilename),
    6635             :                  errdetail("Continuing anyway, but there's something wrong.")));
    6636           0 :         return;
    6637             :     }
    6638             : 
    6639             :     /*
    6640             :      * Write a magic number to serve as a file version identifier.  We can
    6641             :      * change the magic number whenever the relcache layout changes.
    6642             :      */
    6643        6786 :     magic = RELCACHE_INIT_FILEMAGIC;
    6644        6786 :     if (fwrite(&magic, 1, sizeof(magic), fp) != sizeof(magic))
    6645           0 :         ereport(FATAL,
    6646             :                 errcode_for_file_access(),
    6647             :                 errmsg_internal("could not write init file: %m"));
    6648             : 
    6649             :     /*
    6650             :      * Write all the appropriate reldescs (in no particular order).
    6651             :      */
    6652        6786 :     hash_seq_init(&status, RelationIdCache);
    6653             : 
    6654      936468 :     while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
    6655             :     {
    6656      929682 :         Relation    rel = idhentry->reldesc;
    6657      929682 :         Form_pg_class relform = rel->rd_rel;
    6658             : 
    6659             :         /* ignore if not correct group */
    6660      929682 :         if (relform->relisshared != shared)
    6661      464934 :             continue;
    6662             : 
    6663             :         /*
    6664             :          * Ignore if not supposed to be in init file.  We can allow any shared
    6665             :          * relation that's been loaded so far to be in the shared init file,
    6666             :          * but unshared relations must be ones that should be in the local
    6667             :          * file per RelationIdIsInInitFile.  (Note: if you want to change the
    6668             :          * criterion for rels to be kept in the init file, see also inval.c.
    6669             :          * The reason for filtering here is to be sure that we don't put
    6670             :          * anything into the local init file for which a relcache inval would
    6671             :          * not cause invalidation of that init file.)
    6672             :          */
    6673      464748 :         if (!shared && !RelationIdIsInInitFile(RelationGetRelid(rel)))
    6674             :         {
    6675             :             /* Nailed rels had better get stored. */
    6676             :             Assert(!rel->rd_isnailed);
    6677           0 :             continue;
    6678             :         }
    6679             : 
    6680             :         /* first write the relcache entry proper */
    6681      464748 :         write_item(rel, sizeof(RelationData), fp);
    6682             : 
    6683             :         /* next write the relation tuple form */
    6684      464748 :         write_item(relform, CLASS_TUPLE_SIZE, fp);
    6685             : 
    6686             :         /* next, do all the attribute tuple form data entries */
    6687     2727392 :         for (i = 0; i < relform->relnatts; i++)
    6688             :         {
    6689     2262644 :             write_item(TupleDescAttr(rel->rd_att, i),
    6690             :                        ATTRIBUTE_FIXED_PART_SIZE, fp);
    6691             :         }
    6692             : 
    6693             :         /* next, do the access method specific field */
    6694      464748 :         write_item(rel->rd_options,
    6695      464748 :                    (rel->rd_options ? VARSIZE(rel->rd_options) : 0),
    6696             :                    fp);
    6697             : 
    6698             :         /*
    6699             :          * If it's an index, there's more to do. Note we explicitly ignore
    6700             :          * partitioned indexes here.
    6701             :          */
    6702      464748 :         if (rel->rd_rel->relkind == RELKIND_INDEX)
    6703             :         {
    6704             :             /* write the pg_index tuple */
    6705             :             /* we assume this was created by heap_copytuple! */
    6706      291740 :             write_item(rel->rd_indextuple,
    6707      291740 :                        HEAPTUPLESIZE + rel->rd_indextuple->t_len,
    6708             :                        fp);
    6709             : 
    6710             :             /* write the vector of opfamily OIDs */
    6711      291740 :             write_item(rel->rd_opfamily,
    6712      291740 :                        relform->relnatts * sizeof(Oid),
    6713             :                        fp);
    6714             : 
    6715             :             /* write the vector of opcintype OIDs */
    6716      291740 :             write_item(rel->rd_opcintype,
    6717      291740 :                        relform->relnatts * sizeof(Oid),
    6718             :                        fp);
    6719             : 
    6720             :             /* write the vector of support procedure OIDs */
    6721      291740 :             write_item(rel->rd_support,
    6722      291740 :                        relform->relnatts * (rel->rd_indam->amsupport * sizeof(RegProcedure)),
    6723             :                        fp);
    6724             : 
    6725             :             /* write the vector of collation OIDs */
    6726      291740 :             write_item(rel->rd_indcollation,
    6727      291740 :                        relform->relnatts * sizeof(Oid),
    6728             :                        fp);
    6729             : 
    6730             :             /* write the vector of indoption values */
    6731      291740 :             write_item(rel->rd_indoption,
    6732      291740 :                        relform->relnatts * sizeof(int16),
    6733             :                        fp);
    6734             : 
    6735             :             Assert(rel->rd_opcoptions);
    6736             : 
    6737             :             /* write the vector of opcoptions values */
    6738      770054 :             for (i = 0; i < relform->relnatts; i++)
    6739             :             {
    6740      478314 :                 bytea      *opt = rel->rd_opcoptions[i];
    6741             : 
    6742      478314 :                 write_item(opt, opt ? VARSIZE(opt) : 0, fp);
    6743             :             }
    6744             :         }
    6745             :     }
    6746             : 
    6747        6786 :     if (FreeFile(fp))
    6748           0 :         ereport(FATAL,
    6749             :                 errcode_for_file_access(),
    6750             :                 errmsg_internal("could not write init file: %m"));
    6751             : 
    6752             :     /*
    6753             :      * Now we have to check whether the data we've so painstakingly
    6754             :      * accumulated is already obsolete due to someone else's just-committed
    6755             :      * catalog changes.  If so, we just delete the temp file and leave it to
    6756             :      * the next backend to try again.  (Our own relcache entries will be
    6757             :      * updated by SI message processing, but we can't be sure whether what we
    6758             :      * wrote out was up-to-date.)
    6759             :      *
    6760             :      * This mustn't run concurrently with the code that unlinks an init file
    6761             :      * and sends SI messages, so grab a serialization lock for the duration.
    6762             :      */
    6763        6786 :     LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE);
    6764             : 
    6765             :     /* Make sure we have seen all incoming SI messages */
    6766        6786 :     AcceptInvalidationMessages();
    6767             : 
    6768             :     /*
    6769             :      * If we have received any SI relcache invals since backend start, assume
    6770             :      * we may have written out-of-date data.
    6771             :      */
    6772        6786 :     if (relcacheInvalsReceived == 0L)
    6773             :     {
    6774             :         /*
    6775             :          * OK, rename the temp file to its final name, deleting any
    6776             :          * previously-existing init file.
    6777             :          *
    6778             :          * Note: a failure here is possible under Cygwin, if some other
    6779             :          * backend is holding open an unlinked-but-not-yet-gone init file. So
    6780             :          * treat this as a noncritical failure; just remove the useless temp
    6781             :          * file on failure.
    6782             :          */
    6783        6784 :         if (rename(tempfilename, finalfilename) < 0)
    6784           0 :             unlink(tempfilename);
    6785             :     }
    6786             :     else
    6787             :     {
    6788             :         /* Delete the already-obsolete temp file */
    6789           2 :         unlink(tempfilename);
    6790             :     }
    6791             : 
    6792        6786 :     LWLockRelease(RelCacheInitLock);
    6793             : }
    6794             : 
    6795             : /* write a chunk of data preceded by its length */
    6796             : static void
    6797     5885642 : write_item(const void *data, Size len, FILE *fp)
    6798             : {
    6799     5885642 :     if (fwrite(&len, 1, sizeof(len), fp) != sizeof(len))
    6800           0 :         ereport(FATAL,
    6801             :                 errcode_for_file_access(),
    6802             :                 errmsg_internal("could not write init file: %m"));
    6803     5885642 :     if (len > 0 && fwrite(data, 1, len, fp) != len)
    6804           0 :         ereport(FATAL,
    6805             :                 errcode_for_file_access(),
    6806             :                 errmsg_internal("could not write init file: %m"));
    6807     5885642 : }
    6808             : 
    6809             : /*
    6810             :  * Determine whether a given relation (identified by OID) is one of the ones
    6811             :  * we should store in a relcache init file.
    6812             :  *
    6813             :  * We must cache all nailed rels, and for efficiency we should cache every rel
    6814             :  * that supports a syscache.  The former set is almost but not quite a subset
    6815             :  * of the latter. The special cases are relations where
    6816             :  * RelationCacheInitializePhase2/3 chooses to nail for efficiency reasons, but
    6817             :  * which do not support any syscache.
    6818             :  */
    6819             : bool
    6820     2525190 : RelationIdIsInInitFile(Oid relationId)
    6821             : {
    6822     2525190 :     if (relationId == SharedSecLabelRelationId ||
    6823     2518650 :         relationId == TriggerRelidNameIndexId ||
    6824     2518346 :         relationId == DatabaseNameIndexId ||
    6825             :         relationId == SharedSecLabelObjectIndexId)
    6826             :     {
    6827             :         /*
    6828             :          * If this Assert fails, we don't need the applicable special case
    6829             :          * anymore.
    6830             :          */
    6831             :         Assert(!RelationSupportsSysCache(relationId));
    6832        7162 :         return true;
    6833             :     }
    6834     2518028 :     return RelationSupportsSysCache(relationId);
    6835             : }
    6836             : 
    6837             : /*
    6838             :  * Invalidate (remove) the init file during commit of a transaction that
    6839             :  * changed one or more of the relation cache entries that are kept in the
    6840             :  * local init file.
    6841             :  *
    6842             :  * To be safe against concurrent inspection or rewriting of the init file,
    6843             :  * we must take RelCacheInitLock, then remove the old init file, then send
    6844             :  * the SI messages that include relcache inval for such relations, and then
    6845             :  * release RelCacheInitLock.  This serializes the whole affair against
    6846             :  * write_relcache_init_file, so that we can be sure that any other process
    6847             :  * that's concurrently trying to create a new init file won't move an
    6848             :  * already-stale version into place after we unlink.  Also, because we unlink
    6849             :  * before sending the SI messages, a backend that's currently starting cannot
    6850             :  * read the now-obsolete init file and then miss the SI messages that will
    6851             :  * force it to update its relcache entries.  (This works because the backend
    6852             :  * startup sequence gets into the sinval array before trying to load the init
    6853             :  * file.)
    6854             :  *
    6855             :  * We take the lock and do the unlink in RelationCacheInitFilePreInvalidate,
    6856             :  * then release the lock in RelationCacheInitFilePostInvalidate.  Caller must
    6857             :  * send any pending SI messages between those calls.
    6858             :  */
    6859             : void
    6860       74878 : RelationCacheInitFilePreInvalidate(void)
    6861             : {
    6862             :     char        localinitfname[MAXPGPATH];
    6863             :     char        sharedinitfname[MAXPGPATH];
    6864             : 
    6865       74878 :     if (DatabasePath)
    6866       74878 :         snprintf(localinitfname, sizeof(localinitfname), "%s/%s",
    6867             :                  DatabasePath, RELCACHE_INIT_FILENAME);
    6868       74878 :     snprintf(sharedinitfname, sizeof(sharedinitfname), "global/%s",
    6869             :              RELCACHE_INIT_FILENAME);
    6870             : 
    6871       74878 :     LWLockAcquire(RelCacheInitLock, LW_EXCLUSIVE);
    6872             : 
    6873             :     /*
    6874             :      * The files might not be there if no backend has been started since the
    6875             :      * last removal.  But complain about failures other than ENOENT with
    6876             :      * ERROR.  Fortunately, it's not too late to abort the transaction if we
    6877             :      * can't get rid of the would-be-obsolete init file.
    6878             :      */
    6879       74878 :     if (DatabasePath)
    6880       74878 :         unlink_initfile(localinitfname, ERROR);
    6881       74878 :     unlink_initfile(sharedinitfname, ERROR);
    6882       74878 : }
    6883             : 
    6884             : void
    6885       74878 : RelationCacheInitFilePostInvalidate(void)
    6886             : {
    6887       74878 :     LWLockRelease(RelCacheInitLock);
    6888       74878 : }
    6889             : 
    6890             : /*
    6891             :  * Remove the init files during postmaster startup.
    6892             :  *
    6893             :  * We used to keep the init files across restarts, but that is unsafe in PITR
    6894             :  * scenarios, and even in simple crash-recovery cases there are windows for
    6895             :  * the init files to become out-of-sync with the database.  So now we just
    6896             :  * remove them during startup and expect the first backend launch to rebuild
    6897             :  * them.  Of course, this has to happen in each database of the cluster.
    6898             :  */
    6899             : void
    6900        1814 : RelationCacheInitFileRemove(void)
    6901             : {
    6902        1814 :     const char *tblspcdir = PG_TBLSPC_DIR;
    6903             :     DIR        *dir;
    6904             :     struct dirent *de;
    6905             :     char        path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)];
    6906             : 
    6907        1814 :     snprintf(path, sizeof(path), "global/%s",
    6908             :              RELCACHE_INIT_FILENAME);
    6909        1814 :     unlink_initfile(path, LOG);
    6910             : 
    6911             :     /* Scan everything in the default tablespace */
    6912        1814 :     RelationCacheInitFileRemoveInDir("base");
    6913             : 
    6914             :     /* Scan the tablespace link directory to find non-default tablespaces */
    6915        1814 :     dir = AllocateDir(tblspcdir);
    6916             : 
    6917        5538 :     while ((de = ReadDirExtended(dir, tblspcdir, LOG)) != NULL)
    6918             :     {
    6919        3724 :         if (strspn(de->d_name, "0123456789") == strlen(de->d_name))
    6920             :         {
    6921             :             /* Scan the tablespace dir for per-database dirs */
    6922          96 :             snprintf(path, sizeof(path), "%s/%s/%s",
    6923          96 :                      tblspcdir, de->d_name, TABLESPACE_VERSION_DIRECTORY);
    6924          96 :             RelationCacheInitFileRemoveInDir(path);
    6925             :         }
    6926             :     }
    6927             : 
    6928        1814 :     FreeDir(dir);
    6929        1814 : }
    6930             : 
    6931             : /* Process one per-tablespace directory for RelationCacheInitFileRemove */
    6932             : static void
    6933        1910 : RelationCacheInitFileRemoveInDir(const char *tblspcpath)
    6934             : {
    6935             :     DIR        *dir;
    6936             :     struct dirent *de;
    6937             :     char        initfilename[MAXPGPATH * 2];
    6938             : 
    6939             :     /* Scan the tablespace directory to find per-database directories */
    6940        1910 :     dir = AllocateDir(tblspcpath);
    6941             : 
    6942       11576 :     while ((de = ReadDirExtended(dir, tblspcpath, LOG)) != NULL)
    6943             :     {
    6944        9666 :         if (strspn(de->d_name, "0123456789") == strlen(de->d_name))
    6945             :         {
    6946             :             /* Try to remove the init file in each database */
    6947        5700 :             snprintf(initfilename, sizeof(initfilename), "%s/%s/%s",
    6948        5700 :                      tblspcpath, de->d_name, RELCACHE_INIT_FILENAME);
    6949        5700 :             unlink_initfile(initfilename, LOG);
    6950             :         }
    6951             :     }
    6952             : 
    6953        1910 :     FreeDir(dir);
    6954        1910 : }
    6955             : 
    6956             : static void
    6957      157270 : unlink_initfile(const char *initfilename, int elevel)
    6958             : {
    6959      157270 :     if (unlink(initfilename) < 0)
    6960             :     {
    6961             :         /* It might not be there, but log any error other than ENOENT */
    6962      154228 :         if (errno != ENOENT)
    6963           0 :             ereport(elevel,
    6964             :                     (errcode_for_file_access(),
    6965             :                      errmsg("could not remove cache file \"%s\": %m",
    6966             :                             initfilename)));
    6967             :     }
    6968      157270 : }
    6969             : 
    6970             : /*
    6971             :  * ResourceOwner callbacks
    6972             :  */
    6973             : static char *
    6974           0 : ResOwnerPrintRelCache(Datum res)
    6975             : {
    6976           0 :     Relation    rel = (Relation) DatumGetPointer(res);
    6977             : 
    6978           0 :     return psprintf("relation \"%s\"", RelationGetRelationName(rel));
    6979             : }
    6980             : 
    6981             : static void
    6982       43380 : ResOwnerReleaseRelation(Datum res)
    6983             : {
    6984       43380 :     Relation    rel = (Relation) DatumGetPointer(res);
    6985             : 
    6986             :     /*
    6987             :      * This reference has already been removed from the resource owner, so
    6988             :      * just decrement reference count without calling
    6989             :      * ResourceOwnerForgetRelationRef.
    6990             :      */
    6991             :     Assert(rel->rd_refcnt > 0);
    6992       43380 :     rel->rd_refcnt -= 1;
    6993             : 
    6994       43380 :     RelationCloseCleanup((Relation) res);
    6995       43380 : }

Generated by: LCOV version 1.14