LCOV - code coverage report
Current view: top level - src/backend/catalog - index.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 1097 1179 93.0 %
Date: 2025-04-01 15:15:16 Functions: 37 38 97.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * index.c
       4             :  *    code to create and destroy POSTGRES index relations
       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/catalog/index.c
      12             :  *
      13             :  *
      14             :  * INTERFACE ROUTINES
      15             :  *      index_create()          - Create a cataloged index relation
      16             :  *      index_drop()            - Removes index relation from catalogs
      17             :  *      BuildIndexInfo()        - Prepare to insert index tuples
      18             :  *      FormIndexDatum()        - Construct datum vector for one index tuple
      19             :  *
      20             :  *-------------------------------------------------------------------------
      21             :  */
      22             : #include "postgres.h"
      23             : 
      24             : #include <unistd.h>
      25             : 
      26             : #include "access/amapi.h"
      27             : #include "access/heapam.h"
      28             : #include "access/multixact.h"
      29             : #include "access/relscan.h"
      30             : #include "access/tableam.h"
      31             : #include "access/toast_compression.h"
      32             : #include "access/transam.h"
      33             : #include "access/visibilitymap.h"
      34             : #include "access/xact.h"
      35             : #include "bootstrap/bootstrap.h"
      36             : #include "catalog/binary_upgrade.h"
      37             : #include "catalog/catalog.h"
      38             : #include "catalog/dependency.h"
      39             : #include "catalog/heap.h"
      40             : #include "catalog/index.h"
      41             : #include "catalog/objectaccess.h"
      42             : #include "catalog/partition.h"
      43             : #include "catalog/pg_am.h"
      44             : #include "catalog/pg_collation.h"
      45             : #include "catalog/pg_constraint.h"
      46             : #include "catalog/pg_description.h"
      47             : #include "catalog/pg_inherits.h"
      48             : #include "catalog/pg_opclass.h"
      49             : #include "catalog/pg_operator.h"
      50             : #include "catalog/pg_tablespace.h"
      51             : #include "catalog/pg_trigger.h"
      52             : #include "catalog/pg_type.h"
      53             : #include "catalog/storage.h"
      54             : #include "catalog/storage_xlog.h"
      55             : #include "commands/event_trigger.h"
      56             : #include "commands/progress.h"
      57             : #include "commands/tablecmds.h"
      58             : #include "commands/trigger.h"
      59             : #include "executor/executor.h"
      60             : #include "miscadmin.h"
      61             : #include "nodes/makefuncs.h"
      62             : #include "nodes/nodeFuncs.h"
      63             : #include "optimizer/optimizer.h"
      64             : #include "parser/parser.h"
      65             : #include "pgstat.h"
      66             : #include "postmaster/autovacuum.h"
      67             : #include "rewrite/rewriteManip.h"
      68             : #include "storage/bufmgr.h"
      69             : #include "storage/lmgr.h"
      70             : #include "storage/predicate.h"
      71             : #include "storage/smgr.h"
      72             : #include "utils/builtins.h"
      73             : #include "utils/fmgroids.h"
      74             : #include "utils/guc.h"
      75             : #include "utils/inval.h"
      76             : #include "utils/lsyscache.h"
      77             : #include "utils/memutils.h"
      78             : #include "utils/pg_rusage.h"
      79             : #include "utils/rel.h"
      80             : #include "utils/snapmgr.h"
      81             : #include "utils/syscache.h"
      82             : #include "utils/tuplesort.h"
      83             : 
      84             : /* Potentially set by pg_upgrade_support functions */
      85             : Oid         binary_upgrade_next_index_pg_class_oid = InvalidOid;
      86             : RelFileNumber binary_upgrade_next_index_pg_class_relfilenumber =
      87             : InvalidRelFileNumber;
      88             : 
      89             : /*
      90             :  * Pointer-free representation of variables used when reindexing system
      91             :  * catalogs; we use this to propagate those values to parallel workers.
      92             :  */
      93             : typedef struct
      94             : {
      95             :     Oid         currentlyReindexedHeap;
      96             :     Oid         currentlyReindexedIndex;
      97             :     int         numPendingReindexedIndexes;
      98             :     Oid         pendingReindexedIndexes[FLEXIBLE_ARRAY_MEMBER];
      99             : } SerializedReindexState;
     100             : 
     101             : /* non-export function prototypes */
     102             : static bool relationHasPrimaryKey(Relation rel);
     103             : static TupleDesc ConstructTupleDescriptor(Relation heapRelation,
     104             :                                           const IndexInfo *indexInfo,
     105             :                                           const List *indexColNames,
     106             :                                           Oid accessMethodId,
     107             :                                           const Oid *collationIds,
     108             :                                           const Oid *opclassIds);
     109             : static void InitializeAttributeOids(Relation indexRelation,
     110             :                                     int numatts, Oid indexoid);
     111             : static void AppendAttributeTuples(Relation indexRelation, const Datum *attopts, const NullableDatum *stattargets);
     112             : static void UpdateIndexRelation(Oid indexoid, Oid heapoid,
     113             :                                 Oid parentIndexId,
     114             :                                 const IndexInfo *indexInfo,
     115             :                                 const Oid *collationOids,
     116             :                                 const Oid *opclassOids,
     117             :                                 const int16 *coloptions,
     118             :                                 bool primary,
     119             :                                 bool isexclusion,
     120             :                                 bool immediate,
     121             :                                 bool isvalid,
     122             :                                 bool isready);
     123             : static void index_update_stats(Relation rel,
     124             :                                bool hasindex,
     125             :                                double reltuples);
     126             : static void IndexCheckExclusion(Relation heapRelation,
     127             :                                 Relation indexRelation,
     128             :                                 IndexInfo *indexInfo);
     129             : static bool validate_index_callback(ItemPointer itemptr, void *opaque);
     130             : static bool ReindexIsCurrentlyProcessingIndex(Oid indexOid);
     131             : static void SetReindexProcessing(Oid heapOid, Oid indexOid);
     132             : static void ResetReindexProcessing(void);
     133             : static void SetReindexPending(List *indexes);
     134             : static void RemoveReindexPending(Oid indexOid);
     135             : 
     136             : 
     137             : /*
     138             :  * relationHasPrimaryKey
     139             :  *      See whether an existing relation has a primary key.
     140             :  *
     141             :  * Caller must have suitable lock on the relation.
     142             :  *
     143             :  * Note: we intentionally do not check indisvalid here; that's because this
     144             :  * is used to enforce the rule that there can be only one indisprimary index,
     145             :  * and we want that to be true even if said index is invalid.
     146             :  */
     147             : static bool
     148        7558 : relationHasPrimaryKey(Relation rel)
     149             : {
     150        7558 :     bool        result = false;
     151             :     List       *indexoidlist;
     152             :     ListCell   *indexoidscan;
     153             : 
     154             :     /*
     155             :      * Get the list of index OIDs for the table from the relcache, and look up
     156             :      * each one in the pg_index syscache until we find one marked primary key
     157             :      * (hopefully there isn't more than one such).
     158             :      */
     159        7558 :     indexoidlist = RelationGetIndexList(rel);
     160             : 
     161       18152 :     foreach(indexoidscan, indexoidlist)
     162             :     {
     163       10630 :         Oid         indexoid = lfirst_oid(indexoidscan);
     164             :         HeapTuple   indexTuple;
     165             : 
     166       10630 :         indexTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexoid));
     167       10630 :         if (!HeapTupleIsValid(indexTuple))  /* should not happen */
     168           0 :             elog(ERROR, "cache lookup failed for index %u", indexoid);
     169       10630 :         result = ((Form_pg_index) GETSTRUCT(indexTuple))->indisprimary;
     170       10630 :         ReleaseSysCache(indexTuple);
     171       10630 :         if (result)
     172          36 :             break;
     173             :     }
     174             : 
     175        7558 :     list_free(indexoidlist);
     176             : 
     177        7558 :     return result;
     178             : }
     179             : 
     180             : /*
     181             :  * index_check_primary_key
     182             :  *      Apply special checks needed before creating a PRIMARY KEY index
     183             :  *
     184             :  * This processing used to be in DefineIndex(), but has been split out
     185             :  * so that it can be applied during ALTER TABLE ADD PRIMARY KEY USING INDEX.
     186             :  *
     187             :  * We check for a pre-existing primary key, and that all columns of the index
     188             :  * are simple column references (not expressions), and that all those
     189             :  * columns are marked NOT NULL.  If not, fail.
     190             :  *
     191             :  * We used to automatically change unmarked columns to NOT NULL here by doing
     192             :  * our own local ALTER TABLE command.  But that doesn't work well if we're
     193             :  * executing one subcommand of an ALTER TABLE: the operations may not get
     194             :  * performed in the right order overall.  Now we expect that the parser
     195             :  * inserted any required ALTER TABLE SET NOT NULL operations before trying
     196             :  * to create a primary-key index.
     197             :  *
     198             :  * Caller had better have at least ShareLock on the table, else the not-null
     199             :  * checking isn't trustworthy.
     200             :  */
     201             : void
     202       14098 : index_check_primary_key(Relation heapRel,
     203             :                         const IndexInfo *indexInfo,
     204             :                         bool is_alter_table,
     205             :                         const IndexStmt *stmt)
     206             : {
     207             :     int         i;
     208             : 
     209             :     /*
     210             :      * If ALTER TABLE or CREATE TABLE .. PARTITION OF, check that there isn't
     211             :      * already a PRIMARY KEY.  In CREATE TABLE for an ordinary relation, we
     212             :      * have faith that the parser rejected multiple pkey clauses; and CREATE
     213             :      * INDEX doesn't have a way to say PRIMARY KEY, so it's no problem either.
     214             :      */
     215       21656 :     if ((is_alter_table || heapRel->rd_rel->relispartition) &&
     216        7558 :         relationHasPrimaryKey(heapRel))
     217             :     {
     218          36 :         ereport(ERROR,
     219             :                 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
     220             :                  errmsg("multiple primary keys for table \"%s\" are not allowed",
     221             :                         RelationGetRelationName(heapRel))));
     222             :     }
     223             : 
     224             :     /*
     225             :      * Indexes created with NULLS NOT DISTINCT cannot be used for primary key
     226             :      * constraints. While there is no direct syntax to reach here, it can be
     227             :      * done by creating a separate index and attaching it via ALTER TABLE ..
     228             :      * USING INDEX.
     229             :      */
     230       14062 :     if (indexInfo->ii_NullsNotDistinct)
     231             :     {
     232           6 :         ereport(ERROR,
     233             :                 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
     234             :                  errmsg("primary keys cannot use NULLS NOT DISTINCT indexes")));
     235             :     }
     236             : 
     237             :     /*
     238             :      * Check that all of the attributes in a primary key are marked as not
     239             :      * null.  (We don't really expect to see that; it'd mean the parser messed
     240             :      * up.  But it seems wise to check anyway.)
     241             :      */
     242       31176 :     for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
     243             :     {
     244       17120 :         AttrNumber  attnum = indexInfo->ii_IndexAttrNumbers[i];
     245             :         HeapTuple   atttuple;
     246             :         Form_pg_attribute attform;
     247             : 
     248       17120 :         if (attnum == 0)
     249           0 :             ereport(ERROR,
     250             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     251             :                      errmsg("primary keys cannot be expressions")));
     252             : 
     253             :         /* System attributes are never null, so no need to check */
     254       17120 :         if (attnum < 0)
     255           0 :             continue;
     256             : 
     257       17120 :         atttuple = SearchSysCache2(ATTNUM,
     258             :                                    ObjectIdGetDatum(RelationGetRelid(heapRel)),
     259             :                                    Int16GetDatum(attnum));
     260       17120 :         if (!HeapTupleIsValid(atttuple))
     261           0 :             elog(ERROR, "cache lookup failed for attribute %d of relation %u",
     262             :                  attnum, RelationGetRelid(heapRel));
     263       17120 :         attform = (Form_pg_attribute) GETSTRUCT(atttuple);
     264             : 
     265       17120 :         if (!attform->attnotnull)
     266           0 :             ereport(ERROR,
     267             :                     (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
     268             :                      errmsg("primary key column \"%s\" is not marked NOT NULL",
     269             :                             NameStr(attform->attname))));
     270             : 
     271       17120 :         ReleaseSysCache(atttuple);
     272             :     }
     273       14056 : }
     274             : 
     275             : /*
     276             :  *      ConstructTupleDescriptor
     277             :  *
     278             :  * Build an index tuple descriptor for a new index
     279             :  */
     280             : static TupleDesc
     281       45870 : ConstructTupleDescriptor(Relation heapRelation,
     282             :                          const IndexInfo *indexInfo,
     283             :                          const List *indexColNames,
     284             :                          Oid accessMethodId,
     285             :                          const Oid *collationIds,
     286             :                          const Oid *opclassIds)
     287             : {
     288       45870 :     int         numatts = indexInfo->ii_NumIndexAttrs;
     289       45870 :     int         numkeyatts = indexInfo->ii_NumIndexKeyAttrs;
     290       45870 :     ListCell   *colnames_item = list_head(indexColNames);
     291       45870 :     ListCell   *indexpr_item = list_head(indexInfo->ii_Expressions);
     292             :     IndexAmRoutine *amroutine;
     293             :     TupleDesc   heapTupDesc;
     294             :     TupleDesc   indexTupDesc;
     295             :     int         natts;          /* #atts in heap rel --- for error checks */
     296             :     int         i;
     297             : 
     298             :     /* We need access to the index AM's API struct */
     299       45870 :     amroutine = GetIndexAmRoutineByAmId(accessMethodId, false);
     300             : 
     301             :     /* ... and to the table's tuple descriptor */
     302       45870 :     heapTupDesc = RelationGetDescr(heapRelation);
     303       45870 :     natts = RelationGetForm(heapRelation)->relnatts;
     304             : 
     305             :     /*
     306             :      * allocate the new tuple descriptor
     307             :      */
     308       45870 :     indexTupDesc = CreateTemplateTupleDesc(numatts);
     309             : 
     310             :     /*
     311             :      * Fill in the pg_attribute row.
     312             :      */
     313      120576 :     for (i = 0; i < numatts; i++)
     314             :     {
     315       74712 :         AttrNumber  atnum = indexInfo->ii_IndexAttrNumbers[i];
     316       74712 :         Form_pg_attribute to = TupleDescAttr(indexTupDesc, i);
     317             :         HeapTuple   tuple;
     318             :         Form_pg_type typeTup;
     319             :         Form_pg_opclass opclassTup;
     320             :         Oid         keyType;
     321             : 
     322       74712 :         MemSet(to, 0, ATTRIBUTE_FIXED_PART_SIZE);
     323       74712 :         to->attnum = i + 1;
     324       74712 :         to->attislocal = true;
     325       74712 :         to->attcollation = (i < numkeyatts) ? collationIds[i] : InvalidOid;
     326             : 
     327             :         /*
     328             :          * Set the attribute name as specified by caller.
     329             :          */
     330       74712 :         if (colnames_item == NULL)  /* shouldn't happen */
     331           0 :             elog(ERROR, "too few entries in colnames list");
     332       74712 :         namestrcpy(&to->attname, (const char *) lfirst(colnames_item));
     333       74712 :         colnames_item = lnext(indexColNames, colnames_item);
     334             : 
     335             :         /*
     336             :          * For simple index columns, we copy some pg_attribute fields from the
     337             :          * parent relation.  For expressions we have to look at the expression
     338             :          * result.
     339             :          */
     340       74712 :         if (atnum != 0)
     341             :         {
     342             :             /* Simple index column */
     343             :             const FormData_pg_attribute *from;
     344             : 
     345             :             Assert(atnum > 0);   /* should've been caught above */
     346             : 
     347       73790 :             if (atnum > natts)   /* safety check */
     348           0 :                 elog(ERROR, "invalid column number %d", atnum);
     349       73790 :             from = TupleDescAttr(heapTupDesc,
     350             :                                  AttrNumberGetAttrOffset(atnum));
     351             : 
     352       73790 :             to->atttypid = from->atttypid;
     353       73790 :             to->attlen = from->attlen;
     354       73790 :             to->attndims = from->attndims;
     355       73790 :             to->atttypmod = from->atttypmod;
     356       73790 :             to->attbyval = from->attbyval;
     357       73790 :             to->attalign = from->attalign;
     358       73790 :             to->attstorage = from->attstorage;
     359       73790 :             to->attcompression = from->attcompression;
     360             :         }
     361             :         else
     362             :         {
     363             :             /* Expressional index */
     364             :             Node       *indexkey;
     365             : 
     366         922 :             if (indexpr_item == NULL)   /* shouldn't happen */
     367           0 :                 elog(ERROR, "too few entries in indexprs list");
     368         922 :             indexkey = (Node *) lfirst(indexpr_item);
     369         922 :             indexpr_item = lnext(indexInfo->ii_Expressions, indexpr_item);
     370             : 
     371             :             /*
     372             :              * Lookup the expression type in pg_type for the type length etc.
     373             :              */
     374         922 :             keyType = exprType(indexkey);
     375         922 :             tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(keyType));
     376         922 :             if (!HeapTupleIsValid(tuple))
     377           0 :                 elog(ERROR, "cache lookup failed for type %u", keyType);
     378         922 :             typeTup = (Form_pg_type) GETSTRUCT(tuple);
     379             : 
     380             :             /*
     381             :              * Assign some of the attributes values. Leave the rest.
     382             :              */
     383         922 :             to->atttypid = keyType;
     384         922 :             to->attlen = typeTup->typlen;
     385         922 :             to->atttypmod = exprTypmod(indexkey);
     386         922 :             to->attbyval = typeTup->typbyval;
     387         922 :             to->attalign = typeTup->typalign;
     388         922 :             to->attstorage = typeTup->typstorage;
     389             : 
     390             :             /*
     391             :              * For expression columns, set attcompression invalid, since
     392             :              * there's no table column from which to copy the value. Whenever
     393             :              * we actually need to compress a value, we'll use whatever the
     394             :              * current value of default_toast_compression is at that point in
     395             :              * time.
     396             :              */
     397         922 :             to->attcompression = InvalidCompressionMethod;
     398             : 
     399         922 :             ReleaseSysCache(tuple);
     400             : 
     401             :             /*
     402             :              * Make sure the expression yields a type that's safe to store in
     403             :              * an index.  We need this defense because we have index opclasses
     404             :              * for pseudo-types such as "record", and the actually stored type
     405             :              * had better be safe; eg, a named composite type is okay, an
     406             :              * anonymous record type is not.  The test is the same as for
     407             :              * whether a table column is of a safe type (which is why we
     408             :              * needn't check for the non-expression case).
     409             :              */
     410         922 :             CheckAttributeType(NameStr(to->attname),
     411             :                                to->atttypid, to->attcollation,
     412             :                                NIL, 0);
     413             :         }
     414             : 
     415             :         /*
     416             :          * We do not yet have the correct relation OID for the index, so just
     417             :          * set it invalid for now.  InitializeAttributeOids() will fix it
     418             :          * later.
     419             :          */
     420       74706 :         to->attrelid = InvalidOid;
     421             : 
     422             :         /*
     423             :          * Check the opclass and index AM to see if either provides a keytype
     424             :          * (overriding the attribute type).  Opclass (if exists) takes
     425             :          * precedence.
     426             :          */
     427       74706 :         keyType = amroutine->amkeytype;
     428             : 
     429       74706 :         if (i < indexInfo->ii_NumIndexKeyAttrs)
     430             :         {
     431       74068 :             tuple = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassIds[i]));
     432       74068 :             if (!HeapTupleIsValid(tuple))
     433           0 :                 elog(ERROR, "cache lookup failed for opclass %u", opclassIds[i]);
     434       74068 :             opclassTup = (Form_pg_opclass) GETSTRUCT(tuple);
     435       74068 :             if (OidIsValid(opclassTup->opckeytype))
     436        5068 :                 keyType = opclassTup->opckeytype;
     437             : 
     438             :             /*
     439             :              * If keytype is specified as ANYELEMENT, and opcintype is
     440             :              * ANYARRAY, then the attribute type must be an array (else it'd
     441             :              * not have matched this opclass); use its element type.
     442             :              *
     443             :              * We could also allow ANYCOMPATIBLE/ANYCOMPATIBLEARRAY here, but
     444             :              * there seems no need to do so; there's no reason to declare an
     445             :              * opclass as taking ANYCOMPATIBLEARRAY rather than ANYARRAY.
     446             :              */
     447       74068 :             if (keyType == ANYELEMENTOID && opclassTup->opcintype == ANYARRAYOID)
     448             :             {
     449         226 :                 keyType = get_base_element_type(to->atttypid);
     450         226 :                 if (!OidIsValid(keyType))
     451           0 :                     elog(ERROR, "could not get element type of array type %u",
     452             :                          to->atttypid);
     453             :             }
     454             : 
     455       74068 :             ReleaseSysCache(tuple);
     456             :         }
     457             : 
     458             :         /*
     459             :          * If a key type different from the heap value is specified, update
     460             :          * the type-related fields in the index tupdesc.
     461             :          */
     462       74706 :         if (OidIsValid(keyType) && keyType != to->atttypid)
     463             :         {
     464        4140 :             tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(keyType));
     465        4140 :             if (!HeapTupleIsValid(tuple))
     466           0 :                 elog(ERROR, "cache lookup failed for type %u", keyType);
     467        4140 :             typeTup = (Form_pg_type) GETSTRUCT(tuple);
     468             : 
     469        4140 :             to->atttypid = keyType;
     470        4140 :             to->atttypmod = -1;
     471        4140 :             to->attlen = typeTup->typlen;
     472        4140 :             to->attbyval = typeTup->typbyval;
     473        4140 :             to->attalign = typeTup->typalign;
     474        4140 :             to->attstorage = typeTup->typstorage;
     475             :             /* As above, use the default compression method in this case */
     476        4140 :             to->attcompression = InvalidCompressionMethod;
     477             : 
     478        4140 :             ReleaseSysCache(tuple);
     479             :         }
     480             : 
     481       74706 :         populate_compact_attribute(indexTupDesc, i);
     482             :     }
     483             : 
     484       45864 :     pfree(amroutine);
     485             : 
     486       45864 :     return indexTupDesc;
     487             : }
     488             : 
     489             : /* ----------------------------------------------------------------
     490             :  *      InitializeAttributeOids
     491             :  * ----------------------------------------------------------------
     492             :  */
     493             : static void
     494       45864 : InitializeAttributeOids(Relation indexRelation,
     495             :                         int numatts,
     496             :                         Oid indexoid)
     497             : {
     498             :     TupleDesc   tupleDescriptor;
     499             :     int         i;
     500             : 
     501       45864 :     tupleDescriptor = RelationGetDescr(indexRelation);
     502             : 
     503      120564 :     for (i = 0; i < numatts; i += 1)
     504       74700 :         TupleDescAttr(tupleDescriptor, i)->attrelid = indexoid;
     505       45864 : }
     506             : 
     507             : /* ----------------------------------------------------------------
     508             :  *      AppendAttributeTuples
     509             :  * ----------------------------------------------------------------
     510             :  */
     511             : static void
     512       45864 : AppendAttributeTuples(Relation indexRelation, const Datum *attopts, const NullableDatum *stattargets)
     513             : {
     514             :     Relation    pg_attribute;
     515             :     CatalogIndexState indstate;
     516             :     TupleDesc   indexTupDesc;
     517       45864 :     FormExtraData_pg_attribute *attrs_extra = NULL;
     518             : 
     519       45864 :     if (attopts)
     520             :     {
     521       28898 :         attrs_extra = palloc0_array(FormExtraData_pg_attribute, indexRelation->rd_att->natts);
     522             : 
     523       69666 :         for (int i = 0; i < indexRelation->rd_att->natts; i++)
     524             :         {
     525       40768 :             if (attopts[i])
     526         160 :                 attrs_extra[i].attoptions.value = attopts[i];
     527             :             else
     528       40608 :                 attrs_extra[i].attoptions.isnull = true;
     529             : 
     530       40768 :             if (stattargets)
     531         734 :                 attrs_extra[i].attstattarget = stattargets[i];
     532             :             else
     533       40034 :                 attrs_extra[i].attstattarget.isnull = true;
     534             :         }
     535             :     }
     536             : 
     537             :     /*
     538             :      * open the attribute relation and its indexes
     539             :      */
     540       45864 :     pg_attribute = table_open(AttributeRelationId, RowExclusiveLock);
     541             : 
     542       45864 :     indstate = CatalogOpenIndexes(pg_attribute);
     543             : 
     544             :     /*
     545             :      * insert data from new index's tupdesc into pg_attribute
     546             :      */
     547       45864 :     indexTupDesc = RelationGetDescr(indexRelation);
     548             : 
     549       45864 :     InsertPgAttributeTuples(pg_attribute, indexTupDesc, InvalidOid, attrs_extra, indstate);
     550             : 
     551       45864 :     CatalogCloseIndexes(indstate);
     552             : 
     553       45864 :     table_close(pg_attribute, RowExclusiveLock);
     554       45864 : }
     555             : 
     556             : /* ----------------------------------------------------------------
     557             :  *      UpdateIndexRelation
     558             :  *
     559             :  * Construct and insert a new entry in the pg_index catalog
     560             :  * ----------------------------------------------------------------
     561             :  */
     562             : static void
     563       45864 : UpdateIndexRelation(Oid indexoid,
     564             :                     Oid heapoid,
     565             :                     Oid parentIndexId,
     566             :                     const IndexInfo *indexInfo,
     567             :                     const Oid *collationOids,
     568             :                     const Oid *opclassOids,
     569             :                     const int16 *coloptions,
     570             :                     bool primary,
     571             :                     bool isexclusion,
     572             :                     bool immediate,
     573             :                     bool isvalid,
     574             :                     bool isready)
     575             : {
     576             :     int2vector *indkey;
     577             :     oidvector  *indcollation;
     578             :     oidvector  *indclass;
     579             :     int2vector *indoption;
     580             :     Datum       exprsDatum;
     581             :     Datum       predDatum;
     582             :     Datum       values[Natts_pg_index];
     583       45864 :     bool        nulls[Natts_pg_index] = {0};
     584             :     Relation    pg_index;
     585             :     HeapTuple   tuple;
     586             :     int         i;
     587             : 
     588             :     /*
     589             :      * Copy the index key, opclass, and indoption info into arrays (should we
     590             :      * make the caller pass them like this to start with?)
     591             :      */
     592       45864 :     indkey = buildint2vector(NULL, indexInfo->ii_NumIndexAttrs);
     593      120564 :     for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
     594       74700 :         indkey->values[i] = indexInfo->ii_IndexAttrNumbers[i];
     595       45864 :     indcollation = buildoidvector(collationOids, indexInfo->ii_NumIndexKeyAttrs);
     596       45864 :     indclass = buildoidvector(opclassOids, indexInfo->ii_NumIndexKeyAttrs);
     597       45864 :     indoption = buildint2vector(coloptions, indexInfo->ii_NumIndexKeyAttrs);
     598             : 
     599             :     /*
     600             :      * Convert the index expressions (if any) to a text datum
     601             :      */
     602       45864 :     if (indexInfo->ii_Expressions != NIL)
     603             :     {
     604             :         char       *exprsString;
     605             : 
     606         890 :         exprsString = nodeToString(indexInfo->ii_Expressions);
     607         890 :         exprsDatum = CStringGetTextDatum(exprsString);
     608         890 :         pfree(exprsString);
     609             :     }
     610             :     else
     611       44974 :         exprsDatum = (Datum) 0;
     612             : 
     613             :     /*
     614             :      * Convert the index predicate (if any) to a text datum.  Note we convert
     615             :      * implicit-AND format to normal explicit-AND for storage.
     616             :      */
     617       45864 :     if (indexInfo->ii_Predicate != NIL)
     618             :     {
     619             :         char       *predString;
     620             : 
     621         442 :         predString = nodeToString(make_ands_explicit(indexInfo->ii_Predicate));
     622         442 :         predDatum = CStringGetTextDatum(predString);
     623         442 :         pfree(predString);
     624             :     }
     625             :     else
     626       45422 :         predDatum = (Datum) 0;
     627             : 
     628             : 
     629             :     /*
     630             :      * open the system catalog index relation
     631             :      */
     632       45864 :     pg_index = table_open(IndexRelationId, RowExclusiveLock);
     633             : 
     634             :     /*
     635             :      * Build a pg_index tuple
     636             :      */
     637       45864 :     values[Anum_pg_index_indexrelid - 1] = ObjectIdGetDatum(indexoid);
     638       45864 :     values[Anum_pg_index_indrelid - 1] = ObjectIdGetDatum(heapoid);
     639       45864 :     values[Anum_pg_index_indnatts - 1] = Int16GetDatum(indexInfo->ii_NumIndexAttrs);
     640       45864 :     values[Anum_pg_index_indnkeyatts - 1] = Int16GetDatum(indexInfo->ii_NumIndexKeyAttrs);
     641       45864 :     values[Anum_pg_index_indisunique - 1] = BoolGetDatum(indexInfo->ii_Unique);
     642       45864 :     values[Anum_pg_index_indnullsnotdistinct - 1] = BoolGetDatum(indexInfo->ii_NullsNotDistinct);
     643       45864 :     values[Anum_pg_index_indisprimary - 1] = BoolGetDatum(primary);
     644       45864 :     values[Anum_pg_index_indisexclusion - 1] = BoolGetDatum(isexclusion);
     645       45864 :     values[Anum_pg_index_indimmediate - 1] = BoolGetDatum(immediate);
     646       45864 :     values[Anum_pg_index_indisclustered - 1] = BoolGetDatum(false);
     647       45864 :     values[Anum_pg_index_indisvalid - 1] = BoolGetDatum(isvalid);
     648       45864 :     values[Anum_pg_index_indcheckxmin - 1] = BoolGetDatum(false);
     649       45864 :     values[Anum_pg_index_indisready - 1] = BoolGetDatum(isready);
     650       45864 :     values[Anum_pg_index_indislive - 1] = BoolGetDatum(true);
     651       45864 :     values[Anum_pg_index_indisreplident - 1] = BoolGetDatum(false);
     652       45864 :     values[Anum_pg_index_indkey - 1] = PointerGetDatum(indkey);
     653       45864 :     values[Anum_pg_index_indcollation - 1] = PointerGetDatum(indcollation);
     654       45864 :     values[Anum_pg_index_indclass - 1] = PointerGetDatum(indclass);
     655       45864 :     values[Anum_pg_index_indoption - 1] = PointerGetDatum(indoption);
     656       45864 :     values[Anum_pg_index_indexprs - 1] = exprsDatum;
     657       45864 :     if (exprsDatum == (Datum) 0)
     658       44974 :         nulls[Anum_pg_index_indexprs - 1] = true;
     659       45864 :     values[Anum_pg_index_indpred - 1] = predDatum;
     660       45864 :     if (predDatum == (Datum) 0)
     661       45422 :         nulls[Anum_pg_index_indpred - 1] = true;
     662             : 
     663       45864 :     tuple = heap_form_tuple(RelationGetDescr(pg_index), values, nulls);
     664             : 
     665             :     /*
     666             :      * insert the tuple into the pg_index catalog
     667             :      */
     668       45864 :     CatalogTupleInsert(pg_index, tuple);
     669             : 
     670             :     /*
     671             :      * close the relation and free the tuple
     672             :      */
     673       45864 :     table_close(pg_index, RowExclusiveLock);
     674       45864 :     heap_freetuple(tuple);
     675       45864 : }
     676             : 
     677             : 
     678             : /*
     679             :  * index_create
     680             :  *
     681             :  * heapRelation: table to build index on (suitably locked by caller)
     682             :  * indexRelationName: what it say
     683             :  * indexRelationId: normally, pass InvalidOid to let this routine
     684             :  *      generate an OID for the index.  During bootstrap this may be
     685             :  *      nonzero to specify a preselected OID.
     686             :  * parentIndexRelid: if creating an index partition, the OID of the
     687             :  *      parent index; otherwise InvalidOid.
     688             :  * parentConstraintId: if creating a constraint on a partition, the OID
     689             :  *      of the constraint in the parent; otherwise InvalidOid.
     690             :  * relFileNumber: normally, pass InvalidRelFileNumber to get new storage.
     691             :  *      May be nonzero to attach an existing valid build.
     692             :  * indexInfo: same info executor uses to insert into the index
     693             :  * indexColNames: column names to use for index (List of char *)
     694             :  * accessMethodId: OID of index AM to use
     695             :  * tableSpaceId: OID of tablespace to use
     696             :  * collationIds: array of collation OIDs, one per index column
     697             :  * opclassIds: array of index opclass OIDs, one per index column
     698             :  * coloptions: array of per-index-column indoption settings
     699             :  * reloptions: AM-specific options
     700             :  * flags: bitmask that can include any combination of these bits:
     701             :  *      INDEX_CREATE_IS_PRIMARY
     702             :  *          the index is a primary key
     703             :  *      INDEX_CREATE_ADD_CONSTRAINT:
     704             :  *          invoke index_constraint_create also
     705             :  *      INDEX_CREATE_SKIP_BUILD:
     706             :  *          skip the index_build() step for the moment; caller must do it
     707             :  *          later (typically via reindex_index())
     708             :  *      INDEX_CREATE_CONCURRENT:
     709             :  *          do not lock the table against writers.  The index will be
     710             :  *          marked "invalid" and the caller must take additional steps
     711             :  *          to fix it up.
     712             :  *      INDEX_CREATE_IF_NOT_EXISTS:
     713             :  *          do not throw an error if a relation with the same name
     714             :  *          already exists.
     715             :  *      INDEX_CREATE_PARTITIONED:
     716             :  *          create a partitioned index (table must be partitioned)
     717             :  * constr_flags: flags passed to index_constraint_create
     718             :  *      (only if INDEX_CREATE_ADD_CONSTRAINT is set)
     719             :  * allow_system_table_mods: allow table to be a system catalog
     720             :  * is_internal: if true, post creation hook for new index
     721             :  * constraintId: if not NULL, receives OID of created constraint
     722             :  *
     723             :  * Returns the OID of the created index.
     724             :  */
     725             : Oid
     726       45912 : index_create(Relation heapRelation,
     727             :              const char *indexRelationName,
     728             :              Oid indexRelationId,
     729             :              Oid parentIndexRelid,
     730             :              Oid parentConstraintId,
     731             :              RelFileNumber relFileNumber,
     732             :              IndexInfo *indexInfo,
     733             :              const List *indexColNames,
     734             :              Oid accessMethodId,
     735             :              Oid tableSpaceId,
     736             :              const Oid *collationIds,
     737             :              const Oid *opclassIds,
     738             :              const Datum *opclassOptions,
     739             :              const int16 *coloptions,
     740             :              const NullableDatum *stattargets,
     741             :              Datum reloptions,
     742             :              bits16 flags,
     743             :              bits16 constr_flags,
     744             :              bool allow_system_table_mods,
     745             :              bool is_internal,
     746             :              Oid *constraintId)
     747             : {
     748       45912 :     Oid         heapRelationId = RelationGetRelid(heapRelation);
     749             :     Relation    pg_class;
     750             :     Relation    indexRelation;
     751             :     TupleDesc   indexTupDesc;
     752             :     bool        shared_relation;
     753             :     bool        mapped_relation;
     754             :     bool        is_exclusion;
     755             :     Oid         namespaceId;
     756             :     int         i;
     757             :     char        relpersistence;
     758       45912 :     bool        isprimary = (flags & INDEX_CREATE_IS_PRIMARY) != 0;
     759       45912 :     bool        invalid = (flags & INDEX_CREATE_INVALID) != 0;
     760       45912 :     bool        concurrent = (flags & INDEX_CREATE_CONCURRENT) != 0;
     761       45912 :     bool        partitioned = (flags & INDEX_CREATE_PARTITIONED) != 0;
     762             :     char        relkind;
     763             :     TransactionId relfrozenxid;
     764             :     MultiXactId relminmxid;
     765       45912 :     bool        create_storage = !RelFileNumberIsValid(relFileNumber);
     766             : 
     767             :     /* constraint flags can only be set when a constraint is requested */
     768             :     Assert((constr_flags == 0) ||
     769             :            ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0));
     770             :     /* partitioned indexes must never be "built" by themselves */
     771             :     Assert(!partitioned || (flags & INDEX_CREATE_SKIP_BUILD));
     772             : 
     773       45912 :     relkind = partitioned ? RELKIND_PARTITIONED_INDEX : RELKIND_INDEX;
     774       45912 :     is_exclusion = (indexInfo->ii_ExclusionOps != NULL);
     775             : 
     776       45912 :     pg_class = table_open(RelationRelationId, RowExclusiveLock);
     777             : 
     778             :     /*
     779             :      * The index will be in the same namespace as its parent table, and is
     780             :      * shared across databases if and only if the parent is.  Likewise, it
     781             :      * will use the relfilenumber map if and only if the parent does; and it
     782             :      * inherits the parent's relpersistence.
     783             :      */
     784       45912 :     namespaceId = RelationGetNamespace(heapRelation);
     785       45912 :     shared_relation = heapRelation->rd_rel->relisshared;
     786       45912 :     mapped_relation = RelationIsMapped(heapRelation);
     787       45912 :     relpersistence = heapRelation->rd_rel->relpersistence;
     788             : 
     789             :     /*
     790             :      * check parameters
     791             :      */
     792       45912 :     if (indexInfo->ii_NumIndexAttrs < 1)
     793           0 :         elog(ERROR, "must index at least one column");
     794             : 
     795       74224 :     if (!allow_system_table_mods &&
     796       28312 :         IsSystemRelation(heapRelation) &&
     797       11160 :         IsNormalProcessingMode())
     798           0 :         ereport(ERROR,
     799             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     800             :                  errmsg("user-defined indexes on system catalog tables are not supported")));
     801             : 
     802             :     /*
     803             :      * Btree text_pattern_ops uses text_eq as the equality operator, which is
     804             :      * fine as long as the collation is deterministic; text_eq then reduces to
     805             :      * bitwise equality and so it is semantically compatible with the other
     806             :      * operators and functions in that opclass.  But with a nondeterministic
     807             :      * collation, text_eq could yield results that are incompatible with the
     808             :      * actual behavior of the index (which is determined by the opclass's
     809             :      * comparison function).  We prevent such problems by refusing creation of
     810             :      * an index with that opclass and a nondeterministic collation.
     811             :      *
     812             :      * The same applies to varchar_pattern_ops and bpchar_pattern_ops.  If we
     813             :      * find more cases, we might decide to create a real mechanism for marking
     814             :      * opclasses as incompatible with nondeterminism; but for now, this small
     815             :      * hack suffices.
     816             :      *
     817             :      * Another solution is to use a special operator, not text_eq, as the
     818             :      * equality opclass member; but that is undesirable because it would
     819             :      * prevent index usage in many queries that work fine today.
     820             :      */
     821      120022 :     for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
     822             :     {
     823       74122 :         Oid         collation = collationIds[i];
     824       74122 :         Oid         opclass = opclassIds[i];
     825             : 
     826       74122 :         if (collation)
     827             :         {
     828        6070 :             if ((opclass == TEXT_BTREE_PATTERN_OPS_OID ||
     829        5996 :                  opclass == VARCHAR_BTREE_PATTERN_OPS_OID ||
     830          86 :                  opclass == BPCHAR_BTREE_PATTERN_OPS_OID) &&
     831          86 :                 !get_collation_isdeterministic(collation))
     832             :             {
     833             :                 HeapTuple   classtup;
     834             : 
     835          12 :                 classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
     836          12 :                 if (!HeapTupleIsValid(classtup))
     837           0 :                     elog(ERROR, "cache lookup failed for operator class %u", opclass);
     838          12 :                 ereport(ERROR,
     839             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     840             :                          errmsg("nondeterministic collations are not supported for operator class \"%s\"",
     841             :                                 NameStr(((Form_pg_opclass) GETSTRUCT(classtup))->opcname))));
     842             :                 ReleaseSysCache(classtup);
     843             :             }
     844             :         }
     845             :     }
     846             : 
     847             :     /*
     848             :      * Concurrent index build on a system catalog is unsafe because we tend to
     849             :      * release locks before committing in catalogs.
     850             :      */
     851       46650 :     if (concurrent &&
     852         750 :         IsCatalogRelation(heapRelation))
     853           0 :         ereport(ERROR,
     854             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     855             :                  errmsg("concurrent index creation on system catalog tables is not supported")));
     856             : 
     857             :     /*
     858             :      * This case is currently not supported.  There's no way to ask for it in
     859             :      * the grammar with CREATE INDEX, but it can happen with REINDEX.
     860             :      */
     861       45900 :     if (concurrent && is_exclusion)
     862           0 :         ereport(ERROR,
     863             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     864             :                  errmsg("concurrent index creation for exclusion constraints is not supported")));
     865             : 
     866             :     /*
     867             :      * We cannot allow indexing a shared relation after initdb (because
     868             :      * there's no way to make the entry in other databases' pg_class).
     869             :      */
     870       45900 :     if (shared_relation && !IsBootstrapProcessingMode())
     871           0 :         ereport(ERROR,
     872             :                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
     873             :                  errmsg("shared indexes cannot be created after initdb")));
     874             : 
     875             :     /*
     876             :      * Shared relations must be in pg_global, too (last-ditch check)
     877             :      */
     878       45900 :     if (shared_relation && tableSpaceId != GLOBALTABLESPACE_OID)
     879           0 :         elog(ERROR, "shared relations must be placed in pg_global tablespace");
     880             : 
     881             :     /*
     882             :      * Check for duplicate name (both as to the index, and as to the
     883             :      * associated constraint if any).  Such cases would fail on the relevant
     884             :      * catalogs' unique indexes anyway, but we prefer to give a friendlier
     885             :      * error message.
     886             :      */
     887       45900 :     if (get_relname_relid(indexRelationName, namespaceId))
     888             :     {
     889          24 :         if ((flags & INDEX_CREATE_IF_NOT_EXISTS) != 0)
     890             :         {
     891          18 :             ereport(NOTICE,
     892             :                     (errcode(ERRCODE_DUPLICATE_TABLE),
     893             :                      errmsg("relation \"%s\" already exists, skipping",
     894             :                             indexRelationName)));
     895          18 :             table_close(pg_class, RowExclusiveLock);
     896          18 :             return InvalidOid;
     897             :         }
     898             : 
     899           6 :         ereport(ERROR,
     900             :                 (errcode(ERRCODE_DUPLICATE_TABLE),
     901             :                  errmsg("relation \"%s\" already exists",
     902             :                         indexRelationName)));
     903             :     }
     904             : 
     905       55728 :     if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0 &&
     906        9852 :         ConstraintNameIsUsed(CONSTRAINT_RELATION, heapRelationId,
     907             :                              indexRelationName))
     908             :     {
     909             :         /*
     910             :          * INDEX_CREATE_IF_NOT_EXISTS does not apply here, since the
     911             :          * conflicting constraint is not an index.
     912             :          */
     913           6 :         ereport(ERROR,
     914             :                 (errcode(ERRCODE_DUPLICATE_OBJECT),
     915             :                  errmsg("constraint \"%s\" for relation \"%s\" already exists",
     916             :                         indexRelationName, RelationGetRelationName(heapRelation))));
     917             :     }
     918             : 
     919             :     /*
     920             :      * construct tuple descriptor for index tuples
     921             :      */
     922       45870 :     indexTupDesc = ConstructTupleDescriptor(heapRelation,
     923             :                                             indexInfo,
     924             :                                             indexColNames,
     925             :                                             accessMethodId,
     926             :                                             collationIds,
     927             :                                             opclassIds);
     928             : 
     929             :     /*
     930             :      * Allocate an OID for the index, unless we were told what to use.
     931             :      *
     932             :      * The OID will be the relfilenumber as well, so make sure it doesn't
     933             :      * collide with either pg_class OIDs or existing physical files.
     934             :      */
     935       45864 :     if (!OidIsValid(indexRelationId))
     936             :     {
     937             :         /* Use binary-upgrade override for pg_class.oid and relfilenumber */
     938       31464 :         if (IsBinaryUpgrade)
     939             :         {
     940        1086 :             if (!OidIsValid(binary_upgrade_next_index_pg_class_oid))
     941           0 :                 ereport(ERROR,
     942             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     943             :                          errmsg("pg_class index OID value not set when in binary upgrade mode")));
     944             : 
     945        1086 :             indexRelationId = binary_upgrade_next_index_pg_class_oid;
     946        1086 :             binary_upgrade_next_index_pg_class_oid = InvalidOid;
     947             : 
     948             :             /* Override the index relfilenumber */
     949        1086 :             if ((relkind == RELKIND_INDEX) &&
     950        1040 :                 (!RelFileNumberIsValid(binary_upgrade_next_index_pg_class_relfilenumber)))
     951           0 :                 ereport(ERROR,
     952             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     953             :                          errmsg("index relfilenumber value not set when in binary upgrade mode")));
     954        1086 :             relFileNumber = binary_upgrade_next_index_pg_class_relfilenumber;
     955        1086 :             binary_upgrade_next_index_pg_class_relfilenumber = InvalidRelFileNumber;
     956             : 
     957             :             /*
     958             :              * Note that we want create_storage = true for binary upgrade. The
     959             :              * storage we create here will be replaced later, but we need to
     960             :              * have something on disk in the meanwhile.
     961             :              */
     962             :             Assert(create_storage);
     963             :         }
     964             :         else
     965             :         {
     966             :             indexRelationId =
     967       30378 :                 GetNewRelFileNumber(tableSpaceId, pg_class, relpersistence);
     968             :         }
     969             :     }
     970             : 
     971             :     /*
     972             :      * create the index relation's relcache entry and, if necessary, the
     973             :      * physical disk file. (If we fail further down, it's the smgr's
     974             :      * responsibility to remove the disk file again, if any.)
     975             :      */
     976       45864 :     indexRelation = heap_create(indexRelationName,
     977             :                                 namespaceId,
     978             :                                 tableSpaceId,
     979             :                                 indexRelationId,
     980             :                                 relFileNumber,
     981             :                                 accessMethodId,
     982             :                                 indexTupDesc,
     983             :                                 relkind,
     984             :                                 relpersistence,
     985             :                                 shared_relation,
     986             :                                 mapped_relation,
     987             :                                 allow_system_table_mods,
     988             :                                 &relfrozenxid,
     989             :                                 &relminmxid,
     990             :                                 create_storage);
     991             : 
     992             :     Assert(relfrozenxid == InvalidTransactionId);
     993             :     Assert(relminmxid == InvalidMultiXactId);
     994             :     Assert(indexRelationId == RelationGetRelid(indexRelation));
     995             : 
     996             :     /*
     997             :      * Obtain exclusive lock on it.  Although no other transactions can see it
     998             :      * until we commit, this prevents deadlock-risk complaints from lock
     999             :      * manager in cases such as CLUSTER.
    1000             :      */
    1001       45864 :     LockRelation(indexRelation, AccessExclusiveLock);
    1002             : 
    1003             :     /*
    1004             :      * Fill in fields of the index's pg_class entry that are not set correctly
    1005             :      * by heap_create.
    1006             :      *
    1007             :      * XXX should have a cleaner way to create cataloged indexes
    1008             :      */
    1009       45864 :     indexRelation->rd_rel->relowner = heapRelation->rd_rel->relowner;
    1010       45864 :     indexRelation->rd_rel->relam = accessMethodId;
    1011       45864 :     indexRelation->rd_rel->relispartition = OidIsValid(parentIndexRelid);
    1012             : 
    1013             :     /*
    1014             :      * store index's pg_class entry
    1015             :      */
    1016       45864 :     InsertPgClassTuple(pg_class, indexRelation,
    1017             :                        RelationGetRelid(indexRelation),
    1018             :                        (Datum) 0,
    1019             :                        reloptions);
    1020             : 
    1021             :     /* done with pg_class */
    1022       45864 :     table_close(pg_class, RowExclusiveLock);
    1023             : 
    1024             :     /*
    1025             :      * now update the object id's of all the attribute tuple forms in the
    1026             :      * index relation's tuple descriptor
    1027             :      */
    1028       45864 :     InitializeAttributeOids(indexRelation,
    1029             :                             indexInfo->ii_NumIndexAttrs,
    1030             :                             indexRelationId);
    1031             : 
    1032             :     /*
    1033             :      * append ATTRIBUTE tuples for the index
    1034             :      */
    1035       45864 :     AppendAttributeTuples(indexRelation, opclassOptions, stattargets);
    1036             : 
    1037             :     /* ----------------
    1038             :      *    update pg_index
    1039             :      *    (append INDEX tuple)
    1040             :      *
    1041             :      *    Note that this stows away a representation of "predicate".
    1042             :      *    (Or, could define a rule to maintain the predicate) --Nels, Feb '92
    1043             :      * ----------------
    1044             :      */
    1045       91728 :     UpdateIndexRelation(indexRelationId, heapRelationId, parentIndexRelid,
    1046             :                         indexInfo,
    1047             :                         collationIds, opclassIds, coloptions,
    1048             :                         isprimary, is_exclusion,
    1049       45864 :                         (constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
    1050       45864 :                         !concurrent && !invalid,
    1051       45864 :                         !concurrent);
    1052             : 
    1053             :     /*
    1054             :      * Register relcache invalidation on the indexes' heap relation, to
    1055             :      * maintain consistency of its index list
    1056             :      */
    1057       45864 :     CacheInvalidateRelcache(heapRelation);
    1058             : 
    1059             :     /* update pg_inherits and the parent's relhassubclass, if needed */
    1060       45864 :     if (OidIsValid(parentIndexRelid))
    1061             :     {
    1062        2414 :         StoreSingleInheritance(indexRelationId, parentIndexRelid, 1);
    1063        2414 :         LockRelationOid(parentIndexRelid, ShareUpdateExclusiveLock);
    1064        2414 :         SetRelationHasSubclass(parentIndexRelid, true);
    1065             :     }
    1066             : 
    1067             :     /*
    1068             :      * Register constraint and dependencies for the index.
    1069             :      *
    1070             :      * If the index is from a CONSTRAINT clause, construct a pg_constraint
    1071             :      * entry.  The index will be linked to the constraint, which in turn is
    1072             :      * linked to the table.  If it's not a CONSTRAINT, we need to make a
    1073             :      * dependency directly on the table.
    1074             :      *
    1075             :      * We don't need a dependency on the namespace, because there'll be an
    1076             :      * indirect dependency via our parent table.
    1077             :      *
    1078             :      * During bootstrap we can't register any dependencies, and we don't try
    1079             :      * to make a constraint either.
    1080             :      */
    1081       45864 :     if (!IsBootstrapProcessingMode())
    1082             :     {
    1083             :         ObjectAddress myself,
    1084             :                     referenced;
    1085             :         ObjectAddresses *addrs;
    1086             : 
    1087       31464 :         ObjectAddressSet(myself, RelationRelationId, indexRelationId);
    1088             : 
    1089       31464 :         if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0)
    1090             :         {
    1091             :             char        constraintType;
    1092             :             ObjectAddress localaddr;
    1093             : 
    1094        9846 :             if (isprimary)
    1095        8634 :                 constraintType = CONSTRAINT_PRIMARY;
    1096        1212 :             else if (indexInfo->ii_Unique)
    1097        1012 :                 constraintType = CONSTRAINT_UNIQUE;
    1098         200 :             else if (is_exclusion)
    1099         200 :                 constraintType = CONSTRAINT_EXCLUSION;
    1100             :             else
    1101             :             {
    1102           0 :                 elog(ERROR, "constraint must be PRIMARY, UNIQUE or EXCLUDE");
    1103             :                 constraintType = 0; /* keep compiler quiet */
    1104             :             }
    1105             : 
    1106        9846 :             localaddr = index_constraint_create(heapRelation,
    1107             :                                                 indexRelationId,
    1108             :                                                 parentConstraintId,
    1109             :                                                 indexInfo,
    1110             :                                                 indexRelationName,
    1111             :                                                 constraintType,
    1112             :                                                 constr_flags,
    1113             :                                                 allow_system_table_mods,
    1114             :                                                 is_internal);
    1115        9846 :             if (constraintId)
    1116        9846 :                 *constraintId = localaddr.objectId;
    1117             :         }
    1118             :         else
    1119             :         {
    1120       21618 :             bool        have_simple_col = false;
    1121             : 
    1122       21618 :             addrs = new_object_addresses();
    1123             : 
    1124             :             /* Create auto dependencies on simply-referenced columns */
    1125       59448 :             for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
    1126             :             {
    1127       37830 :                 if (indexInfo->ii_IndexAttrNumbers[i] != 0)
    1128             :                 {
    1129       36948 :                     ObjectAddressSubSet(referenced, RelationRelationId,
    1130             :                                         heapRelationId,
    1131             :                                         indexInfo->ii_IndexAttrNumbers[i]);
    1132       36948 :                     add_exact_object_address(&referenced, addrs);
    1133       36948 :                     have_simple_col = true;
    1134             :                 }
    1135             :             }
    1136             : 
    1137             :             /*
    1138             :              * If there are no simply-referenced columns, give the index an
    1139             :              * auto dependency on the whole table.  In most cases, this will
    1140             :              * be redundant, but it might not be if the index expressions and
    1141             :              * predicate contain no Vars or only whole-row Vars.
    1142             :              */
    1143       21618 :             if (!have_simple_col)
    1144             :             {
    1145         696 :                 ObjectAddressSet(referenced, RelationRelationId,
    1146             :                                  heapRelationId);
    1147         696 :                 add_exact_object_address(&referenced, addrs);
    1148             :             }
    1149             : 
    1150       21618 :             record_object_address_dependencies(&myself, addrs, DEPENDENCY_AUTO);
    1151       21618 :             free_object_addresses(addrs);
    1152             :         }
    1153             : 
    1154             :         /*
    1155             :          * If this is an index partition, create partition dependencies on
    1156             :          * both the parent index and the table.  (Note: these must be *in
    1157             :          * addition to*, not instead of, all other dependencies.  Otherwise
    1158             :          * we'll be short some dependencies after DETACH PARTITION.)
    1159             :          */
    1160       31464 :         if (OidIsValid(parentIndexRelid))
    1161             :         {
    1162        2414 :             ObjectAddressSet(referenced, RelationRelationId, parentIndexRelid);
    1163        2414 :             recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
    1164             : 
    1165        2414 :             ObjectAddressSet(referenced, RelationRelationId, heapRelationId);
    1166        2414 :             recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
    1167             :         }
    1168             : 
    1169             :         /* placeholder for normal dependencies */
    1170       31464 :         addrs = new_object_addresses();
    1171             : 
    1172             :         /* Store dependency on collations */
    1173             : 
    1174             :         /* The default collation is pinned, so don't bother recording it */
    1175       80596 :         for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
    1176             :         {
    1177       49132 :             if (OidIsValid(collationIds[i]) && collationIds[i] != DEFAULT_COLLATION_OID)
    1178             :             {
    1179         376 :                 ObjectAddressSet(referenced, CollationRelationId, collationIds[i]);
    1180         376 :                 add_exact_object_address(&referenced, addrs);
    1181             :             }
    1182             :         }
    1183             : 
    1184             :         /* Store dependency on operator classes */
    1185       80596 :         for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
    1186             :         {
    1187       49132 :             ObjectAddressSet(referenced, OperatorClassRelationId, opclassIds[i]);
    1188       49132 :             add_exact_object_address(&referenced, addrs);
    1189             :         }
    1190             : 
    1191       31464 :         record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
    1192       31464 :         free_object_addresses(addrs);
    1193             : 
    1194             :         /* Store dependencies on anything mentioned in index expressions */
    1195       31464 :         if (indexInfo->ii_Expressions)
    1196             :         {
    1197         890 :             recordDependencyOnSingleRelExpr(&myself,
    1198         890 :                                             (Node *) indexInfo->ii_Expressions,
    1199             :                                             heapRelationId,
    1200             :                                             DEPENDENCY_NORMAL,
    1201             :                                             DEPENDENCY_AUTO, false);
    1202             :         }
    1203             : 
    1204             :         /* Store dependencies on anything mentioned in predicate */
    1205       31464 :         if (indexInfo->ii_Predicate)
    1206             :         {
    1207         442 :             recordDependencyOnSingleRelExpr(&myself,
    1208         442 :                                             (Node *) indexInfo->ii_Predicate,
    1209             :                                             heapRelationId,
    1210             :                                             DEPENDENCY_NORMAL,
    1211             :                                             DEPENDENCY_AUTO, false);
    1212             :         }
    1213             :     }
    1214             :     else
    1215             :     {
    1216             :         /* Bootstrap mode - assert we weren't asked for constraint support */
    1217             :         Assert((flags & INDEX_CREATE_ADD_CONSTRAINT) == 0);
    1218             :     }
    1219             : 
    1220             :     /* Post creation hook for new index */
    1221       45864 :     InvokeObjectPostCreateHookArg(RelationRelationId,
    1222             :                                   indexRelationId, 0, is_internal);
    1223             : 
    1224             :     /*
    1225             :      * Advance the command counter so that we can see the newly-entered
    1226             :      * catalog tuples for the index.
    1227             :      */
    1228       45864 :     CommandCounterIncrement();
    1229             : 
    1230             :     /*
    1231             :      * In bootstrap mode, we have to fill in the index strategy structure with
    1232             :      * information from the catalogs.  If we aren't bootstrapping, then the
    1233             :      * relcache entry has already been rebuilt thanks to sinval update during
    1234             :      * CommandCounterIncrement.
    1235             :      */
    1236       45858 :     if (IsBootstrapProcessingMode())
    1237       14400 :         RelationInitIndexAccessInfo(indexRelation);
    1238             :     else
    1239             :         Assert(indexRelation->rd_indexcxt != NULL);
    1240             : 
    1241       45858 :     indexRelation->rd_index->indnkeyatts = indexInfo->ii_NumIndexKeyAttrs;
    1242             : 
    1243             :     /* Validate opclass-specific options */
    1244       45858 :     if (opclassOptions)
    1245       68928 :         for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
    1246       40124 :             (void) index_opclass_options(indexRelation, i + 1,
    1247       40124 :                                          opclassOptions[i],
    1248             :                                          true);
    1249             : 
    1250             :     /*
    1251             :      * If this is bootstrap (initdb) time, then we don't actually fill in the
    1252             :      * index yet.  We'll be creating more indexes and classes later, so we
    1253             :      * delay filling them in until just before we're done with bootstrapping.
    1254             :      * Similarly, if the caller specified to skip the build then filling the
    1255             :      * index is delayed till later (ALTER TABLE can save work in some cases
    1256             :      * with this).  Otherwise, we call the AM routine that constructs the
    1257             :      * index.
    1258             :      */
    1259       45770 :     if (IsBootstrapProcessingMode())
    1260             :     {
    1261       14400 :         index_register(heapRelationId, indexRelationId, indexInfo);
    1262             :     }
    1263       31370 :     else if ((flags & INDEX_CREATE_SKIP_BUILD) != 0)
    1264             :     {
    1265             :         /*
    1266             :          * Caller is responsible for filling the index later on.  However,
    1267             :          * we'd better make sure that the heap relation is correctly marked as
    1268             :          * having an index.
    1269             :          */
    1270        3112 :         index_update_stats(heapRelation,
    1271             :                            true,
    1272             :                            -1.0);
    1273             :         /* Make the above update visible */
    1274        3112 :         CommandCounterIncrement();
    1275             :     }
    1276             :     else
    1277             :     {
    1278       28258 :         index_build(heapRelation, indexRelation, indexInfo, false, true);
    1279             :     }
    1280             : 
    1281             :     /*
    1282             :      * Close the index; but we keep the lock that we acquired above until end
    1283             :      * of transaction.  Closing the heap is caller's responsibility.
    1284             :      */
    1285       45662 :     index_close(indexRelation, NoLock);
    1286             : 
    1287       45662 :     return indexRelationId;
    1288             : }
    1289             : 
    1290             : /*
    1291             :  * index_concurrently_create_copy
    1292             :  *
    1293             :  * Create concurrently an index based on the definition of the one provided by
    1294             :  * caller.  The index is inserted into catalogs and needs to be built later
    1295             :  * on.  This is called during concurrent reindex processing.
    1296             :  *
    1297             :  * "tablespaceOid" is the tablespace to use for this index.
    1298             :  */
    1299             : Oid
    1300         520 : index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId,
    1301             :                                Oid tablespaceOid, const char *newName)
    1302             : {
    1303             :     Relation    indexRelation;
    1304             :     IndexInfo  *oldInfo,
    1305             :                *newInfo;
    1306         520 :     Oid         newIndexId = InvalidOid;
    1307             :     HeapTuple   indexTuple,
    1308             :                 classTuple;
    1309             :     Datum       indclassDatum,
    1310             :                 colOptionDatum,
    1311             :                 reloptionsDatum;
    1312             :     Datum      *opclassOptions;
    1313             :     oidvector  *indclass;
    1314             :     int2vector *indcoloptions;
    1315             :     NullableDatum *stattargets;
    1316             :     bool        isnull;
    1317         520 :     List       *indexColNames = NIL;
    1318         520 :     List       *indexExprs = NIL;
    1319         520 :     List       *indexPreds = NIL;
    1320             : 
    1321         520 :     indexRelation = index_open(oldIndexId, RowExclusiveLock);
    1322             : 
    1323             :     /* The new index needs some information from the old index */
    1324         520 :     oldInfo = BuildIndexInfo(indexRelation);
    1325             : 
    1326             :     /*
    1327             :      * Concurrent build of an index with exclusion constraints is not
    1328             :      * supported.
    1329             :      */
    1330         520 :     if (oldInfo->ii_ExclusionOps != NULL)
    1331           6 :         ereport(ERROR,
    1332             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1333             :                  errmsg("concurrent index creation for exclusion constraints is not supported")));
    1334             : 
    1335             :     /* Get the array of class and column options IDs from index info */
    1336         514 :     indexTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(oldIndexId));
    1337         514 :     if (!HeapTupleIsValid(indexTuple))
    1338           0 :         elog(ERROR, "cache lookup failed for index %u", oldIndexId);
    1339         514 :     indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
    1340             :                                            Anum_pg_index_indclass);
    1341         514 :     indclass = (oidvector *) DatumGetPointer(indclassDatum);
    1342             : 
    1343         514 :     colOptionDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
    1344             :                                             Anum_pg_index_indoption);
    1345         514 :     indcoloptions = (int2vector *) DatumGetPointer(colOptionDatum);
    1346             : 
    1347             :     /* Fetch reloptions of index if any */
    1348         514 :     classTuple = SearchSysCache1(RELOID, ObjectIdGetDatum(oldIndexId));
    1349         514 :     if (!HeapTupleIsValid(classTuple))
    1350           0 :         elog(ERROR, "cache lookup failed for relation %u", oldIndexId);
    1351         514 :     reloptionsDatum = SysCacheGetAttr(RELOID, classTuple,
    1352             :                                       Anum_pg_class_reloptions, &isnull);
    1353             : 
    1354             :     /*
    1355             :      * Fetch the list of expressions and predicates directly from the
    1356             :      * catalogs.  This cannot rely on the information from IndexInfo of the
    1357             :      * old index as these have been flattened for the planner.
    1358             :      */
    1359         514 :     if (oldInfo->ii_Expressions != NIL)
    1360             :     {
    1361             :         Datum       exprDatum;
    1362             :         char       *exprString;
    1363             : 
    1364          40 :         exprDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
    1365             :                                            Anum_pg_index_indexprs);
    1366          40 :         exprString = TextDatumGetCString(exprDatum);
    1367          40 :         indexExprs = (List *) stringToNode(exprString);
    1368          40 :         pfree(exprString);
    1369             :     }
    1370         514 :     if (oldInfo->ii_Predicate != NIL)
    1371             :     {
    1372             :         Datum       predDatum;
    1373             :         char       *predString;
    1374             : 
    1375          28 :         predDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
    1376             :                                            Anum_pg_index_indpred);
    1377          28 :         predString = TextDatumGetCString(predDatum);
    1378          28 :         indexPreds = (List *) stringToNode(predString);
    1379             : 
    1380             :         /* Also convert to implicit-AND format */
    1381          28 :         indexPreds = make_ands_implicit((Expr *) indexPreds);
    1382          28 :         pfree(predString);
    1383             :     }
    1384             : 
    1385             :     /*
    1386             :      * Build the index information for the new index.  Note that rebuild of
    1387             :      * indexes with exclusion constraints is not supported, hence there is no
    1388             :      * need to fill all the ii_Exclusion* fields.
    1389             :      */
    1390         514 :     newInfo = makeIndexInfo(oldInfo->ii_NumIndexAttrs,
    1391             :                             oldInfo->ii_NumIndexKeyAttrs,
    1392             :                             oldInfo->ii_Am,
    1393             :                             indexExprs,
    1394             :                             indexPreds,
    1395         514 :                             oldInfo->ii_Unique,
    1396         514 :                             oldInfo->ii_NullsNotDistinct,
    1397             :                             false,  /* not ready for inserts */
    1398             :                             true,
    1399         514 :                             indexRelation->rd_indam->amsummarizing,
    1400         514 :                             oldInfo->ii_WithoutOverlaps);
    1401             : 
    1402             :     /*
    1403             :      * Extract the list of column names and the column numbers for the new
    1404             :      * index information.  All this information will be used for the index
    1405             :      * creation.
    1406             :      */
    1407        1248 :     for (int i = 0; i < oldInfo->ii_NumIndexAttrs; i++)
    1408             :     {
    1409         734 :         TupleDesc   indexTupDesc = RelationGetDescr(indexRelation);
    1410         734 :         Form_pg_attribute att = TupleDescAttr(indexTupDesc, i);
    1411             : 
    1412         734 :         indexColNames = lappend(indexColNames, NameStr(att->attname));
    1413         734 :         newInfo->ii_IndexAttrNumbers[i] = oldInfo->ii_IndexAttrNumbers[i];
    1414             :     }
    1415             : 
    1416             :     /* Extract opclass options for each attribute */
    1417         514 :     opclassOptions = palloc0(sizeof(Datum) * newInfo->ii_NumIndexAttrs);
    1418        1248 :     for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
    1419         734 :         opclassOptions[i] = get_attoptions(oldIndexId, i + 1);
    1420             : 
    1421             :     /* Extract statistic targets for each attribute */
    1422         514 :     stattargets = palloc0_array(NullableDatum, newInfo->ii_NumIndexAttrs);
    1423        1248 :     for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
    1424             :     {
    1425             :         HeapTuple   tp;
    1426             :         Datum       dat;
    1427             : 
    1428         734 :         tp = SearchSysCache2(ATTNUM, ObjectIdGetDatum(oldIndexId), Int16GetDatum(i + 1));
    1429         734 :         if (!HeapTupleIsValid(tp))
    1430           0 :             elog(ERROR, "cache lookup failed for attribute %d of relation %u",
    1431             :                  i + 1, oldIndexId);
    1432         734 :         dat = SysCacheGetAttr(ATTNUM, tp, Anum_pg_attribute_attstattarget, &isnull);
    1433         734 :         ReleaseSysCache(tp);
    1434         734 :         stattargets[i].value = dat;
    1435         734 :         stattargets[i].isnull = isnull;
    1436             :     }
    1437             : 
    1438             :     /*
    1439             :      * Now create the new index.
    1440             :      *
    1441             :      * For a partition index, we adjust the partition dependency later, to
    1442             :      * ensure a consistent state at all times.  That is why parentIndexRelid
    1443             :      * is not set here.
    1444             :      */
    1445         514 :     newIndexId = index_create(heapRelation,
    1446             :                               newName,
    1447             :                               InvalidOid,   /* indexRelationId */
    1448             :                               InvalidOid,   /* parentIndexRelid */
    1449             :                               InvalidOid,   /* parentConstraintId */
    1450             :                               InvalidRelFileNumber, /* relFileNumber */
    1451             :                               newInfo,
    1452             :                               indexColNames,
    1453         514 :                               indexRelation->rd_rel->relam,
    1454             :                               tablespaceOid,
    1455         514 :                               indexRelation->rd_indcollation,
    1456         514 :                               indclass->values,
    1457             :                               opclassOptions,
    1458         514 :                               indcoloptions->values,
    1459             :                               stattargets,
    1460             :                               reloptionsDatum,
    1461             :                               INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT,
    1462             :                               0,
    1463             :                               true, /* allow table to be a system catalog? */
    1464             :                               false,    /* is_internal? */
    1465             :                               NULL);
    1466             : 
    1467             :     /* Close the relations used and clean up */
    1468         514 :     index_close(indexRelation, NoLock);
    1469         514 :     ReleaseSysCache(indexTuple);
    1470         514 :     ReleaseSysCache(classTuple);
    1471             : 
    1472         514 :     return newIndexId;
    1473             : }
    1474             : 
    1475             : /*
    1476             :  * index_concurrently_build
    1477             :  *
    1478             :  * Build index for a concurrent operation.  Low-level locks are taken when
    1479             :  * this operation is performed to prevent only schema changes, but they need
    1480             :  * to be kept until the end of the transaction performing this operation.
    1481             :  * 'indexOid' refers to an index relation OID already created as part of
    1482             :  * previous processing, and 'heapOid' refers to its parent heap relation.
    1483             :  */
    1484             : void
    1485         738 : index_concurrently_build(Oid heapRelationId,
    1486             :                          Oid indexRelationId)
    1487             : {
    1488             :     Relation    heapRel;
    1489             :     Oid         save_userid;
    1490             :     int         save_sec_context;
    1491             :     int         save_nestlevel;
    1492             :     Relation    indexRelation;
    1493             :     IndexInfo  *indexInfo;
    1494             : 
    1495             :     /* This had better make sure that a snapshot is active */
    1496             :     Assert(ActiveSnapshotSet());
    1497             : 
    1498             :     /* Open and lock the parent heap relation */
    1499         738 :     heapRel = table_open(heapRelationId, ShareUpdateExclusiveLock);
    1500             : 
    1501             :     /*
    1502             :      * Switch to the table owner's userid, so that any index functions are run
    1503             :      * as that user.  Also lock down security-restricted operations and
    1504             :      * arrange to make GUC variable changes local to this command.
    1505             :      */
    1506         738 :     GetUserIdAndSecContext(&save_userid, &save_sec_context);
    1507         738 :     SetUserIdAndSecContext(heapRel->rd_rel->relowner,
    1508             :                            save_sec_context | SECURITY_RESTRICTED_OPERATION);
    1509         738 :     save_nestlevel = NewGUCNestLevel();
    1510         738 :     RestrictSearchPath();
    1511             : 
    1512         738 :     indexRelation = index_open(indexRelationId, RowExclusiveLock);
    1513             : 
    1514             :     /*
    1515             :      * We have to re-build the IndexInfo struct, since it was lost in the
    1516             :      * commit of the transaction where this concurrent index was created at
    1517             :      * the catalog level.
    1518             :      */
    1519         738 :     indexInfo = BuildIndexInfo(indexRelation);
    1520             :     Assert(!indexInfo->ii_ReadyForInserts);
    1521         738 :     indexInfo->ii_Concurrent = true;
    1522         738 :     indexInfo->ii_BrokenHotChain = false;
    1523             : 
    1524             :     /* Now build the index */
    1525         738 :     index_build(heapRel, indexRelation, indexInfo, false, true);
    1526             : 
    1527             :     /* Roll back any GUC changes executed by index functions */
    1528         714 :     AtEOXact_GUC(false, save_nestlevel);
    1529             : 
    1530             :     /* Restore userid and security context */
    1531         714 :     SetUserIdAndSecContext(save_userid, save_sec_context);
    1532             : 
    1533             :     /* Close both the relations, but keep the locks */
    1534         714 :     table_close(heapRel, NoLock);
    1535         714 :     index_close(indexRelation, NoLock);
    1536             : 
    1537             :     /*
    1538             :      * Update the pg_index row to mark the index as ready for inserts. Once we
    1539             :      * commit this transaction, any new transactions that open the table must
    1540             :      * insert new entries into the index for insertions and non-HOT updates.
    1541             :      */
    1542         714 :     index_set_state_flags(indexRelationId, INDEX_CREATE_SET_READY);
    1543         714 : }
    1544             : 
    1545             : /*
    1546             :  * index_concurrently_swap
    1547             :  *
    1548             :  * Swap name, dependencies, and constraints of the old index over to the new
    1549             :  * index, while marking the old index as invalid and the new as valid.
    1550             :  */
    1551             : void
    1552         508 : index_concurrently_swap(Oid newIndexId, Oid oldIndexId, const char *oldName)
    1553             : {
    1554             :     Relation    pg_class,
    1555             :                 pg_index,
    1556             :                 pg_constraint,
    1557             :                 pg_trigger;
    1558             :     Relation    oldClassRel,
    1559             :                 newClassRel;
    1560             :     HeapTuple   oldClassTuple,
    1561             :                 newClassTuple;
    1562             :     Form_pg_class oldClassForm,
    1563             :                 newClassForm;
    1564             :     HeapTuple   oldIndexTuple,
    1565             :                 newIndexTuple;
    1566             :     Form_pg_index oldIndexForm,
    1567             :                 newIndexForm;
    1568             :     bool        isPartition;
    1569             :     Oid         indexConstraintOid;
    1570         508 :     List       *constraintOids = NIL;
    1571             :     ListCell   *lc;
    1572             : 
    1573             :     /*
    1574             :      * Take a necessary lock on the old and new index before swapping them.
    1575             :      */
    1576         508 :     oldClassRel = relation_open(oldIndexId, ShareUpdateExclusiveLock);
    1577         508 :     newClassRel = relation_open(newIndexId, ShareUpdateExclusiveLock);
    1578             : 
    1579             :     /* Now swap names and dependencies of those indexes */
    1580         508 :     pg_class = table_open(RelationRelationId, RowExclusiveLock);
    1581             : 
    1582         508 :     oldClassTuple = SearchSysCacheCopy1(RELOID,
    1583             :                                         ObjectIdGetDatum(oldIndexId));
    1584         508 :     if (!HeapTupleIsValid(oldClassTuple))
    1585           0 :         elog(ERROR, "could not find tuple for relation %u", oldIndexId);
    1586         508 :     newClassTuple = SearchSysCacheCopy1(RELOID,
    1587             :                                         ObjectIdGetDatum(newIndexId));
    1588         508 :     if (!HeapTupleIsValid(newClassTuple))
    1589           0 :         elog(ERROR, "could not find tuple for relation %u", newIndexId);
    1590             : 
    1591         508 :     oldClassForm = (Form_pg_class) GETSTRUCT(oldClassTuple);
    1592         508 :     newClassForm = (Form_pg_class) GETSTRUCT(newClassTuple);
    1593             : 
    1594             :     /* Swap the names */
    1595         508 :     namestrcpy(&newClassForm->relname, NameStr(oldClassForm->relname));
    1596         508 :     namestrcpy(&oldClassForm->relname, oldName);
    1597             : 
    1598             :     /* Swap the partition flags to track inheritance properly */
    1599         508 :     isPartition = newClassForm->relispartition;
    1600         508 :     newClassForm->relispartition = oldClassForm->relispartition;
    1601         508 :     oldClassForm->relispartition = isPartition;
    1602             : 
    1603         508 :     CatalogTupleUpdate(pg_class, &oldClassTuple->t_self, oldClassTuple);
    1604         508 :     CatalogTupleUpdate(pg_class, &newClassTuple->t_self, newClassTuple);
    1605             : 
    1606         508 :     heap_freetuple(oldClassTuple);
    1607         508 :     heap_freetuple(newClassTuple);
    1608             : 
    1609             :     /* Now swap index info */
    1610         508 :     pg_index = table_open(IndexRelationId, RowExclusiveLock);
    1611             : 
    1612         508 :     oldIndexTuple = SearchSysCacheCopy1(INDEXRELID,
    1613             :                                         ObjectIdGetDatum(oldIndexId));
    1614         508 :     if (!HeapTupleIsValid(oldIndexTuple))
    1615           0 :         elog(ERROR, "could not find tuple for relation %u", oldIndexId);
    1616         508 :     newIndexTuple = SearchSysCacheCopy1(INDEXRELID,
    1617             :                                         ObjectIdGetDatum(newIndexId));
    1618         508 :     if (!HeapTupleIsValid(newIndexTuple))
    1619           0 :         elog(ERROR, "could not find tuple for relation %u", newIndexId);
    1620             : 
    1621         508 :     oldIndexForm = (Form_pg_index) GETSTRUCT(oldIndexTuple);
    1622         508 :     newIndexForm = (Form_pg_index) GETSTRUCT(newIndexTuple);
    1623             : 
    1624             :     /*
    1625             :      * Copy constraint flags from the old index. This is safe because the old
    1626             :      * index guaranteed uniqueness.
    1627             :      */
    1628         508 :     newIndexForm->indisprimary = oldIndexForm->indisprimary;
    1629         508 :     oldIndexForm->indisprimary = false;
    1630         508 :     newIndexForm->indisexclusion = oldIndexForm->indisexclusion;
    1631         508 :     oldIndexForm->indisexclusion = false;
    1632         508 :     newIndexForm->indimmediate = oldIndexForm->indimmediate;
    1633         508 :     oldIndexForm->indimmediate = true;
    1634             : 
    1635             :     /* Preserve indisreplident in the new index */
    1636         508 :     newIndexForm->indisreplident = oldIndexForm->indisreplident;
    1637             : 
    1638             :     /* Preserve indisclustered in the new index */
    1639         508 :     newIndexForm->indisclustered = oldIndexForm->indisclustered;
    1640             : 
    1641             :     /*
    1642             :      * Mark the new index as valid, and the old index as invalid similarly to
    1643             :      * what index_set_state_flags() does.
    1644             :      */
    1645         508 :     newIndexForm->indisvalid = true;
    1646         508 :     oldIndexForm->indisvalid = false;
    1647         508 :     oldIndexForm->indisclustered = false;
    1648         508 :     oldIndexForm->indisreplident = false;
    1649             : 
    1650         508 :     CatalogTupleUpdate(pg_index, &oldIndexTuple->t_self, oldIndexTuple);
    1651         508 :     CatalogTupleUpdate(pg_index, &newIndexTuple->t_self, newIndexTuple);
    1652             : 
    1653         508 :     heap_freetuple(oldIndexTuple);
    1654         508 :     heap_freetuple(newIndexTuple);
    1655             : 
    1656             :     /*
    1657             :      * Move constraints and triggers over to the new index
    1658             :      */
    1659             : 
    1660         508 :     constraintOids = get_index_ref_constraints(oldIndexId);
    1661             : 
    1662         508 :     indexConstraintOid = get_index_constraint(oldIndexId);
    1663             : 
    1664         508 :     if (OidIsValid(indexConstraintOid))
    1665          50 :         constraintOids = lappend_oid(constraintOids, indexConstraintOid);
    1666             : 
    1667         508 :     pg_constraint = table_open(ConstraintRelationId, RowExclusiveLock);
    1668         508 :     pg_trigger = table_open(TriggerRelationId, RowExclusiveLock);
    1669             : 
    1670         576 :     foreach(lc, constraintOids)
    1671             :     {
    1672             :         HeapTuple   constraintTuple,
    1673             :                     triggerTuple;
    1674             :         Form_pg_constraint conForm;
    1675             :         ScanKeyData key[1];
    1676             :         SysScanDesc scan;
    1677          68 :         Oid         constraintOid = lfirst_oid(lc);
    1678             : 
    1679             :         /* Move the constraint from the old to the new index */
    1680          68 :         constraintTuple = SearchSysCacheCopy1(CONSTROID,
    1681             :                                               ObjectIdGetDatum(constraintOid));
    1682          68 :         if (!HeapTupleIsValid(constraintTuple))
    1683           0 :             elog(ERROR, "could not find tuple for constraint %u", constraintOid);
    1684             : 
    1685          68 :         conForm = ((Form_pg_constraint) GETSTRUCT(constraintTuple));
    1686             : 
    1687          68 :         if (conForm->conindid == oldIndexId)
    1688             :         {
    1689          68 :             conForm->conindid = newIndexId;
    1690             : 
    1691          68 :             CatalogTupleUpdate(pg_constraint, &constraintTuple->t_self, constraintTuple);
    1692             :         }
    1693             : 
    1694          68 :         heap_freetuple(constraintTuple);
    1695             : 
    1696             :         /* Search for trigger records */
    1697          68 :         ScanKeyInit(&key[0],
    1698             :                     Anum_pg_trigger_tgconstraint,
    1699             :                     BTEqualStrategyNumber, F_OIDEQ,
    1700             :                     ObjectIdGetDatum(constraintOid));
    1701             : 
    1702          68 :         scan = systable_beginscan(pg_trigger, TriggerConstraintIndexId, true,
    1703             :                                   NULL, 1, key);
    1704             : 
    1705         128 :         while (HeapTupleIsValid((triggerTuple = systable_getnext(scan))))
    1706             :         {
    1707          60 :             Form_pg_trigger tgForm = (Form_pg_trigger) GETSTRUCT(triggerTuple);
    1708             : 
    1709          60 :             if (tgForm->tgconstrindid != oldIndexId)
    1710           0 :                 continue;
    1711             : 
    1712             :             /* Make a modifiable copy */
    1713          60 :             triggerTuple = heap_copytuple(triggerTuple);
    1714          60 :             tgForm = (Form_pg_trigger) GETSTRUCT(triggerTuple);
    1715             : 
    1716          60 :             tgForm->tgconstrindid = newIndexId;
    1717             : 
    1718          60 :             CatalogTupleUpdate(pg_trigger, &triggerTuple->t_self, triggerTuple);
    1719             : 
    1720          60 :             heap_freetuple(triggerTuple);
    1721             :         }
    1722             : 
    1723          68 :         systable_endscan(scan);
    1724             :     }
    1725             : 
    1726             :     /*
    1727             :      * Move comment if any
    1728             :      */
    1729             :     {
    1730             :         Relation    description;
    1731             :         ScanKeyData skey[3];
    1732             :         SysScanDesc sd;
    1733             :         HeapTuple   tuple;
    1734         508 :         Datum       values[Natts_pg_description] = {0};
    1735         508 :         bool        nulls[Natts_pg_description] = {0};
    1736         508 :         bool        replaces[Natts_pg_description] = {0};
    1737             : 
    1738         508 :         values[Anum_pg_description_objoid - 1] = ObjectIdGetDatum(newIndexId);
    1739         508 :         replaces[Anum_pg_description_objoid - 1] = true;
    1740             : 
    1741         508 :         ScanKeyInit(&skey[0],
    1742             :                     Anum_pg_description_objoid,
    1743             :                     BTEqualStrategyNumber, F_OIDEQ,
    1744             :                     ObjectIdGetDatum(oldIndexId));
    1745         508 :         ScanKeyInit(&skey[1],
    1746             :                     Anum_pg_description_classoid,
    1747             :                     BTEqualStrategyNumber, F_OIDEQ,
    1748             :                     ObjectIdGetDatum(RelationRelationId));
    1749         508 :         ScanKeyInit(&skey[2],
    1750             :                     Anum_pg_description_objsubid,
    1751             :                     BTEqualStrategyNumber, F_INT4EQ,
    1752             :                     Int32GetDatum(0));
    1753             : 
    1754         508 :         description = table_open(DescriptionRelationId, RowExclusiveLock);
    1755             : 
    1756         508 :         sd = systable_beginscan(description, DescriptionObjIndexId, true,
    1757             :                                 NULL, 3, skey);
    1758             : 
    1759         508 :         while ((tuple = systable_getnext(sd)) != NULL)
    1760             :         {
    1761           6 :             tuple = heap_modify_tuple(tuple, RelationGetDescr(description),
    1762             :                                       values, nulls, replaces);
    1763           6 :             CatalogTupleUpdate(description, &tuple->t_self, tuple);
    1764             : 
    1765           6 :             break;              /* Assume there can be only one match */
    1766             :         }
    1767             : 
    1768         508 :         systable_endscan(sd);
    1769         508 :         table_close(description, NoLock);
    1770             :     }
    1771             : 
    1772             :     /*
    1773             :      * Swap inheritance relationship with parent index
    1774             :      */
    1775         508 :     if (get_rel_relispartition(oldIndexId))
    1776             :     {
    1777          84 :         List       *ancestors = get_partition_ancestors(oldIndexId);
    1778          84 :         Oid         parentIndexRelid = linitial_oid(ancestors);
    1779             : 
    1780          84 :         DeleteInheritsTuple(oldIndexId, parentIndexRelid, false, NULL);
    1781          84 :         StoreSingleInheritance(newIndexId, parentIndexRelid, 1);
    1782             : 
    1783          84 :         list_free(ancestors);
    1784             :     }
    1785             : 
    1786             :     /*
    1787             :      * Swap all dependencies of and on the old index to the new one, and
    1788             :      * vice-versa.  Note that a call to CommandCounterIncrement() would cause
    1789             :      * duplicate entries in pg_depend, so this should not be done.
    1790             :      */
    1791         508 :     changeDependenciesOf(RelationRelationId, newIndexId, oldIndexId);
    1792         508 :     changeDependenciesOn(RelationRelationId, newIndexId, oldIndexId);
    1793             : 
    1794         508 :     changeDependenciesOf(RelationRelationId, oldIndexId, newIndexId);
    1795         508 :     changeDependenciesOn(RelationRelationId, oldIndexId, newIndexId);
    1796             : 
    1797             :     /* copy over statistics from old to new index */
    1798         508 :     pgstat_copy_relation_stats(newClassRel, oldClassRel);
    1799             : 
    1800             :     /* Copy data of pg_statistic from the old index to the new one */
    1801         508 :     CopyStatistics(oldIndexId, newIndexId);
    1802             : 
    1803             :     /* Close relations */
    1804         508 :     table_close(pg_class, RowExclusiveLock);
    1805         508 :     table_close(pg_index, RowExclusiveLock);
    1806         508 :     table_close(pg_constraint, RowExclusiveLock);
    1807         508 :     table_close(pg_trigger, RowExclusiveLock);
    1808             : 
    1809             :     /* The lock taken previously is not released until the end of transaction */
    1810         508 :     relation_close(oldClassRel, NoLock);
    1811         508 :     relation_close(newClassRel, NoLock);
    1812         508 : }
    1813             : 
    1814             : /*
    1815             :  * index_concurrently_set_dead
    1816             :  *
    1817             :  * Perform the last invalidation stage of DROP INDEX CONCURRENTLY or REINDEX
    1818             :  * CONCURRENTLY before actually dropping the index.  After calling this
    1819             :  * function, the index is seen by all the backends as dead.  Low-level locks
    1820             :  * taken here are kept until the end of the transaction calling this function.
    1821             :  */
    1822             : void
    1823         686 : index_concurrently_set_dead(Oid heapId, Oid indexId)
    1824             : {
    1825             :     Relation    userHeapRelation;
    1826             :     Relation    userIndexRelation;
    1827             : 
    1828             :     /*
    1829             :      * No more predicate locks will be acquired on this index, and we're about
    1830             :      * to stop doing inserts into the index which could show conflicts with
    1831             :      * existing predicate locks, so now is the time to move them to the heap
    1832             :      * relation.
    1833             :      */
    1834         686 :     userHeapRelation = table_open(heapId, ShareUpdateExclusiveLock);
    1835         686 :     userIndexRelation = index_open(indexId, ShareUpdateExclusiveLock);
    1836         686 :     TransferPredicateLocksToHeapRelation(userIndexRelation);
    1837             : 
    1838             :     /*
    1839             :      * Now we are sure that nobody uses the index for queries; they just might
    1840             :      * have it open for updating it.  So now we can unset indisready and
    1841             :      * indislive, then wait till nobody could be using it at all anymore.
    1842             :      */
    1843         686 :     index_set_state_flags(indexId, INDEX_DROP_SET_DEAD);
    1844             : 
    1845             :     /*
    1846             :      * Invalidate the relcache for the table, so that after this commit all
    1847             :      * sessions will refresh the table's index list.  Forgetting just the
    1848             :      * index's relcache entry is not enough.
    1849             :      */
    1850         686 :     CacheInvalidateRelcache(userHeapRelation);
    1851             : 
    1852             :     /*
    1853             :      * Close the relations again, though still holding session lock.
    1854             :      */
    1855         686 :     table_close(userHeapRelation, NoLock);
    1856         686 :     index_close(userIndexRelation, NoLock);
    1857         686 : }
    1858             : 
    1859             : /*
    1860             :  * index_constraint_create
    1861             :  *
    1862             :  * Set up a constraint associated with an index.  Return the new constraint's
    1863             :  * address.
    1864             :  *
    1865             :  * heapRelation: table owning the index (must be suitably locked by caller)
    1866             :  * indexRelationId: OID of the index
    1867             :  * parentConstraintId: if constraint is on a partition, the OID of the
    1868             :  *      constraint in the parent.
    1869             :  * indexInfo: same info executor uses to insert into the index
    1870             :  * constraintName: what it say (generally, should match name of index)
    1871             :  * constraintType: one of CONSTRAINT_PRIMARY, CONSTRAINT_UNIQUE, or
    1872             :  *      CONSTRAINT_EXCLUSION
    1873             :  * flags: bitmask that can include any combination of these bits:
    1874             :  *      INDEX_CONSTR_CREATE_MARK_AS_PRIMARY: index is a PRIMARY KEY
    1875             :  *      INDEX_CONSTR_CREATE_DEFERRABLE: constraint is DEFERRABLE
    1876             :  *      INDEX_CONSTR_CREATE_INIT_DEFERRED: constraint is INITIALLY DEFERRED
    1877             :  *      INDEX_CONSTR_CREATE_UPDATE_INDEX: update the pg_index row
    1878             :  *      INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS: remove existing dependencies
    1879             :  *          of index on table's columns
    1880             :  *      INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS: constraint uses WITHOUT OVERLAPS
    1881             :  * allow_system_table_mods: allow table to be a system catalog
    1882             :  * is_internal: index is constructed due to internal process
    1883             :  */
    1884             : ObjectAddress
    1885       19374 : index_constraint_create(Relation heapRelation,
    1886             :                         Oid indexRelationId,
    1887             :                         Oid parentConstraintId,
    1888             :                         const IndexInfo *indexInfo,
    1889             :                         const char *constraintName,
    1890             :                         char constraintType,
    1891             :                         bits16 constr_flags,
    1892             :                         bool allow_system_table_mods,
    1893             :                         bool is_internal)
    1894             : {
    1895       19374 :     Oid         namespaceId = RelationGetNamespace(heapRelation);
    1896             :     ObjectAddress myself,
    1897             :                 idxaddr;
    1898             :     Oid         conOid;
    1899             :     bool        deferrable;
    1900             :     bool        initdeferred;
    1901             :     bool        mark_as_primary;
    1902             :     bool        islocal;
    1903             :     bool        noinherit;
    1904             :     bool        is_without_overlaps;
    1905             :     int16       inhcount;
    1906             : 
    1907       19374 :     deferrable = (constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) != 0;
    1908       19374 :     initdeferred = (constr_flags & INDEX_CONSTR_CREATE_INIT_DEFERRED) != 0;
    1909       19374 :     mark_as_primary = (constr_flags & INDEX_CONSTR_CREATE_MARK_AS_PRIMARY) != 0;
    1910       19374 :     is_without_overlaps = (constr_flags & INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS) != 0;
    1911             : 
    1912             :     /* constraint creation support doesn't work while bootstrapping */
    1913             :     Assert(!IsBootstrapProcessingMode());
    1914             : 
    1915             :     /* enforce system-table restriction */
    1916       29168 :     if (!allow_system_table_mods &&
    1917        9794 :         IsSystemRelation(heapRelation) &&
    1918           0 :         IsNormalProcessingMode())
    1919           0 :         ereport(ERROR,
    1920             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1921             :                  errmsg("user-defined indexes on system catalog tables are not supported")));
    1922             : 
    1923             :     /* primary/unique constraints shouldn't have any expressions */
    1924       19374 :     if (indexInfo->ii_Expressions &&
    1925             :         constraintType != CONSTRAINT_EXCLUSION)
    1926           0 :         elog(ERROR, "constraints cannot have index expressions");
    1927             : 
    1928             :     /*
    1929             :      * If we're manufacturing a constraint for a pre-existing index, we need
    1930             :      * to get rid of the existing auto dependencies for the index (the ones
    1931             :      * that index_create() would have made instead of calling this function).
    1932             :      *
    1933             :      * Note: this code would not necessarily do the right thing if the index
    1934             :      * has any expressions or predicate, but we'd never be turning such an
    1935             :      * index into a UNIQUE or PRIMARY KEY constraint.
    1936             :      */
    1937       19374 :     if (constr_flags & INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS)
    1938        9528 :         deleteDependencyRecordsForClass(RelationRelationId, indexRelationId,
    1939             :                                         RelationRelationId, DEPENDENCY_AUTO);
    1940             : 
    1941       19374 :     if (OidIsValid(parentConstraintId))
    1942             :     {
    1943        1308 :         islocal = false;
    1944        1308 :         inhcount = 1;
    1945        1308 :         noinherit = false;
    1946             :     }
    1947             :     else
    1948             :     {
    1949       18066 :         islocal = true;
    1950       18066 :         inhcount = 0;
    1951       18066 :         noinherit = true;
    1952             :     }
    1953             : 
    1954             :     /*
    1955             :      * Construct a pg_constraint entry.
    1956             :      */
    1957       19374 :     conOid = CreateConstraintEntry(constraintName,
    1958             :                                    namespaceId,
    1959             :                                    constraintType,
    1960             :                                    deferrable,
    1961             :                                    initdeferred,
    1962             :                                    true,    /* Is Enforced */
    1963             :                                    true,
    1964             :                                    parentConstraintId,
    1965             :                                    RelationGetRelid(heapRelation),
    1966       19374 :                                    indexInfo->ii_IndexAttrNumbers,
    1967             :                                    indexInfo->ii_NumIndexKeyAttrs,
    1968             :                                    indexInfo->ii_NumIndexAttrs,
    1969             :                                    InvalidOid,  /* no domain */
    1970             :                                    indexRelationId, /* index OID */
    1971             :                                    InvalidOid,  /* no foreign key */
    1972             :                                    NULL,
    1973             :                                    NULL,
    1974             :                                    NULL,
    1975             :                                    NULL,
    1976             :                                    0,
    1977             :                                    ' ',
    1978             :                                    ' ',
    1979             :                                    NULL,
    1980             :                                    0,
    1981             :                                    ' ',
    1982       19374 :                                    indexInfo->ii_ExclusionOps,
    1983             :                                    NULL,    /* no check constraint */
    1984             :                                    NULL,
    1985             :                                    islocal,
    1986             :                                    inhcount,
    1987             :                                    noinherit,
    1988             :                                    is_without_overlaps,
    1989             :                                    is_internal);
    1990             : 
    1991             :     /*
    1992             :      * Register the index as internally dependent on the constraint.
    1993             :      *
    1994             :      * Note that the constraint has a dependency on the table, so we don't
    1995             :      * need (or want) any direct dependency from the index to the table.
    1996             :      */
    1997       19374 :     ObjectAddressSet(myself, ConstraintRelationId, conOid);
    1998       19374 :     ObjectAddressSet(idxaddr, RelationRelationId, indexRelationId);
    1999       19374 :     recordDependencyOn(&idxaddr, &myself, DEPENDENCY_INTERNAL);
    2000             : 
    2001             :     /*
    2002             :      * Also, if this is a constraint on a partition, give it partition-type
    2003             :      * dependencies on the parent constraint as well as the table.
    2004             :      */
    2005       19374 :     if (OidIsValid(parentConstraintId))
    2006             :     {
    2007             :         ObjectAddress referenced;
    2008             : 
    2009        1308 :         ObjectAddressSet(referenced, ConstraintRelationId, parentConstraintId);
    2010        1308 :         recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
    2011        1308 :         ObjectAddressSet(referenced, RelationRelationId,
    2012             :                          RelationGetRelid(heapRelation));
    2013        1308 :         recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
    2014             :     }
    2015             : 
    2016             :     /*
    2017             :      * If the constraint is deferrable, create the deferred uniqueness
    2018             :      * checking trigger.  (The trigger will be given an internal dependency on
    2019             :      * the constraint by CreateTrigger.)
    2020             :      */
    2021       19374 :     if (deferrable)
    2022             :     {
    2023         132 :         CreateTrigStmt *trigger = makeNode(CreateTrigStmt);
    2024             : 
    2025         132 :         trigger->replace = false;
    2026         132 :         trigger->isconstraint = true;
    2027         132 :         trigger->trigname = (constraintType == CONSTRAINT_PRIMARY) ?
    2028         132 :             "PK_ConstraintTrigger" :
    2029             :             "Unique_ConstraintTrigger";
    2030         132 :         trigger->relation = NULL;
    2031         132 :         trigger->funcname = SystemFuncName("unique_key_recheck");
    2032         132 :         trigger->args = NIL;
    2033         132 :         trigger->row = true;
    2034         132 :         trigger->timing = TRIGGER_TYPE_AFTER;
    2035         132 :         trigger->events = TRIGGER_TYPE_INSERT | TRIGGER_TYPE_UPDATE;
    2036         132 :         trigger->columns = NIL;
    2037         132 :         trigger->whenClause = NULL;
    2038         132 :         trigger->transitionRels = NIL;
    2039         132 :         trigger->deferrable = true;
    2040         132 :         trigger->initdeferred = initdeferred;
    2041         132 :         trigger->constrrel = NULL;
    2042             : 
    2043         132 :         (void) CreateTrigger(trigger, NULL, RelationGetRelid(heapRelation),
    2044             :                              InvalidOid, conOid, indexRelationId, InvalidOid,
    2045             :                              InvalidOid, NULL, true, false);
    2046             :     }
    2047             : 
    2048             :     /*
    2049             :      * If needed, mark the index as primary and/or deferred in pg_index.
    2050             :      *
    2051             :      * Note: When making an existing index into a constraint, caller must have
    2052             :      * a table lock that prevents concurrent table updates; otherwise, there
    2053             :      * is a risk that concurrent readers of the table will miss seeing this
    2054             :      * index at all.
    2055             :      */
    2056       19374 :     if ((constr_flags & INDEX_CONSTR_CREATE_UPDATE_INDEX) &&
    2057        4148 :         (mark_as_primary || deferrable))
    2058             :     {
    2059             :         Relation    pg_index;
    2060             :         HeapTuple   indexTuple;
    2061             :         Form_pg_index indexForm;
    2062        5380 :         bool        dirty = false;
    2063        5380 :         bool        marked_as_primary = false;
    2064             : 
    2065        5380 :         pg_index = table_open(IndexRelationId, RowExclusiveLock);
    2066             : 
    2067        5380 :         indexTuple = SearchSysCacheCopy1(INDEXRELID,
    2068             :                                          ObjectIdGetDatum(indexRelationId));
    2069        5380 :         if (!HeapTupleIsValid(indexTuple))
    2070           0 :             elog(ERROR, "cache lookup failed for index %u", indexRelationId);
    2071        5380 :         indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
    2072             : 
    2073        5380 :         if (mark_as_primary && !indexForm->indisprimary)
    2074             :         {
    2075        5380 :             indexForm->indisprimary = true;
    2076        5380 :             dirty = true;
    2077        5380 :             marked_as_primary = true;
    2078             :         }
    2079             : 
    2080        5380 :         if (deferrable && indexForm->indimmediate)
    2081             :         {
    2082           0 :             indexForm->indimmediate = false;
    2083           0 :             dirty = true;
    2084             :         }
    2085             : 
    2086        5380 :         if (dirty)
    2087             :         {
    2088        5380 :             CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
    2089             : 
    2090             :             /*
    2091             :              * When we mark an existing index as primary, force a relcache
    2092             :              * flush on its parent table, so that all sessions will become
    2093             :              * aware that the table now has a primary key.  This is important
    2094             :              * because it affects some replication behaviors.
    2095             :              */
    2096        5380 :             if (marked_as_primary)
    2097        5380 :                 CacheInvalidateRelcache(heapRelation);
    2098             : 
    2099        5380 :             InvokeObjectPostAlterHookArg(IndexRelationId, indexRelationId, 0,
    2100             :                                          InvalidOid, is_internal);
    2101             :         }
    2102             : 
    2103        5380 :         heap_freetuple(indexTuple);
    2104        5380 :         table_close(pg_index, RowExclusiveLock);
    2105             :     }
    2106             : 
    2107       19374 :     return myself;
    2108             : }
    2109             : 
    2110             : /*
    2111             :  *      index_drop
    2112             :  *
    2113             :  * NOTE: this routine should now only be called through performDeletion(),
    2114             :  * else associated dependencies won't be cleaned up.
    2115             :  *
    2116             :  * If concurrent is true, do a DROP INDEX CONCURRENTLY.  If concurrent is
    2117             :  * false but concurrent_lock_mode is true, then do a normal DROP INDEX but
    2118             :  * take a lock for CONCURRENTLY processing.  That is used as part of REINDEX
    2119             :  * CONCURRENTLY.
    2120             :  */
    2121             : void
    2122       23622 : index_drop(Oid indexId, bool concurrent, bool concurrent_lock_mode)
    2123             : {
    2124             :     Oid         heapId;
    2125             :     Relation    userHeapRelation;
    2126             :     Relation    userIndexRelation;
    2127             :     Relation    indexRelation;
    2128             :     HeapTuple   tuple;
    2129             :     bool        hasexprs;
    2130             :     LockRelId   heaprelid,
    2131             :                 indexrelid;
    2132             :     LOCKTAG     heaplocktag;
    2133             :     LOCKMODE    lockmode;
    2134             : 
    2135             :     /*
    2136             :      * A temporary relation uses a non-concurrent DROP.  Other backends can't
    2137             :      * access a temporary relation, so there's no harm in grabbing a stronger
    2138             :      * lock (see comments in RemoveRelations), and a non-concurrent DROP is
    2139             :      * more efficient.
    2140             :      */
    2141             :     Assert(get_rel_persistence(indexId) != RELPERSISTENCE_TEMP ||
    2142             :            (!concurrent && !concurrent_lock_mode));
    2143             : 
    2144             :     /*
    2145             :      * To drop an index safely, we must grab exclusive lock on its parent
    2146             :      * table.  Exclusive lock on the index alone is insufficient because
    2147             :      * another backend might be about to execute a query on the parent table.
    2148             :      * If it relies on a previously cached list of index OIDs, then it could
    2149             :      * attempt to access the just-dropped index.  We must therefore take a
    2150             :      * table lock strong enough to prevent all queries on the table from
    2151             :      * proceeding until we commit and send out a shared-cache-inval notice
    2152             :      * that will make them update their index lists.
    2153             :      *
    2154             :      * In the concurrent case we avoid this requirement by disabling index use
    2155             :      * in multiple steps and waiting out any transactions that might be using
    2156             :      * the index, so we don't need exclusive lock on the parent table. Instead
    2157             :      * we take ShareUpdateExclusiveLock, to ensure that two sessions aren't
    2158             :      * doing CREATE/DROP INDEX CONCURRENTLY on the same index.  (We will get
    2159             :      * AccessExclusiveLock on the index below, once we're sure nobody else is
    2160             :      * using it.)
    2161             :      */
    2162       23622 :     heapId = IndexGetRelation(indexId, false);
    2163       23622 :     lockmode = (concurrent || concurrent_lock_mode) ? ShareUpdateExclusiveLock : AccessExclusiveLock;
    2164       23622 :     userHeapRelation = table_open(heapId, lockmode);
    2165       23622 :     userIndexRelation = index_open(indexId, lockmode);
    2166             : 
    2167             :     /*
    2168             :      * We might still have open queries using it in our own session, which the
    2169             :      * above locking won't prevent, so test explicitly.
    2170             :      */
    2171       23622 :     CheckTableNotInUse(userIndexRelation, "DROP INDEX");
    2172             : 
    2173             :     /*
    2174             :      * Drop Index Concurrently is more or less the reverse process of Create
    2175             :      * Index Concurrently.
    2176             :      *
    2177             :      * First we unset indisvalid so queries starting afterwards don't use the
    2178             :      * index to answer queries anymore.  We have to keep indisready = true so
    2179             :      * transactions that are still scanning the index can continue to see
    2180             :      * valid index contents.  For instance, if they are using READ COMMITTED
    2181             :      * mode, and another transaction makes changes and commits, they need to
    2182             :      * see those new tuples in the index.
    2183             :      *
    2184             :      * After all transactions that could possibly have used the index for
    2185             :      * queries end, we can unset indisready and indislive, then wait till
    2186             :      * nobody could be touching it anymore.  (Note: we need indislive because
    2187             :      * this state must be distinct from the initial state during CREATE INDEX
    2188             :      * CONCURRENTLY, which has indislive true while indisready and indisvalid
    2189             :      * are false.  That's because in that state, transactions must examine the
    2190             :      * index for HOT-safety decisions, while in this state we don't want them
    2191             :      * to open it at all.)
    2192             :      *
    2193             :      * Since all predicate locks on the index are about to be made invalid, we
    2194             :      * must promote them to predicate locks on the heap.  In the
    2195             :      * non-concurrent case we can just do that now.  In the concurrent case
    2196             :      * it's a bit trickier.  The predicate locks must be moved when there are
    2197             :      * no index scans in progress on the index and no more can subsequently
    2198             :      * start, so that no new predicate locks can be made on the index.  Also,
    2199             :      * they must be moved before heap inserts stop maintaining the index, else
    2200             :      * the conflict with the predicate lock on the index gap could be missed
    2201             :      * before the lock on the heap relation is in place to detect a conflict
    2202             :      * based on the heap tuple insert.
    2203             :      */
    2204       23622 :     if (concurrent)
    2205             :     {
    2206             :         /*
    2207             :          * We must commit our transaction in order to make the first pg_index
    2208             :          * state update visible to other sessions.  If the DROP machinery has
    2209             :          * already performed any other actions (removal of other objects,
    2210             :          * pg_depend entries, etc), the commit would make those actions
    2211             :          * permanent, which would leave us with inconsistent catalog state if
    2212             :          * we fail partway through the following sequence.  Since DROP INDEX
    2213             :          * CONCURRENTLY is restricted to dropping just one index that has no
    2214             :          * dependencies, we should get here before anything's been done ---
    2215             :          * but let's check that to be sure.  We can verify that the current
    2216             :          * transaction has not executed any transactional updates by checking
    2217             :          * that no XID has been assigned.
    2218             :          */
    2219         178 :         if (GetTopTransactionIdIfAny() != InvalidTransactionId)
    2220           0 :             ereport(ERROR,
    2221             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2222             :                      errmsg("DROP INDEX CONCURRENTLY must be first action in transaction")));
    2223             : 
    2224             :         /*
    2225             :          * Mark index invalid by updating its pg_index entry
    2226             :          */
    2227         178 :         index_set_state_flags(indexId, INDEX_DROP_CLEAR_VALID);
    2228             : 
    2229             :         /*
    2230             :          * Invalidate the relcache for the table, so that after this commit
    2231             :          * all sessions will refresh any cached plans that might reference the
    2232             :          * index.
    2233             :          */
    2234         178 :         CacheInvalidateRelcache(userHeapRelation);
    2235             : 
    2236             :         /* save lockrelid and locktag for below, then close but keep locks */
    2237         178 :         heaprelid = userHeapRelation->rd_lockInfo.lockRelId;
    2238         178 :         SET_LOCKTAG_RELATION(heaplocktag, heaprelid.dbId, heaprelid.relId);
    2239         178 :         indexrelid = userIndexRelation->rd_lockInfo.lockRelId;
    2240             : 
    2241         178 :         table_close(userHeapRelation, NoLock);
    2242         178 :         index_close(userIndexRelation, NoLock);
    2243             : 
    2244             :         /*
    2245             :          * We must commit our current transaction so that the indisvalid
    2246             :          * update becomes visible to other transactions; then start another.
    2247             :          * Note that any previously-built data structures are lost in the
    2248             :          * commit.  The only data we keep past here are the relation IDs.
    2249             :          *
    2250             :          * Before committing, get a session-level lock on the table, to ensure
    2251             :          * that neither it nor the index can be dropped before we finish. This
    2252             :          * cannot block, even if someone else is waiting for access, because
    2253             :          * we already have the same lock within our transaction.
    2254             :          */
    2255         178 :         LockRelationIdForSession(&heaprelid, ShareUpdateExclusiveLock);
    2256         178 :         LockRelationIdForSession(&indexrelid, ShareUpdateExclusiveLock);
    2257             : 
    2258         178 :         PopActiveSnapshot();
    2259         178 :         CommitTransactionCommand();
    2260         178 :         StartTransactionCommand();
    2261             : 
    2262             :         /*
    2263             :          * Now we must wait until no running transaction could be using the
    2264             :          * index for a query.  Use AccessExclusiveLock here to check for
    2265             :          * running transactions that hold locks of any kind on the table. Note
    2266             :          * we do not need to worry about xacts that open the table for reading
    2267             :          * after this point; they will see the index as invalid when they open
    2268             :          * the relation.
    2269             :          *
    2270             :          * Note: the reason we use actual lock acquisition here, rather than
    2271             :          * just checking the ProcArray and sleeping, is that deadlock is
    2272             :          * possible if one of the transactions in question is blocked trying
    2273             :          * to acquire an exclusive lock on our table.  The lock code will
    2274             :          * detect deadlock and error out properly.
    2275             :          *
    2276             :          * Note: we report progress through WaitForLockers() unconditionally
    2277             :          * here, even though it will only be used when we're called by REINDEX
    2278             :          * CONCURRENTLY and not when called by DROP INDEX CONCURRENTLY.
    2279             :          */
    2280         178 :         WaitForLockers(heaplocktag, AccessExclusiveLock, true);
    2281             : 
    2282             :         /*
    2283             :          * Updating pg_index might involve TOAST table access, so ensure we
    2284             :          * have a valid snapshot.
    2285             :          */
    2286         178 :         PushActiveSnapshot(GetTransactionSnapshot());
    2287             : 
    2288             :         /* Finish invalidation of index and mark it as dead */
    2289         178 :         index_concurrently_set_dead(heapId, indexId);
    2290             : 
    2291         178 :         PopActiveSnapshot();
    2292             : 
    2293             :         /*
    2294             :          * Again, commit the transaction to make the pg_index update visible
    2295             :          * to other sessions.
    2296             :          */
    2297         178 :         CommitTransactionCommand();
    2298         178 :         StartTransactionCommand();
    2299             : 
    2300             :         /*
    2301             :          * Wait till every transaction that saw the old index state has
    2302             :          * finished.  See above about progress reporting.
    2303             :          */
    2304         178 :         WaitForLockers(heaplocktag, AccessExclusiveLock, true);
    2305             : 
    2306             :         /*
    2307             :          * Re-open relations to allow us to complete our actions.
    2308             :          *
    2309             :          * At this point, nothing should be accessing the index, but lets
    2310             :          * leave nothing to chance and grab AccessExclusiveLock on the index
    2311             :          * before the physical deletion.
    2312             :          */
    2313         178 :         userHeapRelation = table_open(heapId, ShareUpdateExclusiveLock);
    2314         178 :         userIndexRelation = index_open(indexId, AccessExclusiveLock);
    2315             :     }
    2316             :     else
    2317             :     {
    2318             :         /* Not concurrent, so just transfer predicate locks and we're good */
    2319       23444 :         TransferPredicateLocksToHeapRelation(userIndexRelation);
    2320             :     }
    2321             : 
    2322             :     /*
    2323             :      * Schedule physical removal of the files (if any)
    2324             :      */
    2325       23622 :     if (RELKIND_HAS_STORAGE(userIndexRelation->rd_rel->relkind))
    2326       21980 :         RelationDropStorage(userIndexRelation);
    2327             : 
    2328             :     /* ensure that stats are dropped if transaction commits */
    2329       23622 :     pgstat_drop_relation(userIndexRelation);
    2330             : 
    2331             :     /*
    2332             :      * Close and flush the index's relcache entry, to ensure relcache doesn't
    2333             :      * try to rebuild it while we're deleting catalog entries. We keep the
    2334             :      * lock though.
    2335             :      */
    2336       23622 :     index_close(userIndexRelation, NoLock);
    2337             : 
    2338       23622 :     RelationForgetRelation(indexId);
    2339             : 
    2340             :     /*
    2341             :      * Updating pg_index might involve TOAST table access, so ensure we have a
    2342             :      * valid snapshot.
    2343             :      */
    2344       23622 :     PushActiveSnapshot(GetTransactionSnapshot());
    2345             : 
    2346             :     /*
    2347             :      * fix INDEX relation, and check for expressional index
    2348             :      */
    2349       23622 :     indexRelation = table_open(IndexRelationId, RowExclusiveLock);
    2350             : 
    2351       23622 :     tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
    2352       23622 :     if (!HeapTupleIsValid(tuple))
    2353           0 :         elog(ERROR, "cache lookup failed for index %u", indexId);
    2354             : 
    2355       23622 :     hasexprs = !heap_attisnull(tuple, Anum_pg_index_indexprs,
    2356       23622 :                                RelationGetDescr(indexRelation));
    2357             : 
    2358       23622 :     CatalogTupleDelete(indexRelation, &tuple->t_self);
    2359             : 
    2360       23622 :     ReleaseSysCache(tuple);
    2361       23622 :     table_close(indexRelation, RowExclusiveLock);
    2362             : 
    2363       23622 :     PopActiveSnapshot();
    2364             : 
    2365             :     /*
    2366             :      * if it has any expression columns, we might have stored statistics about
    2367             :      * them.
    2368             :      */
    2369       23622 :     if (hasexprs)
    2370         748 :         RemoveStatistics(indexId, 0);
    2371             : 
    2372             :     /*
    2373             :      * fix ATTRIBUTE relation
    2374             :      */
    2375       23622 :     DeleteAttributeTuples(indexId);
    2376             : 
    2377             :     /*
    2378             :      * fix RELATION relation
    2379             :      */
    2380       23622 :     DeleteRelationTuple(indexId);
    2381             : 
    2382             :     /*
    2383             :      * fix INHERITS relation
    2384             :      */
    2385       23622 :     DeleteInheritsTuple(indexId, InvalidOid, false, NULL);
    2386             : 
    2387             :     /*
    2388             :      * We are presently too lazy to attempt to compute the new correct value
    2389             :      * of relhasindex (the next VACUUM will fix it if necessary). So there is
    2390             :      * no need to update the pg_class tuple for the owning relation. But we
    2391             :      * must send out a shared-cache-inval notice on the owning relation to
    2392             :      * ensure other backends update their relcache lists of indexes.  (In the
    2393             :      * concurrent case, this is redundant but harmless.)
    2394             :      */
    2395       23622 :     CacheInvalidateRelcache(userHeapRelation);
    2396             : 
    2397             :     /*
    2398             :      * Close owning rel, but keep lock
    2399             :      */
    2400       23622 :     table_close(userHeapRelation, NoLock);
    2401             : 
    2402             :     /*
    2403             :      * Release the session locks before we go.
    2404             :      */
    2405       23622 :     if (concurrent)
    2406             :     {
    2407         178 :         UnlockRelationIdForSession(&heaprelid, ShareUpdateExclusiveLock);
    2408         178 :         UnlockRelationIdForSession(&indexrelid, ShareUpdateExclusiveLock);
    2409             :     }
    2410       23622 : }
    2411             : 
    2412             : /* ----------------------------------------------------------------
    2413             :  *                      index_build support
    2414             :  * ----------------------------------------------------------------
    2415             :  */
    2416             : 
    2417             : /* ----------------
    2418             :  *      BuildIndexInfo
    2419             :  *          Construct an IndexInfo record for an open index
    2420             :  *
    2421             :  * IndexInfo stores the information about the index that's needed by
    2422             :  * FormIndexDatum, which is used for both index_build() and later insertion
    2423             :  * of individual index tuples.  Normally we build an IndexInfo for an index
    2424             :  * just once per command, and then use it for (potentially) many tuples.
    2425             :  * ----------------
    2426             :  */
    2427             : IndexInfo *
    2428     3308252 : BuildIndexInfo(Relation index)
    2429             : {
    2430             :     IndexInfo  *ii;
    2431     3308252 :     Form_pg_index indexStruct = index->rd_index;
    2432             :     int         i;
    2433             :     int         numAtts;
    2434             : 
    2435             :     /* check the number of keys, and copy attr numbers into the IndexInfo */
    2436     3308252 :     numAtts = indexStruct->indnatts;
    2437     3308252 :     if (numAtts < 1 || numAtts > INDEX_MAX_KEYS)
    2438           0 :         elog(ERROR, "invalid indnatts %d for index %u",
    2439             :              numAtts, RelationGetRelid(index));
    2440             : 
    2441             :     /*
    2442             :      * Create the node, fetching any expressions needed for expressional
    2443             :      * indexes and index predicate if any.
    2444             :      */
    2445     3308252 :     ii = makeIndexInfo(indexStruct->indnatts,
    2446     3308252 :                        indexStruct->indnkeyatts,
    2447     3308252 :                        index->rd_rel->relam,
    2448             :                        RelationGetIndexExpressions(index),
    2449             :                        RelationGetIndexPredicate(index),
    2450     3308252 :                        indexStruct->indisunique,
    2451     3308252 :                        indexStruct->indnullsnotdistinct,
    2452     3308252 :                        indexStruct->indisready,
    2453             :                        false,
    2454     3308252 :                        index->rd_indam->amsummarizing,
    2455     3308252 :                        indexStruct->indisexclusion && indexStruct->indisunique);
    2456             : 
    2457             :     /* fill in attribute numbers */
    2458    10036200 :     for (i = 0; i < numAtts; i++)
    2459     6727948 :         ii->ii_IndexAttrNumbers[i] = indexStruct->indkey.values[i];
    2460             : 
    2461             :     /* fetch exclusion constraint info if any */
    2462     3308252 :     if (indexStruct->indisexclusion)
    2463             :     {
    2464        2184 :         RelationGetExclusionInfo(index,
    2465             :                                  &ii->ii_ExclusionOps,
    2466             :                                  &ii->ii_ExclusionProcs,
    2467             :                                  &ii->ii_ExclusionStrats);
    2468             :     }
    2469             : 
    2470     3308252 :     return ii;
    2471             : }
    2472             : 
    2473             : /* ----------------
    2474             :  *      BuildDummyIndexInfo
    2475             :  *          Construct a dummy IndexInfo record for an open index
    2476             :  *
    2477             :  * This differs from the real BuildIndexInfo in that it will never run any
    2478             :  * user-defined code that might exist in index expressions or predicates.
    2479             :  * Instead of the real index expressions, we return null constants that have
    2480             :  * the right types/typmods/collations.  Predicates and exclusion clauses are
    2481             :  * just ignored.  This is sufficient for the purpose of truncating an index,
    2482             :  * since we will not need to actually evaluate the expressions or predicates;
    2483             :  * the only thing that's likely to be done with the data is construction of
    2484             :  * a tupdesc describing the index's rowtype.
    2485             :  * ----------------
    2486             :  */
    2487             : IndexInfo *
    2488         204 : BuildDummyIndexInfo(Relation index)
    2489             : {
    2490             :     IndexInfo  *ii;
    2491         204 :     Form_pg_index indexStruct = index->rd_index;
    2492             :     int         i;
    2493             :     int         numAtts;
    2494             : 
    2495             :     /* check the number of keys, and copy attr numbers into the IndexInfo */
    2496         204 :     numAtts = indexStruct->indnatts;
    2497         204 :     if (numAtts < 1 || numAtts > INDEX_MAX_KEYS)
    2498           0 :         elog(ERROR, "invalid indnatts %d for index %u",
    2499             :              numAtts, RelationGetRelid(index));
    2500             : 
    2501             :     /*
    2502             :      * Create the node, using dummy index expressions, and pretending there is
    2503             :      * no predicate.
    2504             :      */
    2505         408 :     ii = makeIndexInfo(indexStruct->indnatts,
    2506         204 :                        indexStruct->indnkeyatts,
    2507         204 :                        index->rd_rel->relam,
    2508             :                        RelationGetDummyIndexExpressions(index),
    2509             :                        NIL,
    2510         204 :                        indexStruct->indisunique,
    2511         204 :                        indexStruct->indnullsnotdistinct,
    2512         204 :                        indexStruct->indisready,
    2513             :                        false,
    2514         204 :                        index->rd_indam->amsummarizing,
    2515         204 :                        indexStruct->indisexclusion && indexStruct->indisunique);
    2516             : 
    2517             :     /* fill in attribute numbers */
    2518         530 :     for (i = 0; i < numAtts; i++)
    2519         326 :         ii->ii_IndexAttrNumbers[i] = indexStruct->indkey.values[i];
    2520             : 
    2521             :     /* We ignore the exclusion constraint if any */
    2522             : 
    2523         204 :     return ii;
    2524             : }
    2525             : 
    2526             : /*
    2527             :  * CompareIndexInfo
    2528             :  *      Return whether the properties of two indexes (in different tables)
    2529             :  *      indicate that they have the "same" definitions.
    2530             :  *
    2531             :  * Note: passing collations and opfamilies separately is a kludge.  Adding
    2532             :  * them to IndexInfo may result in better coding here and elsewhere.
    2533             :  *
    2534             :  * Use build_attrmap_by_name(index2, index1) to build the attmap.
    2535             :  */
    2536             : bool
    2537         690 : CompareIndexInfo(const IndexInfo *info1, const IndexInfo *info2,
    2538             :                  const Oid *collations1, const Oid *collations2,
    2539             :                  const Oid *opfamilies1, const Oid *opfamilies2,
    2540             :                  const AttrMap *attmap)
    2541             : {
    2542             :     int         i;
    2543             : 
    2544         690 :     if (info1->ii_Unique != info2->ii_Unique)
    2545           0 :         return false;
    2546             : 
    2547         690 :     if (info1->ii_NullsNotDistinct != info2->ii_NullsNotDistinct)
    2548           0 :         return false;
    2549             : 
    2550             :     /* indexes are only equivalent if they have the same access method */
    2551         690 :     if (info1->ii_Am != info2->ii_Am)
    2552          12 :         return false;
    2553             : 
    2554             :     /* and same number of attributes */
    2555         678 :     if (info1->ii_NumIndexAttrs != info2->ii_NumIndexAttrs)
    2556          24 :         return false;
    2557             : 
    2558             :     /* and same number of key attributes */
    2559         654 :     if (info1->ii_NumIndexKeyAttrs != info2->ii_NumIndexKeyAttrs)
    2560           0 :         return false;
    2561             : 
    2562             :     /*
    2563             :      * and columns match through the attribute map (actual attribute numbers
    2564             :      * might differ!)  Note that this checks that index columns that are
    2565             :      * expressions appear in the same positions.  We will next compare the
    2566             :      * expressions themselves.
    2567             :      */
    2568        1354 :     for (i = 0; i < info1->ii_NumIndexAttrs; i++)
    2569             :     {
    2570         742 :         if (attmap->maplen < info2->ii_IndexAttrNumbers[i])
    2571           0 :             elog(ERROR, "incorrect attribute map");
    2572             : 
    2573             :         /* ignore expressions for now (but check their collation/opfamily) */
    2574         742 :         if (!(info1->ii_IndexAttrNumbers[i] == InvalidAttrNumber &&
    2575          48 :               info2->ii_IndexAttrNumbers[i] == InvalidAttrNumber))
    2576             :         {
    2577             :             /* fail if just one index has an expression in this column */
    2578         700 :             if (info1->ii_IndexAttrNumbers[i] == InvalidAttrNumber ||
    2579         694 :                 info2->ii_IndexAttrNumbers[i] == InvalidAttrNumber)
    2580           6 :                 return false;
    2581             : 
    2582             :             /* both are columns, so check for match after mapping */
    2583         694 :             if (attmap->attnums[info2->ii_IndexAttrNumbers[i] - 1] !=
    2584         694 :                 info1->ii_IndexAttrNumbers[i])
    2585          12 :                 return false;
    2586             :         }
    2587             : 
    2588             :         /* collation and opfamily are not valid for included columns */
    2589         724 :         if (i >= info1->ii_NumIndexKeyAttrs)
    2590          14 :             continue;
    2591             : 
    2592         710 :         if (collations1[i] != collations2[i])
    2593          12 :             return false;
    2594         698 :         if (opfamilies1[i] != opfamilies2[i])
    2595          12 :             return false;
    2596             :     }
    2597             : 
    2598             :     /*
    2599             :      * For expression indexes: either both are expression indexes, or neither
    2600             :      * is; if they are, make sure the expressions match.
    2601             :      */
    2602         612 :     if ((info1->ii_Expressions != NIL) != (info2->ii_Expressions != NIL))
    2603           0 :         return false;
    2604         612 :     if (info1->ii_Expressions != NIL)
    2605             :     {
    2606             :         bool        found_whole_row;
    2607             :         Node       *mapped;
    2608             : 
    2609          42 :         mapped = map_variable_attnos((Node *) info2->ii_Expressions,
    2610             :                                      1, 0, attmap,
    2611             :                                      InvalidOid, &found_whole_row);
    2612          42 :         if (found_whole_row)
    2613             :         {
    2614             :             /*
    2615             :              * we could throw an error here, but seems out of scope for this
    2616             :              * routine.
    2617             :              */
    2618           6 :             return false;
    2619             :         }
    2620             : 
    2621          42 :         if (!equal(info1->ii_Expressions, mapped))
    2622           6 :             return false;
    2623             :     }
    2624             : 
    2625             :     /* Partial index predicates must be identical, if they exist */
    2626         606 :     if ((info1->ii_Predicate == NULL) != (info2->ii_Predicate == NULL))
    2627          12 :         return false;
    2628         594 :     if (info1->ii_Predicate != NULL)
    2629             :     {
    2630             :         bool        found_whole_row;
    2631             :         Node       *mapped;
    2632             : 
    2633          24 :         mapped = map_variable_attnos((Node *) info2->ii_Predicate,
    2634             :                                      1, 0, attmap,
    2635             :                                      InvalidOid, &found_whole_row);
    2636          24 :         if (found_whole_row)
    2637             :         {
    2638             :             /*
    2639             :              * we could throw an error here, but seems out of scope for this
    2640             :              * routine.
    2641             :              */
    2642           6 :             return false;
    2643             :         }
    2644          24 :         if (!equal(info1->ii_Predicate, mapped))
    2645           6 :             return false;
    2646             :     }
    2647             : 
    2648             :     /* No support currently for comparing exclusion indexes. */
    2649         588 :     if (info1->ii_ExclusionOps != NULL || info2->ii_ExclusionOps != NULL)
    2650           0 :         return false;
    2651             : 
    2652         588 :     return true;
    2653             : }
    2654             : 
    2655             : /* ----------------
    2656             :  *      BuildSpeculativeIndexInfo
    2657             :  *          Add extra state to IndexInfo record
    2658             :  *
    2659             :  * For unique indexes, we usually don't want to add info to the IndexInfo for
    2660             :  * checking uniqueness, since the B-Tree AM handles that directly.  However, in
    2661             :  * the case of speculative insertion and conflict detection in logical
    2662             :  * replication, additional support is required.
    2663             :  *
    2664             :  * Do this processing here rather than in BuildIndexInfo() to not incur the
    2665             :  * overhead in the common non-speculative cases.
    2666             :  * ----------------
    2667             :  */
    2668             : void
    2669      177038 : BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii)
    2670             : {
    2671             :     int         indnkeyatts;
    2672             :     int         i;
    2673             : 
    2674      177038 :     indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
    2675             : 
    2676             :     /*
    2677             :      * fetch info for checking unique indexes
    2678             :      */
    2679             :     Assert(ii->ii_Unique);
    2680             : 
    2681      177038 :     ii->ii_UniqueOps = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
    2682      177038 :     ii->ii_UniqueProcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
    2683      177038 :     ii->ii_UniqueStrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
    2684             : 
    2685             :     /*
    2686             :      * We have to look up the operator's strategy number.  This provides a
    2687             :      * cross-check that the operator does match the index.
    2688             :      */
    2689             :     /* We need the func OIDs and strategy numbers too */
    2690      354164 :     for (i = 0; i < indnkeyatts; i++)
    2691             :     {
    2692      354252 :         ii->ii_UniqueStrats[i] =
    2693      177126 :             IndexAmTranslateCompareType(COMPARE_EQ,
    2694      177126 :                                         index->rd_rel->relam,
    2695      177126 :                                         index->rd_opfamily[i],
    2696             :                                         false);
    2697      354252 :         ii->ii_UniqueOps[i] =
    2698      177126 :             get_opfamily_member(index->rd_opfamily[i],
    2699      177126 :                                 index->rd_opcintype[i],
    2700      177126 :                                 index->rd_opcintype[i],
    2701      177126 :                                 ii->ii_UniqueStrats[i]);
    2702      177126 :         if (!OidIsValid(ii->ii_UniqueOps[i]))
    2703           0 :             elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
    2704             :                  ii->ii_UniqueStrats[i], index->rd_opcintype[i],
    2705             :                  index->rd_opcintype[i], index->rd_opfamily[i]);
    2706      177126 :         ii->ii_UniqueProcs[i] = get_opcode(ii->ii_UniqueOps[i]);
    2707             :     }
    2708      177038 : }
    2709             : 
    2710             : /* ----------------
    2711             :  *      FormIndexDatum
    2712             :  *          Construct values[] and isnull[] arrays for a new index tuple.
    2713             :  *
    2714             :  *  indexInfo       Info about the index
    2715             :  *  slot            Heap tuple for which we must prepare an index entry
    2716             :  *  estate          executor state for evaluating any index expressions
    2717             :  *  values          Array of index Datums (output area)
    2718             :  *  isnull          Array of is-null indicators (output area)
    2719             :  *
    2720             :  * When there are no index expressions, estate may be NULL.  Otherwise it
    2721             :  * must be supplied, *and* the ecxt_scantuple slot of its per-tuple expr
    2722             :  * context must point to the heap tuple passed in.
    2723             :  *
    2724             :  * Notice we don't actually call index_form_tuple() here; we just prepare
    2725             :  * its input arrays values[] and isnull[].  This is because the index AM
    2726             :  * may wish to alter the data before storage.
    2727             :  * ----------------
    2728             :  */
    2729             : void
    2730    25677958 : FormIndexDatum(IndexInfo *indexInfo,
    2731             :                TupleTableSlot *slot,
    2732             :                EState *estate,
    2733             :                Datum *values,
    2734             :                bool *isnull)
    2735             : {
    2736             :     ListCell   *indexpr_item;
    2737             :     int         i;
    2738             : 
    2739    25677958 :     if (indexInfo->ii_Expressions != NIL &&
    2740      532412 :         indexInfo->ii_ExpressionsState == NIL)
    2741             :     {
    2742             :         /* First time through, set up expression evaluation state */
    2743         810 :         indexInfo->ii_ExpressionsState =
    2744         810 :             ExecPrepareExprList(indexInfo->ii_Expressions, estate);
    2745             :         /* Check caller has set up context correctly */
    2746             :         Assert(GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
    2747             :     }
    2748    25677958 :     indexpr_item = list_head(indexInfo->ii_ExpressionsState);
    2749             : 
    2750    65442282 :     for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
    2751             :     {
    2752    39764342 :         int         keycol = indexInfo->ii_IndexAttrNumbers[i];
    2753             :         Datum       iDatum;
    2754             :         bool        isNull;
    2755             : 
    2756    39764342 :         if (keycol < 0)
    2757           0 :             iDatum = slot_getsysattr(slot, keycol, &isNull);
    2758    39764342 :         else if (keycol != 0)
    2759             :         {
    2760             :             /*
    2761             :              * Plain index column; get the value we need directly from the
    2762             :              * heap tuple.
    2763             :              */
    2764    39231876 :             iDatum = slot_getattr(slot, keycol, &isNull);
    2765             :         }
    2766             :         else
    2767             :         {
    2768             :             /*
    2769             :              * Index expression --- need to evaluate it.
    2770             :              */
    2771      532466 :             if (indexpr_item == NULL)
    2772           0 :                 elog(ERROR, "wrong number of index expressions");
    2773      532466 :             iDatum = ExecEvalExprSwitchContext((ExprState *) lfirst(indexpr_item),
    2774      532466 :                                                GetPerTupleExprContext(estate),
    2775             :                                                &isNull);
    2776      532448 :             indexpr_item = lnext(indexInfo->ii_ExpressionsState, indexpr_item);
    2777             :         }
    2778    39764324 :         values[i] = iDatum;
    2779    39764324 :         isnull[i] = isNull;
    2780             :     }
    2781             : 
    2782    25677940 :     if (indexpr_item != NULL)
    2783           0 :         elog(ERROR, "wrong number of index expressions");
    2784    25677940 : }
    2785             : 
    2786             : 
    2787             : /*
    2788             :  * index_update_stats --- update pg_class entry after CREATE INDEX or REINDEX
    2789             :  *
    2790             :  * This routine updates the pg_class row of either an index or its parent
    2791             :  * relation after CREATE INDEX or REINDEX.  Its rather bizarre API is designed
    2792             :  * to ensure we can do all the necessary work in just one update.
    2793             :  *
    2794             :  * hasindex: set relhasindex to this value
    2795             :  * reltuples: if >= 0, set reltuples to this value; else no change
    2796             :  *
    2797             :  * If reltuples >= 0, relpages, relallvisible, and relallfrozen are also
    2798             :  * updated (using RelationGetNumberOfBlocks() and visibilitymap_count()).
    2799             :  *
    2800             :  * NOTE: an important side-effect of this operation is that an SI invalidation
    2801             :  * message is sent out to all backends --- including me --- causing relcache
    2802             :  * entries to be flushed or updated with the new data.  This must happen even
    2803             :  * if we find that no change is needed in the pg_class row.  When updating
    2804             :  * a heap entry, this ensures that other backends find out about the new
    2805             :  * index.  When updating an index, it's important because some index AMs
    2806             :  * expect a relcache flush to occur after REINDEX.
    2807             :  */
    2808             : static void
    2809      105472 : index_update_stats(Relation rel,
    2810             :                    bool hasindex,
    2811             :                    double reltuples)
    2812             : {
    2813             :     bool        update_stats;
    2814      105472 :     BlockNumber relpages = 0;   /* keep compiler quiet */
    2815      105472 :     BlockNumber relallvisible = 0;
    2816      105472 :     BlockNumber relallfrozen = 0;
    2817      105472 :     Oid         relid = RelationGetRelid(rel);
    2818             :     Relation    pg_class;
    2819             :     ScanKeyData key[1];
    2820             :     HeapTuple   tuple;
    2821             :     void       *state;
    2822             :     Form_pg_class rd_rel;
    2823             :     bool        dirty;
    2824             : 
    2825             :     /*
    2826             :      * As a special hack, if we are dealing with an empty table and the
    2827             :      * existing reltuples is -1, we leave that alone.  This ensures that
    2828             :      * creating an index as part of CREATE TABLE doesn't cause the table to
    2829             :      * prematurely look like it's been vacuumed.  The rd_rel we modify may
    2830             :      * differ from rel->rd_rel due to e.g. commit of concurrent GRANT, but the
    2831             :      * commands that change reltuples take locks conflicting with ours.  (Even
    2832             :      * if a command changed reltuples under a weaker lock, this affects only
    2833             :      * statistics for an empty table.)
    2834             :      */
    2835      105472 :     if (reltuples == 0 && rel->rd_rel->reltuples < 0)
    2836       43018 :         reltuples = -1;
    2837             : 
    2838             :     /*
    2839             :      * Don't update statistics during binary upgrade, because the indexes are
    2840             :      * created before the data is moved into place.
    2841             :      */
    2842      105472 :     update_stats = reltuples >= 0 && !IsBinaryUpgrade;
    2843             : 
    2844             :     /*
    2845             :      * If autovacuum is off, user may not be expecting table relstats to
    2846             :      * change.  This can be important when restoring a dump that includes
    2847             :      * statistics, as the table statistics may be restored before the index is
    2848             :      * created, and we want to preserve the restored table statistics.
    2849             :      */
    2850      105472 :     if (rel->rd_rel->relkind == RELKIND_RELATION ||
    2851       73330 :         rel->rd_rel->relkind == RELKIND_TOASTVALUE ||
    2852       53310 :         rel->rd_rel->relkind == RELKIND_MATVIEW)
    2853             :     {
    2854       52356 :         if (AutoVacuumingActive())
    2855             :         {
    2856       50570 :             StdRdOptions *options = (StdRdOptions *) rel->rd_options;
    2857             : 
    2858       50570 :             if (options != NULL && !options->autovacuum.enabled)
    2859         276 :                 update_stats = false;
    2860             :         }
    2861             :         else
    2862        1786 :             update_stats = false;
    2863             :     }
    2864             : 
    2865             :     /*
    2866             :      * Finish I/O and visibility map buffer locks before
    2867             :      * systable_inplace_update_begin() locks the pg_class buffer.  The rd_rel
    2868             :      * we modify may differ from rel->rd_rel due to e.g. commit of concurrent
    2869             :      * GRANT, but no command changes a relkind from non-index to index.  (Even
    2870             :      * if one did, relallvisible doesn't break functionality.)
    2871             :      */
    2872      105472 :     if (update_stats)
    2873             :     {
    2874       57450 :         relpages = RelationGetNumberOfBlocks(rel);
    2875             : 
    2876       57450 :         if (rel->rd_rel->relkind != RELKIND_INDEX)
    2877       12172 :             visibilitymap_count(rel, &relallvisible, &relallfrozen);
    2878             :     }
    2879             : 
    2880             :     /*
    2881             :      * We always update the pg_class row using a non-transactional,
    2882             :      * overwrite-in-place update.  There are several reasons for this:
    2883             :      *
    2884             :      * 1. In bootstrap mode, we have no choice --- UPDATE wouldn't work.
    2885             :      *
    2886             :      * 2. We could be reindexing pg_class itself, in which case we can't move
    2887             :      * its pg_class row because CatalogTupleInsert/CatalogTupleUpdate might
    2888             :      * not know about all the indexes yet (see reindex_relation).
    2889             :      *
    2890             :      * 3. Because we execute CREATE INDEX with just share lock on the parent
    2891             :      * rel (to allow concurrent index creations), an ordinary update could
    2892             :      * suffer a tuple-concurrently-updated failure against another CREATE
    2893             :      * INDEX committing at about the same time.  We can avoid that by having
    2894             :      * them both do nontransactional updates (we assume they will both be
    2895             :      * trying to change the pg_class row to the same thing, so it doesn't
    2896             :      * matter which goes first).
    2897             :      *
    2898             :      * It is safe to use a non-transactional update even though our
    2899             :      * transaction could still fail before committing.  Setting relhasindex
    2900             :      * true is safe even if there are no indexes (VACUUM will eventually fix
    2901             :      * it).  And of course the new relpages and reltuples counts are correct
    2902             :      * regardless.  However, we don't want to change relpages (or
    2903             :      * relallvisible) if the caller isn't providing an updated reltuples
    2904             :      * count, because that would bollix the reltuples/relpages ratio which is
    2905             :      * what's really important.
    2906             :      */
    2907             : 
    2908      105472 :     pg_class = table_open(RelationRelationId, RowExclusiveLock);
    2909             : 
    2910      105472 :     ScanKeyInit(&key[0],
    2911             :                 Anum_pg_class_oid,
    2912             :                 BTEqualStrategyNumber, F_OIDEQ,
    2913             :                 ObjectIdGetDatum(relid));
    2914      105472 :     systable_inplace_update_begin(pg_class, ClassOidIndexId, true, NULL,
    2915             :                                   1, key, &tuple, &state);
    2916             : 
    2917      105472 :     if (!HeapTupleIsValid(tuple))
    2918           0 :         elog(ERROR, "could not find tuple for relation %u", relid);
    2919      105472 :     rd_rel = (Form_pg_class) GETSTRUCT(tuple);
    2920             : 
    2921             :     /* Should this be a more comprehensive test? */
    2922             :     Assert(rd_rel->relkind != RELKIND_PARTITIONED_INDEX);
    2923             : 
    2924             :     /* Apply required updates, if any, to copied tuple */
    2925             : 
    2926      105472 :     dirty = false;
    2927      105472 :     if (rd_rel->relhasindex != hasindex)
    2928             :     {
    2929       36300 :         rd_rel->relhasindex = hasindex;
    2930       36300 :         dirty = true;
    2931             :     }
    2932             : 
    2933      105472 :     if (update_stats)
    2934             :     {
    2935       57450 :         if (rd_rel->relpages != (int32) relpages)
    2936             :         {
    2937       48814 :             rd_rel->relpages = (int32) relpages;
    2938       48814 :             dirty = true;
    2939             :         }
    2940       57450 :         if (rd_rel->reltuples != (float4) reltuples)
    2941             :         {
    2942       15560 :             rd_rel->reltuples = (float4) reltuples;
    2943       15560 :             dirty = true;
    2944             :         }
    2945       57450 :         if (rd_rel->relallvisible != (int32) relallvisible)
    2946             :         {
    2947         116 :             rd_rel->relallvisible = (int32) relallvisible;
    2948         116 :             dirty = true;
    2949             :         }
    2950       57450 :         if (rd_rel->relallfrozen != (int32) relallfrozen)
    2951             :         {
    2952          90 :             rd_rel->relallfrozen = (int32) relallfrozen;
    2953          90 :             dirty = true;
    2954             :         }
    2955             :     }
    2956             : 
    2957             :     /*
    2958             :      * If anything changed, write out the tuple
    2959             :      */
    2960      105472 :     if (dirty)
    2961             :     {
    2962       81720 :         systable_inplace_update_finish(state, tuple);
    2963             :         /* the above sends transactional and immediate cache inval messages */
    2964             :     }
    2965             :     else
    2966             :     {
    2967       23752 :         systable_inplace_update_cancel(state);
    2968             : 
    2969             :         /*
    2970             :          * While we didn't change relhasindex, CREATE INDEX needs a
    2971             :          * transactional inval for when the new index's catalog rows become
    2972             :          * visible.  Other CREATE INDEX and REINDEX code happens to also queue
    2973             :          * this inval, but keep this in case rare callers rely on this part of
    2974             :          * our API contract.
    2975             :          */
    2976       23752 :         CacheInvalidateRelcacheByTuple(tuple);
    2977             :     }
    2978             : 
    2979      105472 :     heap_freetuple(tuple);
    2980             : 
    2981      105472 :     table_close(pg_class, RowExclusiveLock);
    2982      105472 : }
    2983             : 
    2984             : 
    2985             : /*
    2986             :  * index_build - invoke access-method-specific index build procedure
    2987             :  *
    2988             :  * On entry, the index's catalog entries are valid, and its physical disk
    2989             :  * file has been created but is empty.  We call the AM-specific build
    2990             :  * procedure to fill in the index contents.  We then update the pg_class
    2991             :  * entries of the index and heap relation as needed, using statistics
    2992             :  * returned by ambuild as well as data passed by the caller.
    2993             :  *
    2994             :  * isreindex indicates we are recreating a previously-existing index.
    2995             :  * parallel indicates if parallelism may be useful.
    2996             :  *
    2997             :  * Note: before Postgres 8.2, the passed-in heap and index Relations
    2998             :  * were automatically closed by this routine.  This is no longer the case.
    2999             :  * The caller opened 'em, and the caller should close 'em.
    3000             :  */
    3001             : void
    3002       51276 : index_build(Relation heapRelation,
    3003             :             Relation indexRelation,
    3004             :             IndexInfo *indexInfo,
    3005             :             bool isreindex,
    3006             :             bool parallel)
    3007             : {
    3008             :     IndexBuildResult *stats;
    3009             :     Oid         save_userid;
    3010             :     int         save_sec_context;
    3011             :     int         save_nestlevel;
    3012             : 
    3013             :     /*
    3014             :      * sanity checks
    3015             :      */
    3016             :     Assert(RelationIsValid(indexRelation));
    3017             :     Assert(PointerIsValid(indexRelation->rd_indam));
    3018             :     Assert(PointerIsValid(indexRelation->rd_indam->ambuild));
    3019             :     Assert(PointerIsValid(indexRelation->rd_indam->ambuildempty));
    3020             : 
    3021             :     /*
    3022             :      * Determine worker process details for parallel CREATE INDEX.  Currently,
    3023             :      * only btree and BRIN have support for parallel builds.
    3024             :      *
    3025             :      * Note that planner considers parallel safety for us.
    3026             :      */
    3027       51276 :     if (parallel && IsNormalProcessingMode() &&
    3028       36672 :         indexRelation->rd_indam->amcanbuildparallel)
    3029       34642 :         indexInfo->ii_ParallelWorkers =
    3030       34642 :             plan_create_index_workers(RelationGetRelid(heapRelation),
    3031             :                                       RelationGetRelid(indexRelation));
    3032             : 
    3033       51276 :     if (indexInfo->ii_ParallelWorkers == 0)
    3034       51118 :         ereport(DEBUG1,
    3035             :                 (errmsg_internal("building index \"%s\" on table \"%s\" serially",
    3036             :                                  RelationGetRelationName(indexRelation),
    3037             :                                  RelationGetRelationName(heapRelation))));
    3038             :     else
    3039         158 :         ereport(DEBUG1,
    3040             :                 (errmsg_internal("building index \"%s\" on table \"%s\" with request for %d parallel workers",
    3041             :                                  RelationGetRelationName(indexRelation),
    3042             :                                  RelationGetRelationName(heapRelation),
    3043             :                                  indexInfo->ii_ParallelWorkers)));
    3044             : 
    3045             :     /*
    3046             :      * Switch to the table owner's userid, so that any index functions are run
    3047             :      * as that user.  Also lock down security-restricted operations and
    3048             :      * arrange to make GUC variable changes local to this command.
    3049             :      */
    3050       51276 :     GetUserIdAndSecContext(&save_userid, &save_sec_context);
    3051       51276 :     SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
    3052             :                            save_sec_context | SECURITY_RESTRICTED_OPERATION);
    3053       51276 :     save_nestlevel = NewGUCNestLevel();
    3054       51276 :     RestrictSearchPath();
    3055             : 
    3056             :     /* Set up initial progress report status */
    3057             :     {
    3058       51276 :         const int   progress_index[] = {
    3059             :             PROGRESS_CREATEIDX_PHASE,
    3060             :             PROGRESS_CREATEIDX_SUBPHASE,
    3061             :             PROGRESS_CREATEIDX_TUPLES_DONE,
    3062             :             PROGRESS_CREATEIDX_TUPLES_TOTAL,
    3063             :             PROGRESS_SCAN_BLOCKS_DONE,
    3064             :             PROGRESS_SCAN_BLOCKS_TOTAL
    3065             :         };
    3066       51276 :         const int64 progress_vals[] = {
    3067             :             PROGRESS_CREATEIDX_PHASE_BUILD,
    3068             :             PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE,
    3069             :             0, 0, 0, 0
    3070             :         };
    3071             : 
    3072       51276 :         pgstat_progress_update_multi_param(6, progress_index, progress_vals);
    3073             :     }
    3074             : 
    3075             :     /*
    3076             :      * Call the access method's build procedure
    3077             :      */
    3078       51276 :     stats = indexRelation->rd_indam->ambuild(heapRelation, indexRelation,
    3079             :                                              indexInfo);
    3080             :     Assert(PointerIsValid(stats));
    3081             : 
    3082             :     /*
    3083             :      * If this is an unlogged index, we may need to write out an init fork for
    3084             :      * it -- but we must first check whether one already exists.  If, for
    3085             :      * example, an unlogged relation is truncated in the transaction that
    3086             :      * created it, or truncated twice in a subsequent transaction, the
    3087             :      * relfilenumber won't change, and nothing needs to be done here.
    3088             :      */
    3089       51180 :     if (indexRelation->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
    3090         186 :         !smgrexists(RelationGetSmgr(indexRelation), INIT_FORKNUM))
    3091             :     {
    3092         186 :         smgrcreate(RelationGetSmgr(indexRelation), INIT_FORKNUM, false);
    3093         186 :         log_smgrcreate(&indexRelation->rd_locator, INIT_FORKNUM);
    3094         186 :         indexRelation->rd_indam->ambuildempty(indexRelation);
    3095             :     }
    3096             : 
    3097             :     /*
    3098             :      * If we found any potentially broken HOT chains, mark the index as not
    3099             :      * being usable until the current transaction is below the event horizon.
    3100             :      * See src/backend/access/heap/README.HOT for discussion.  While it might
    3101             :      * become safe to use the index earlier based on actual cleanup activity
    3102             :      * and other active transactions, the test for that would be much more
    3103             :      * complex and would require some form of blocking, so keep it simple and
    3104             :      * fast by just using the current transaction.
    3105             :      *
    3106             :      * However, when reindexing an existing index, we should do nothing here.
    3107             :      * Any HOT chains that are broken with respect to the index must predate
    3108             :      * the index's original creation, so there is no need to change the
    3109             :      * index's usability horizon.  Moreover, we *must not* try to change the
    3110             :      * index's pg_index entry while reindexing pg_index itself, and this
    3111             :      * optimization nicely prevents that.  The more complex rules needed for a
    3112             :      * reindex are handled separately after this function returns.
    3113             :      *
    3114             :      * We also need not set indcheckxmin during a concurrent index build,
    3115             :      * because we won't set indisvalid true until all transactions that care
    3116             :      * about the broken HOT chains are gone.
    3117             :      *
    3118             :      * Therefore, this code path can only be taken during non-concurrent
    3119             :      * CREATE INDEX.  Thus the fact that heap_update will set the pg_index
    3120             :      * tuple's xmin doesn't matter, because that tuple was created in the
    3121             :      * current transaction anyway.  That also means we don't need to worry
    3122             :      * about any concurrent readers of the tuple; no other transaction can see
    3123             :      * it yet.
    3124             :      */
    3125       51180 :     if (indexInfo->ii_BrokenHotChain &&
    3126          32 :         !isreindex &&
    3127          22 :         !indexInfo->ii_Concurrent)
    3128             :     {
    3129          22 :         Oid         indexId = RelationGetRelid(indexRelation);
    3130             :         Relation    pg_index;
    3131             :         HeapTuple   indexTuple;
    3132             :         Form_pg_index indexForm;
    3133             : 
    3134          22 :         pg_index = table_open(IndexRelationId, RowExclusiveLock);
    3135             : 
    3136          22 :         indexTuple = SearchSysCacheCopy1(INDEXRELID,
    3137             :                                          ObjectIdGetDatum(indexId));
    3138          22 :         if (!HeapTupleIsValid(indexTuple))
    3139           0 :             elog(ERROR, "cache lookup failed for index %u", indexId);
    3140          22 :         indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
    3141             : 
    3142             :         /* If it's a new index, indcheckxmin shouldn't be set ... */
    3143             :         Assert(!indexForm->indcheckxmin);
    3144             : 
    3145          22 :         indexForm->indcheckxmin = true;
    3146          22 :         CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
    3147             : 
    3148          22 :         heap_freetuple(indexTuple);
    3149          22 :         table_close(pg_index, RowExclusiveLock);
    3150             :     }
    3151             : 
    3152             :     /*
    3153             :      * Update heap and index pg_class rows
    3154             :      */
    3155       51180 :     index_update_stats(heapRelation,
    3156             :                        true,
    3157             :                        stats->heap_tuples);
    3158             : 
    3159       51180 :     index_update_stats(indexRelation,
    3160             :                        false,
    3161             :                        stats->index_tuples);
    3162             : 
    3163             :     /* Make the updated catalog row versions visible */
    3164       51180 :     CommandCounterIncrement();
    3165             : 
    3166             :     /*
    3167             :      * If it's for an exclusion constraint, make a second pass over the heap
    3168             :      * to verify that the constraint is satisfied.  We must not do this until
    3169             :      * the index is fully valid.  (Broken HOT chains shouldn't matter, though;
    3170             :      * see comments for IndexCheckExclusion.)
    3171             :      */
    3172       51180 :     if (indexInfo->ii_ExclusionOps != NULL)
    3173         734 :         IndexCheckExclusion(heapRelation, indexRelation, indexInfo);
    3174             : 
    3175             :     /* Roll back any GUC changes executed by index functions */
    3176       51120 :     AtEOXact_GUC(false, save_nestlevel);
    3177             : 
    3178             :     /* Restore userid and security context */
    3179       51120 :     SetUserIdAndSecContext(save_userid, save_sec_context);
    3180       51120 : }
    3181             : 
    3182             : /*
    3183             :  * IndexCheckExclusion - verify that a new exclusion constraint is satisfied
    3184             :  *
    3185             :  * When creating an exclusion constraint, we first build the index normally
    3186             :  * and then rescan the heap to check for conflicts.  We assume that we only
    3187             :  * need to validate tuples that are live according to an up-to-date snapshot,
    3188             :  * and that these were correctly indexed even in the presence of broken HOT
    3189             :  * chains.  This should be OK since we are holding at least ShareLock on the
    3190             :  * table, meaning there can be no uncommitted updates from other transactions.
    3191             :  * (Note: that wouldn't necessarily work for system catalogs, since many
    3192             :  * operations release write lock early on the system catalogs.)
    3193             :  */
    3194             : static void
    3195         734 : IndexCheckExclusion(Relation heapRelation,
    3196             :                     Relation indexRelation,
    3197             :                     IndexInfo *indexInfo)
    3198             : {
    3199             :     TableScanDesc scan;
    3200             :     Datum       values[INDEX_MAX_KEYS];
    3201             :     bool        isnull[INDEX_MAX_KEYS];
    3202             :     ExprState  *predicate;
    3203             :     TupleTableSlot *slot;
    3204             :     EState     *estate;
    3205             :     ExprContext *econtext;
    3206             :     Snapshot    snapshot;
    3207             : 
    3208             :     /*
    3209             :      * If we are reindexing the target index, mark it as no longer being
    3210             :      * reindexed, to forestall an Assert in index_beginscan when we try to use
    3211             :      * the index for probes.  This is OK because the index is now fully valid.
    3212             :      */
    3213         734 :     if (ReindexIsCurrentlyProcessingIndex(RelationGetRelid(indexRelation)))
    3214          78 :         ResetReindexProcessing();
    3215             : 
    3216             :     /*
    3217             :      * Need an EState for evaluation of index expressions and partial-index
    3218             :      * predicates.  Also a slot to hold the current tuple.
    3219             :      */
    3220         734 :     estate = CreateExecutorState();
    3221         734 :     econtext = GetPerTupleExprContext(estate);
    3222         734 :     slot = table_slot_create(heapRelation, NULL);
    3223             : 
    3224             :     /* Arrange for econtext's scan tuple to be the tuple under test */
    3225         734 :     econtext->ecxt_scantuple = slot;
    3226             : 
    3227             :     /* Set up execution state for predicate, if any. */
    3228         734 :     predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
    3229             : 
    3230             :     /*
    3231             :      * Scan all live tuples in the base relation.
    3232             :      */
    3233         734 :     snapshot = RegisterSnapshot(GetLatestSnapshot());
    3234         734 :     scan = table_beginscan_strat(heapRelation,  /* relation */
    3235             :                                  snapshot,  /* snapshot */
    3236             :                                  0, /* number of keys */
    3237             :                                  NULL,  /* scan key */
    3238             :                                  true,  /* buffer access strategy OK */
    3239             :                                  true); /* syncscan OK */
    3240             : 
    3241        1140 :     while (table_scan_getnextslot(scan, ForwardScanDirection, slot))
    3242             :     {
    3243         466 :         CHECK_FOR_INTERRUPTS();
    3244             : 
    3245             :         /*
    3246             :          * In a partial index, ignore tuples that don't satisfy the predicate.
    3247             :          */
    3248         466 :         if (predicate != NULL)
    3249             :         {
    3250          34 :             if (!ExecQual(predicate, econtext))
    3251          12 :                 continue;
    3252             :         }
    3253             : 
    3254             :         /*
    3255             :          * Extract index column values, including computing expressions.
    3256             :          */
    3257         454 :         FormIndexDatum(indexInfo,
    3258             :                        slot,
    3259             :                        estate,
    3260             :                        values,
    3261             :                        isnull);
    3262             : 
    3263             :         /*
    3264             :          * Check that this tuple has no conflicts.
    3265             :          */
    3266         454 :         check_exclusion_constraint(heapRelation,
    3267             :                                    indexRelation, indexInfo,
    3268             :                                    &(slot->tts_tid), values, isnull,
    3269             :                                    estate, true);
    3270             : 
    3271         394 :         MemoryContextReset(econtext->ecxt_per_tuple_memory);
    3272             :     }
    3273             : 
    3274         674 :     table_endscan(scan);
    3275         674 :     UnregisterSnapshot(snapshot);
    3276             : 
    3277         674 :     ExecDropSingleTupleTableSlot(slot);
    3278             : 
    3279         674 :     FreeExecutorState(estate);
    3280             : 
    3281             :     /* These may have been pointing to the now-gone estate */
    3282         674 :     indexInfo->ii_ExpressionsState = NIL;
    3283         674 :     indexInfo->ii_PredicateState = NULL;
    3284         674 : }
    3285             : 
    3286             : /*
    3287             :  * validate_index - support code for concurrent index builds
    3288             :  *
    3289             :  * We do a concurrent index build by first inserting the catalog entry for the
    3290             :  * index via index_create(), marking it not indisready and not indisvalid.
    3291             :  * Then we commit our transaction and start a new one, then we wait for all
    3292             :  * transactions that could have been modifying the table to terminate.  Now
    3293             :  * we know that any subsequently-started transactions will see the index and
    3294             :  * honor its constraints on HOT updates; so while existing HOT-chains might
    3295             :  * be broken with respect to the index, no currently live tuple will have an
    3296             :  * incompatible HOT update done to it.  We now build the index normally via
    3297             :  * index_build(), while holding a weak lock that allows concurrent
    3298             :  * insert/update/delete.  Also, we index only tuples that are valid
    3299             :  * as of the start of the scan (see table_index_build_scan), whereas a normal
    3300             :  * build takes care to include recently-dead tuples.  This is OK because
    3301             :  * we won't mark the index valid until all transactions that might be able
    3302             :  * to see those tuples are gone.  The reason for doing that is to avoid
    3303             :  * bogus unique-index failures due to concurrent UPDATEs (we might see
    3304             :  * different versions of the same row as being valid when we pass over them,
    3305             :  * if we used HeapTupleSatisfiesVacuum).  This leaves us with an index that
    3306             :  * does not contain any tuples added to the table while we built the index.
    3307             :  *
    3308             :  * Next, we mark the index "indisready" (but still not "indisvalid") and
    3309             :  * commit the second transaction and start a third.  Again we wait for all
    3310             :  * transactions that could have been modifying the table to terminate.  Now
    3311             :  * we know that any subsequently-started transactions will see the index and
    3312             :  * insert their new tuples into it.  We then take a new reference snapshot
    3313             :  * which is passed to validate_index().  Any tuples that are valid according
    3314             :  * to this snap, but are not in the index, must be added to the index.
    3315             :  * (Any tuples committed live after the snap will be inserted into the
    3316             :  * index by their originating transaction.  Any tuples committed dead before
    3317             :  * the snap need not be indexed, because we will wait out all transactions
    3318             :  * that might care about them before we mark the index valid.)
    3319             :  *
    3320             :  * validate_index() works by first gathering all the TIDs currently in the
    3321             :  * index, using a bulkdelete callback that just stores the TIDs and doesn't
    3322             :  * ever say "delete it".  (This should be faster than a plain indexscan;
    3323             :  * also, not all index AMs support full-index indexscan.)  Then we sort the
    3324             :  * TIDs, and finally scan the table doing a "merge join" against the TID list
    3325             :  * to see which tuples are missing from the index.  Thus we will ensure that
    3326             :  * all tuples valid according to the reference snapshot are in the index.
    3327             :  *
    3328             :  * Building a unique index this way is tricky: we might try to insert a
    3329             :  * tuple that is already dead or is in process of being deleted, and we
    3330             :  * mustn't have a uniqueness failure against an updated version of the same
    3331             :  * row.  We could try to check the tuple to see if it's already dead and tell
    3332             :  * index_insert() not to do the uniqueness check, but that still leaves us
    3333             :  * with a race condition against an in-progress update.  To handle that,
    3334             :  * we expect the index AM to recheck liveness of the to-be-inserted tuple
    3335             :  * before it declares a uniqueness error.
    3336             :  *
    3337             :  * After completing validate_index(), we wait until all transactions that
    3338             :  * were alive at the time of the reference snapshot are gone; this is
    3339             :  * necessary to be sure there are none left with a transaction snapshot
    3340             :  * older than the reference (and hence possibly able to see tuples we did
    3341             :  * not index).  Then we mark the index "indisvalid" and commit.  Subsequent
    3342             :  * transactions will be able to use it for queries.
    3343             :  *
    3344             :  * Doing two full table scans is a brute-force strategy.  We could try to be
    3345             :  * cleverer, eg storing new tuples in a special area of the table (perhaps
    3346             :  * making the table append-only by setting use_fsm).  However that would
    3347             :  * add yet more locking issues.
    3348             :  */
    3349             : void
    3350         714 : validate_index(Oid heapId, Oid indexId, Snapshot snapshot)
    3351             : {
    3352             :     Relation    heapRelation,
    3353             :                 indexRelation;
    3354             :     IndexInfo  *indexInfo;
    3355             :     IndexVacuumInfo ivinfo;
    3356             :     ValidateIndexState state;
    3357             :     Oid         save_userid;
    3358             :     int         save_sec_context;
    3359             :     int         save_nestlevel;
    3360             : 
    3361             :     {
    3362         714 :         const int   progress_index[] = {
    3363             :             PROGRESS_CREATEIDX_PHASE,
    3364             :             PROGRESS_CREATEIDX_TUPLES_DONE,
    3365             :             PROGRESS_CREATEIDX_TUPLES_TOTAL,
    3366             :             PROGRESS_SCAN_BLOCKS_DONE,
    3367             :             PROGRESS_SCAN_BLOCKS_TOTAL
    3368             :         };
    3369         714 :         const int64 progress_vals[] = {
    3370             :             PROGRESS_CREATEIDX_PHASE_VALIDATE_IDXSCAN,
    3371             :             0, 0, 0, 0
    3372             :         };
    3373             : 
    3374         714 :         pgstat_progress_update_multi_param(5, progress_index, progress_vals);
    3375             :     }
    3376             : 
    3377             :     /* Open and lock the parent heap relation */
    3378         714 :     heapRelation = table_open(heapId, ShareUpdateExclusiveLock);
    3379             : 
    3380             :     /*
    3381             :      * Switch to the table owner's userid, so that any index functions are run
    3382             :      * as that user.  Also lock down security-restricted operations and
    3383             :      * arrange to make GUC variable changes local to this command.
    3384             :      */
    3385         714 :     GetUserIdAndSecContext(&save_userid, &save_sec_context);
    3386         714 :     SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
    3387             :                            save_sec_context | SECURITY_RESTRICTED_OPERATION);
    3388         714 :     save_nestlevel = NewGUCNestLevel();
    3389         714 :     RestrictSearchPath();
    3390             : 
    3391         714 :     indexRelation = index_open(indexId, RowExclusiveLock);
    3392             : 
    3393             :     /*
    3394             :      * Fetch info needed for index_insert.  (You might think this should be
    3395             :      * passed in from DefineIndex, but its copy is long gone due to having
    3396             :      * been built in a previous transaction.)
    3397             :      */
    3398         714 :     indexInfo = BuildIndexInfo(indexRelation);
    3399             : 
    3400             :     /* mark build is concurrent just for consistency */
    3401         714 :     indexInfo->ii_Concurrent = true;
    3402             : 
    3403             :     /*
    3404             :      * Scan the index and gather up all the TIDs into a tuplesort object.
    3405             :      */
    3406         714 :     ivinfo.index = indexRelation;
    3407         714 :     ivinfo.heaprel = heapRelation;
    3408         714 :     ivinfo.analyze_only = false;
    3409         714 :     ivinfo.report_progress = true;
    3410         714 :     ivinfo.estimated_count = true;
    3411         714 :     ivinfo.message_level = DEBUG2;
    3412         714 :     ivinfo.num_heap_tuples = heapRelation->rd_rel->reltuples;
    3413         714 :     ivinfo.strategy = NULL;
    3414             : 
    3415             :     /*
    3416             :      * Encode TIDs as int8 values for the sort, rather than directly sorting
    3417             :      * item pointers.  This can be significantly faster, primarily because TID
    3418             :      * is a pass-by-reference type on all platforms, whereas int8 is
    3419             :      * pass-by-value on most platforms.
    3420             :      */
    3421         714 :     state.tuplesort = tuplesort_begin_datum(INT8OID, Int8LessOperator,
    3422             :                                             InvalidOid, false,
    3423             :                                             maintenance_work_mem,
    3424             :                                             NULL, TUPLESORT_NONE);
    3425         714 :     state.htups = state.itups = state.tups_inserted = 0;
    3426             : 
    3427             :     /* ambulkdelete updates progress metrics */
    3428         714 :     (void) index_bulk_delete(&ivinfo, NULL,
    3429             :                              validate_index_callback, &state);
    3430             : 
    3431             :     /* Execute the sort */
    3432             :     {
    3433         714 :         const int   progress_index[] = {
    3434             :             PROGRESS_CREATEIDX_PHASE,
    3435             :             PROGRESS_SCAN_BLOCKS_DONE,
    3436             :             PROGRESS_SCAN_BLOCKS_TOTAL
    3437             :         };
    3438         714 :         const int64 progress_vals[] = {
    3439             :             PROGRESS_CREATEIDX_PHASE_VALIDATE_SORT,
    3440             :             0, 0
    3441             :         };
    3442             : 
    3443         714 :         pgstat_progress_update_multi_param(3, progress_index, progress_vals);
    3444             :     }
    3445         714 :     tuplesort_performsort(state.tuplesort);
    3446             : 
    3447             :     /*
    3448             :      * Now scan the heap and "merge" it with the index
    3449             :      */
    3450         714 :     pgstat_progress_update_param(PROGRESS_CREATEIDX_PHASE,
    3451             :                                  PROGRESS_CREATEIDX_PHASE_VALIDATE_TABLESCAN);
    3452         714 :     table_index_validate_scan(heapRelation,
    3453             :                               indexRelation,
    3454             :                               indexInfo,
    3455             :                               snapshot,
    3456             :                               &state);
    3457             : 
    3458             :     /* Done with tuplesort object */
    3459         714 :     tuplesort_end(state.tuplesort);
    3460             : 
    3461             :     /* Make sure to release resources cached in indexInfo (if needed). */
    3462         714 :     index_insert_cleanup(indexRelation, indexInfo);
    3463             : 
    3464         714 :     elog(DEBUG2,
    3465             :          "validate_index found %.0f heap tuples, %.0f index tuples; inserted %.0f missing tuples",
    3466             :          state.htups, state.itups, state.tups_inserted);
    3467             : 
    3468             :     /* Roll back any GUC changes executed by index functions */
    3469         714 :     AtEOXact_GUC(false, save_nestlevel);
    3470             : 
    3471             :     /* Restore userid and security context */
    3472         714 :     SetUserIdAndSecContext(save_userid, save_sec_context);
    3473             : 
    3474             :     /* Close rels, but keep locks */
    3475         714 :     index_close(indexRelation, NoLock);
    3476         714 :     table_close(heapRelation, NoLock);
    3477         714 : }
    3478             : 
    3479             : /*
    3480             :  * validate_index_callback - bulkdelete callback to collect the index TIDs
    3481             :  */
    3482             : static bool
    3483      323092 : validate_index_callback(ItemPointer itemptr, void *opaque)
    3484             : {
    3485      323092 :     ValidateIndexState *state = (ValidateIndexState *) opaque;
    3486      323092 :     int64       encoded = itemptr_encode(itemptr);
    3487             : 
    3488      323092 :     tuplesort_putdatum(state->tuplesort, Int64GetDatum(encoded), false);
    3489      323092 :     state->itups += 1;
    3490      323092 :     return false;               /* never actually delete anything */
    3491             : }
    3492             : 
    3493             : /*
    3494             :  * index_set_state_flags - adjust pg_index state flags
    3495             :  *
    3496             :  * This is used during CREATE/DROP INDEX CONCURRENTLY to adjust the pg_index
    3497             :  * flags that denote the index's state.
    3498             :  *
    3499             :  * Note that CatalogTupleUpdate() sends a cache invalidation message for the
    3500             :  * tuple, so other sessions will hear about the update as soon as we commit.
    3501             :  */
    3502             : void
    3503        1784 : index_set_state_flags(Oid indexId, IndexStateFlagsAction action)
    3504             : {
    3505             :     Relation    pg_index;
    3506             :     HeapTuple   indexTuple;
    3507             :     Form_pg_index indexForm;
    3508             : 
    3509             :     /* Open pg_index and fetch a writable copy of the index's tuple */
    3510        1784 :     pg_index = table_open(IndexRelationId, RowExclusiveLock);
    3511             : 
    3512        1784 :     indexTuple = SearchSysCacheCopy1(INDEXRELID,
    3513             :                                      ObjectIdGetDatum(indexId));
    3514        1784 :     if (!HeapTupleIsValid(indexTuple))
    3515           0 :         elog(ERROR, "cache lookup failed for index %u", indexId);
    3516        1784 :     indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
    3517             : 
    3518             :     /* Perform the requested state change on the copy */
    3519        1784 :     switch (action)
    3520             :     {
    3521         714 :         case INDEX_CREATE_SET_READY:
    3522             :             /* Set indisready during a CREATE INDEX CONCURRENTLY sequence */
    3523             :             Assert(indexForm->indislive);
    3524             :             Assert(!indexForm->indisready);
    3525             :             Assert(!indexForm->indisvalid);
    3526         714 :             indexForm->indisready = true;
    3527         714 :             break;
    3528         206 :         case INDEX_CREATE_SET_VALID:
    3529             :             /* Set indisvalid during a CREATE INDEX CONCURRENTLY sequence */
    3530             :             Assert(indexForm->indislive);
    3531             :             Assert(indexForm->indisready);
    3532             :             Assert(!indexForm->indisvalid);
    3533         206 :             indexForm->indisvalid = true;
    3534         206 :             break;
    3535         178 :         case INDEX_DROP_CLEAR_VALID:
    3536             : 
    3537             :             /*
    3538             :              * Clear indisvalid during a DROP INDEX CONCURRENTLY sequence
    3539             :              *
    3540             :              * If indisready == true we leave it set so the index still gets
    3541             :              * maintained by active transactions.  We only need to ensure that
    3542             :              * indisvalid is false.  (We don't assert that either is initially
    3543             :              * true, though, since we want to be able to retry a DROP INDEX
    3544             :              * CONCURRENTLY that failed partway through.)
    3545             :              *
    3546             :              * Note: the CLUSTER logic assumes that indisclustered cannot be
    3547             :              * set on any invalid index, so clear that flag too.  For
    3548             :              * cleanliness, also clear indisreplident.
    3549             :              */
    3550         178 :             indexForm->indisvalid = false;
    3551         178 :             indexForm->indisclustered = false;
    3552         178 :             indexForm->indisreplident = false;
    3553         178 :             break;
    3554         686 :         case INDEX_DROP_SET_DEAD:
    3555             : 
    3556             :             /*
    3557             :              * Clear indisready/indislive during DROP INDEX CONCURRENTLY
    3558             :              *
    3559             :              * We clear both indisready and indislive, because we not only
    3560             :              * want to stop updates, we want to prevent sessions from touching
    3561             :              * the index at all.
    3562             :              */
    3563             :             Assert(!indexForm->indisvalid);
    3564             :             Assert(!indexForm->indisclustered);
    3565             :             Assert(!indexForm->indisreplident);
    3566         686 :             indexForm->indisready = false;
    3567         686 :             indexForm->indislive = false;
    3568         686 :             break;
    3569             :     }
    3570             : 
    3571             :     /* ... and update it */
    3572        1784 :     CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
    3573             : 
    3574        1784 :     table_close(pg_index, RowExclusiveLock);
    3575        1784 : }
    3576             : 
    3577             : 
    3578             : /*
    3579             :  * IndexGetRelation: given an index's relation OID, get the OID of the
    3580             :  * relation it is an index on.  Uses the system cache.
    3581             :  */
    3582             : Oid
    3583       53966 : IndexGetRelation(Oid indexId, bool missing_ok)
    3584             : {
    3585             :     HeapTuple   tuple;
    3586             :     Form_pg_index index;
    3587             :     Oid         result;
    3588             : 
    3589       53966 :     tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
    3590       53966 :     if (!HeapTupleIsValid(tuple))
    3591             :     {
    3592          26 :         if (missing_ok)
    3593          26 :             return InvalidOid;
    3594           0 :         elog(ERROR, "cache lookup failed for index %u", indexId);
    3595             :     }
    3596       53940 :     index = (Form_pg_index) GETSTRUCT(tuple);
    3597             :     Assert(index->indexrelid == indexId);
    3598             : 
    3599       53940 :     result = index->indrelid;
    3600       53940 :     ReleaseSysCache(tuple);
    3601       53940 :     return result;
    3602             : }
    3603             : 
    3604             : /*
    3605             :  * reindex_index - This routine is used to recreate a single index
    3606             :  */
    3607             : void
    3608        7716 : reindex_index(const ReindexStmt *stmt, Oid indexId,
    3609             :               bool skip_constraint_checks, char persistence,
    3610             :               const ReindexParams *params)
    3611             : {
    3612             :     Relation    iRel,
    3613             :                 heapRelation;
    3614             :     Oid         heapId;
    3615             :     Oid         save_userid;
    3616             :     int         save_sec_context;
    3617             :     int         save_nestlevel;
    3618             :     IndexInfo  *indexInfo;
    3619        7716 :     volatile bool skipped_constraint = false;
    3620             :     PGRUsage    ru0;
    3621        7716 :     bool        progress = ((params->options & REINDEXOPT_REPORT_PROGRESS) != 0);
    3622        7716 :     bool        set_tablespace = false;
    3623             : 
    3624        7716 :     pg_rusage_init(&ru0);
    3625             : 
    3626             :     /*
    3627             :      * Open and lock the parent heap relation.  ShareLock is sufficient since
    3628             :      * we only need to be sure no schema or data changes are going on.
    3629             :      */
    3630        7716 :     heapId = IndexGetRelation(indexId,
    3631        7716 :                               (params->options & REINDEXOPT_MISSING_OK) != 0);
    3632             :     /* if relation is missing, leave */
    3633        7716 :     if (!OidIsValid(heapId))
    3634           0 :         return;
    3635             : 
    3636        7716 :     if ((params->options & REINDEXOPT_MISSING_OK) != 0)
    3637        2132 :         heapRelation = try_table_open(heapId, ShareLock);
    3638             :     else
    3639        5584 :         heapRelation = table_open(heapId, ShareLock);
    3640             : 
    3641             :     /* if relation is gone, leave */
    3642        7716 :     if (!heapRelation)
    3643           0 :         return;
    3644             : 
    3645             :     /*
    3646             :      * Switch to the table owner's userid, so that any index functions are run
    3647             :      * as that user.  Also lock down security-restricted operations and
    3648             :      * arrange to make GUC variable changes local to this command.
    3649             :      */
    3650        7716 :     GetUserIdAndSecContext(&save_userid, &save_sec_context);
    3651        7716 :     SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
    3652             :                            save_sec_context | SECURITY_RESTRICTED_OPERATION);
    3653        7716 :     save_nestlevel = NewGUCNestLevel();
    3654        7716 :     RestrictSearchPath();
    3655             : 
    3656        7716 :     if (progress)
    3657             :     {
    3658        3260 :         const int   progress_cols[] = {
    3659             :             PROGRESS_CREATEIDX_COMMAND,
    3660             :             PROGRESS_CREATEIDX_INDEX_OID
    3661             :         };
    3662        3260 :         const int64 progress_vals[] = {
    3663             :             PROGRESS_CREATEIDX_COMMAND_REINDEX,
    3664             :             indexId
    3665             :         };
    3666             : 
    3667        3260 :         pgstat_progress_start_command(PROGRESS_COMMAND_CREATE_INDEX,
    3668             :                                       heapId);
    3669        3260 :         pgstat_progress_update_multi_param(2, progress_cols, progress_vals);
    3670             :     }
    3671             : 
    3672             :     /*
    3673             :      * Open the target index relation and get an exclusive lock on it, to
    3674             :      * ensure that no one else is touching this particular index.
    3675             :      */
    3676        7716 :     if ((params->options & REINDEXOPT_MISSING_OK) != 0)
    3677        2132 :         iRel = try_index_open(indexId, AccessExclusiveLock);
    3678             :     else
    3679        5584 :         iRel = index_open(indexId, AccessExclusiveLock);
    3680             : 
    3681             :     /* if index relation is gone, leave */
    3682        7716 :     if (!iRel)
    3683             :     {
    3684             :         /* Roll back any GUC changes */
    3685           0 :         AtEOXact_GUC(false, save_nestlevel);
    3686             : 
    3687             :         /* Restore userid and security context */
    3688           0 :         SetUserIdAndSecContext(save_userid, save_sec_context);
    3689             : 
    3690             :         /* Close parent heap relation, but keep locks */
    3691           0 :         table_close(heapRelation, NoLock);
    3692           0 :         return;
    3693             :     }
    3694             : 
    3695        7716 :     if (progress)
    3696        3260 :         pgstat_progress_update_param(PROGRESS_CREATEIDX_ACCESS_METHOD_OID,
    3697        3260 :                                      iRel->rd_rel->relam);
    3698             : 
    3699             :     /*
    3700             :      * If a statement is available, telling that this comes from a REINDEX
    3701             :      * command, collect the index for event triggers.
    3702             :      */
    3703        7716 :     if (stmt)
    3704             :     {
    3705             :         ObjectAddress address;
    3706             : 
    3707        3260 :         ObjectAddressSet(address, RelationRelationId, indexId);
    3708        3260 :         EventTriggerCollectSimpleCommand(address,
    3709             :                                          InvalidObjectAddress,
    3710             :                                          (Node *) stmt);
    3711             :     }
    3712             : 
    3713             :     /*
    3714             :      * Partitioned indexes should never get processed here, as they have no
    3715             :      * physical storage.
    3716             :      */
    3717        7716 :     if (iRel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
    3718           0 :         elog(ERROR, "cannot reindex partitioned index \"%s.%s\"",
    3719             :              get_namespace_name(RelationGetNamespace(iRel)),
    3720             :              RelationGetRelationName(iRel));
    3721             : 
    3722             :     /*
    3723             :      * Don't allow reindex on temp tables of other backends ... their local
    3724             :      * buffer manager is not going to cope.
    3725             :      */
    3726        7716 :     if (RELATION_IS_OTHER_TEMP(iRel))
    3727           0 :         ereport(ERROR,
    3728             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    3729             :                  errmsg("cannot reindex temporary tables of other sessions")));
    3730             : 
    3731             :     /*
    3732             :      * Don't allow reindex of an invalid index on TOAST table.  This is a
    3733             :      * leftover from a failed REINDEX CONCURRENTLY, and if rebuilt it would
    3734             :      * not be possible to drop it anymore.
    3735             :      */
    3736        7716 :     if (IsToastNamespace(RelationGetNamespace(iRel)) &&
    3737        2556 :         !get_index_isvalid(indexId))
    3738           0 :         ereport(ERROR,
    3739             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    3740             :                  errmsg("cannot reindex invalid index on TOAST table")));
    3741             : 
    3742             :     /*
    3743             :      * System relations cannot be moved even if allow_system_table_mods is
    3744             :      * enabled to keep things consistent with the concurrent case where all
    3745             :      * the indexes of a relation are processed in series, including indexes of
    3746             :      * toast relations.
    3747             :      *
    3748             :      * Note that this check is not part of CheckRelationTableSpaceMove() as it
    3749             :      * gets used for ALTER TABLE SET TABLESPACE that could cascade across
    3750             :      * toast relations.
    3751             :      */
    3752        7778 :     if (OidIsValid(params->tablespaceOid) &&
    3753          62 :         IsSystemRelation(iRel))
    3754          34 :         ereport(ERROR,
    3755             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    3756             :                  errmsg("cannot move system relation \"%s\"",
    3757             :                         RelationGetRelationName(iRel))));
    3758             : 
    3759             :     /* Check if the tablespace of this index needs to be changed */
    3760        7704 :     if (OidIsValid(params->tablespaceOid) &&
    3761          28 :         CheckRelationTableSpaceMove(iRel, params->tablespaceOid))
    3762          14 :         set_tablespace = true;
    3763             : 
    3764             :     /*
    3765             :      * Also check for active uses of the index in the current transaction; we
    3766             :      * don't want to reindex underneath an open indexscan.
    3767             :      */
    3768        7676 :     CheckTableNotInUse(iRel, "REINDEX INDEX");
    3769             : 
    3770             :     /* Set new tablespace, if requested */
    3771        7676 :     if (set_tablespace)
    3772             :     {
    3773             :         /* Update its pg_class row */
    3774          14 :         SetRelationTableSpace(iRel, params->tablespaceOid, InvalidOid);
    3775             : 
    3776             :         /*
    3777             :          * Schedule unlinking of the old index storage at transaction commit.
    3778             :          */
    3779          14 :         RelationDropStorage(iRel);
    3780          14 :         RelationAssumeNewRelfilelocator(iRel);
    3781             : 
    3782             :         /* Make sure the reltablespace change is visible */
    3783          14 :         CommandCounterIncrement();
    3784             :     }
    3785             : 
    3786             :     /*
    3787             :      * All predicate locks on the index are about to be made invalid. Promote
    3788             :      * them to relation locks on the heap.
    3789             :      */
    3790        7676 :     TransferPredicateLocksToHeapRelation(iRel);
    3791             : 
    3792             :     /* Fetch info needed for index_build */
    3793        7676 :     indexInfo = BuildIndexInfo(iRel);
    3794             : 
    3795             :     /* If requested, skip checking uniqueness/exclusion constraints */
    3796        7676 :     if (skip_constraint_checks)
    3797             :     {
    3798        3734 :         if (indexInfo->ii_Unique || indexInfo->ii_ExclusionOps != NULL)
    3799        3182 :             skipped_constraint = true;
    3800        3734 :         indexInfo->ii_Unique = false;
    3801        3734 :         indexInfo->ii_ExclusionOps = NULL;
    3802        3734 :         indexInfo->ii_ExclusionProcs = NULL;
    3803        3734 :         indexInfo->ii_ExclusionStrats = NULL;
    3804             :     }
    3805             : 
    3806             :     /* Suppress use of the target index while rebuilding it */
    3807        7676 :     SetReindexProcessing(heapId, indexId);
    3808             : 
    3809             :     /* Create a new physical relation for the index */
    3810        7676 :     RelationSetNewRelfilenumber(iRel, persistence);
    3811             : 
    3812             :     /* Initialize the index and rebuild */
    3813             :     /* Note: we do not need to re-establish pkey setting */
    3814        7676 :     index_build(heapRelation, iRel, indexInfo, true, true);
    3815             : 
    3816             :     /* Re-allow use of target index */
    3817        7652 :     ResetReindexProcessing();
    3818             : 
    3819             :     /*
    3820             :      * If the index is marked invalid/not-ready/dead (ie, it's from a failed
    3821             :      * CREATE INDEX CONCURRENTLY, or a DROP INDEX CONCURRENTLY failed midway),
    3822             :      * and we didn't skip a uniqueness check, we can now mark it valid.  This
    3823             :      * allows REINDEX to be used to clean up in such cases.
    3824             :      *
    3825             :      * We can also reset indcheckxmin, because we have now done a
    3826             :      * non-concurrent index build, *except* in the case where index_build
    3827             :      * found some still-broken HOT chains. If it did, and we don't have to
    3828             :      * change any of the other flags, we just leave indcheckxmin alone (note
    3829             :      * that index_build won't have changed it, because this is a reindex).
    3830             :      * This is okay and desirable because not updating the tuple leaves the
    3831             :      * index's usability horizon (recorded as the tuple's xmin value) the same
    3832             :      * as it was.
    3833             :      *
    3834             :      * But, if the index was invalid/not-ready/dead and there were broken HOT
    3835             :      * chains, we had better force indcheckxmin true, because the normal
    3836             :      * argument that the HOT chains couldn't conflict with the index is
    3837             :      * suspect for an invalid index.  (A conflict is definitely possible if
    3838             :      * the index was dead.  It probably shouldn't happen otherwise, but let's
    3839             :      * be conservative.)  In this case advancing the usability horizon is
    3840             :      * appropriate.
    3841             :      *
    3842             :      * Another reason for avoiding unnecessary updates here is that while
    3843             :      * reindexing pg_index itself, we must not try to update tuples in it.
    3844             :      * pg_index's indexes should always have these flags in their clean state,
    3845             :      * so that won't happen.
    3846             :      */
    3847        7652 :     if (!skipped_constraint)
    3848             :     {
    3849             :         Relation    pg_index;
    3850             :         HeapTuple   indexTuple;
    3851             :         Form_pg_index indexForm;
    3852             :         bool        index_bad;
    3853             : 
    3854        4470 :         pg_index = table_open(IndexRelationId, RowExclusiveLock);
    3855             : 
    3856        4470 :         indexTuple = SearchSysCacheCopy1(INDEXRELID,
    3857             :                                          ObjectIdGetDatum(indexId));
    3858        4470 :         if (!HeapTupleIsValid(indexTuple))
    3859           0 :             elog(ERROR, "cache lookup failed for index %u", indexId);
    3860        4470 :         indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
    3861             : 
    3862       13404 :         index_bad = (!indexForm->indisvalid ||
    3863        8934 :                      !indexForm->indisready ||
    3864        4464 :                      !indexForm->indislive);
    3865        4470 :         if (index_bad ||
    3866        4464 :             (indexForm->indcheckxmin && !indexInfo->ii_BrokenHotChain))
    3867             :         {
    3868           6 :             if (!indexInfo->ii_BrokenHotChain)
    3869           6 :                 indexForm->indcheckxmin = false;
    3870           0 :             else if (index_bad)
    3871           0 :                 indexForm->indcheckxmin = true;
    3872           6 :             indexForm->indisvalid = true;
    3873           6 :             indexForm->indisready = true;
    3874           6 :             indexForm->indislive = true;
    3875           6 :             CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
    3876             : 
    3877             :             /*
    3878             :              * Invalidate the relcache for the table, so that after we commit
    3879             :              * all sessions will refresh the table's index list.  This ensures
    3880             :              * that if anyone misses seeing the pg_index row during this
    3881             :              * update, they'll refresh their list before attempting any update
    3882             :              * on the table.
    3883             :              */
    3884           6 :             CacheInvalidateRelcache(heapRelation);
    3885             :         }
    3886             : 
    3887        4470 :         table_close(pg_index, RowExclusiveLock);
    3888             :     }
    3889             : 
    3890             :     /* Log what we did */
    3891        7652 :     if ((params->options & REINDEXOPT_VERBOSE) != 0)
    3892          14 :         ereport(INFO,
    3893             :                 (errmsg("index \"%s\" was reindexed",
    3894             :                         get_rel_name(indexId)),
    3895             :                  errdetail_internal("%s",
    3896             :                                     pg_rusage_show(&ru0))));
    3897             : 
    3898             :     /* Roll back any GUC changes executed by index functions */
    3899        7652 :     AtEOXact_GUC(false, save_nestlevel);
    3900             : 
    3901             :     /* Restore userid and security context */
    3902        7652 :     SetUserIdAndSecContext(save_userid, save_sec_context);
    3903             : 
    3904             :     /* Close rels, but keep locks */
    3905        7652 :     index_close(iRel, NoLock);
    3906        7652 :     table_close(heapRelation, NoLock);
    3907             : 
    3908        7652 :     if (progress)
    3909        3214 :         pgstat_progress_end_command();
    3910             : }
    3911             : 
    3912             : /*
    3913             :  * reindex_relation - This routine is used to recreate all indexes
    3914             :  * of a relation (and optionally its toast relation too, if any).
    3915             :  *
    3916             :  * "flags" is a bitmask that can include any combination of these bits:
    3917             :  *
    3918             :  * REINDEX_REL_PROCESS_TOAST: if true, process the toast table too (if any).
    3919             :  *
    3920             :  * REINDEX_REL_SUPPRESS_INDEX_USE: if true, the relation was just completely
    3921             :  * rebuilt by an operation such as VACUUM FULL or CLUSTER, and therefore its
    3922             :  * indexes are inconsistent with it.  This makes things tricky if the relation
    3923             :  * is a system catalog that we might consult during the reindexing.  To deal
    3924             :  * with that case, we mark all of the indexes as pending rebuild so that they
    3925             :  * won't be trusted until rebuilt.  The caller is required to call us *without*
    3926             :  * having made the rebuilt table visible by doing CommandCounterIncrement;
    3927             :  * we'll do CCI after having collected the index list.  (This way we can still
    3928             :  * use catalog indexes while collecting the list.)
    3929             :  *
    3930             :  * REINDEX_REL_CHECK_CONSTRAINTS: if true, recheck unique and exclusion
    3931             :  * constraint conditions, else don't.  To avoid deadlocks, VACUUM FULL or
    3932             :  * CLUSTER on a system catalog must omit this flag.  REINDEX should be used to
    3933             :  * rebuild an index if constraint inconsistency is suspected.  For optimal
    3934             :  * performance, other callers should include the flag only after transforming
    3935             :  * the data in a manner that risks a change in constraint validity.
    3936             :  *
    3937             :  * REINDEX_REL_FORCE_INDEXES_UNLOGGED: if true, set the persistence of the
    3938             :  * rebuilt indexes to unlogged.
    3939             :  *
    3940             :  * REINDEX_REL_FORCE_INDEXES_PERMANENT: if true, set the persistence of the
    3941             :  * rebuilt indexes to permanent.
    3942             :  *
    3943             :  * Returns true if any indexes were rebuilt (including toast table's index
    3944             :  * when relevant).  Note that a CommandCounterIncrement will occur after each
    3945             :  * index rebuild.
    3946             :  */
    3947             : bool
    3948        8778 : reindex_relation(const ReindexStmt *stmt, Oid relid, int flags,
    3949             :                  const ReindexParams *params)
    3950             : {
    3951             :     Relation    rel;
    3952             :     Oid         toast_relid;
    3953             :     List       *indexIds;
    3954             :     char        persistence;
    3955        8778 :     bool        result = false;
    3956             :     ListCell   *indexId;
    3957             :     int         i;
    3958             : 
    3959             :     /*
    3960             :      * Open and lock the relation.  ShareLock is sufficient since we only need
    3961             :      * to prevent schema and data changes in it.  The lock level used here
    3962             :      * should match ReindexTable().
    3963             :      */
    3964        8778 :     if ((params->options & REINDEXOPT_MISSING_OK) != 0)
    3965        1280 :         rel = try_table_open(relid, ShareLock);
    3966             :     else
    3967        7498 :         rel = table_open(relid, ShareLock);
    3968             : 
    3969             :     /* if relation is gone, leave */
    3970        8778 :     if (!rel)
    3971           0 :         return false;
    3972             : 
    3973             :     /*
    3974             :      * Partitioned tables should never get processed here, as they have no
    3975             :      * physical storage.
    3976             :      */
    3977        8778 :     if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    3978           0 :         elog(ERROR, "cannot reindex partitioned table \"%s.%s\"",
    3979             :              get_namespace_name(RelationGetNamespace(rel)),
    3980             :              RelationGetRelationName(rel));
    3981             : 
    3982        8778 :     toast_relid = rel->rd_rel->reltoastrelid;
    3983             : 
    3984             :     /*
    3985             :      * Get the list of index OIDs for this relation.  (We trust the relcache
    3986             :      * to get this with a sequential scan if ignoring system indexes.)
    3987             :      */
    3988        8778 :     indexIds = RelationGetIndexList(rel);
    3989             : 
    3990        8778 :     if (flags & REINDEX_REL_SUPPRESS_INDEX_USE)
    3991             :     {
    3992             :         /* Suppress use of all the indexes until they are rebuilt */
    3993        1964 :         SetReindexPending(indexIds);
    3994             : 
    3995             :         /*
    3996             :          * Make the new heap contents visible --- now things might be
    3997             :          * inconsistent!
    3998             :          */
    3999        1964 :         CommandCounterIncrement();
    4000             :     }
    4001             : 
    4002             :     /*
    4003             :      * Reindex the toast table, if any, before the main table.
    4004             :      *
    4005             :      * This helps in cases where a corruption in the toast table's index would
    4006             :      * otherwise error and stop REINDEX TABLE command when it tries to fetch a
    4007             :      * toasted datum.  This way. the toast table's index is rebuilt and fixed
    4008             :      * before it is used for reindexing the main table.
    4009             :      *
    4010             :      * It is critical to call reindex_relation() *after* the call to
    4011             :      * RelationGetIndexList() returning the list of indexes on the relation,
    4012             :      * because reindex_relation() will call CommandCounterIncrement() after
    4013             :      * every reindex_index().  See REINDEX_REL_SUPPRESS_INDEX_USE for more
    4014             :      * details.
    4015             :      */
    4016        8778 :     if ((flags & REINDEX_REL_PROCESS_TOAST) && OidIsValid(toast_relid))
    4017             :     {
    4018             :         /*
    4019             :          * Note that this should fail if the toast relation is missing, so
    4020             :          * reset REINDEXOPT_MISSING_OK.  Even if a new tablespace is set for
    4021             :          * the parent relation, the indexes on its toast table are not moved.
    4022             :          * This rule is enforced by setting tablespaceOid to InvalidOid.
    4023             :          */
    4024        2528 :         ReindexParams newparams = *params;
    4025             : 
    4026        2528 :         newparams.options &= ~(REINDEXOPT_MISSING_OK);
    4027        2528 :         newparams.tablespaceOid = InvalidOid;
    4028        2528 :         result |= reindex_relation(stmt, toast_relid, flags, &newparams);
    4029             :     }
    4030             : 
    4031             :     /*
    4032             :      * Compute persistence of indexes: same as that of owning rel, unless
    4033             :      * caller specified otherwise.
    4034             :      */
    4035        8778 :     if (flags & REINDEX_REL_FORCE_INDEXES_UNLOGGED)
    4036          38 :         persistence = RELPERSISTENCE_UNLOGGED;
    4037        8740 :     else if (flags & REINDEX_REL_FORCE_INDEXES_PERMANENT)
    4038        1846 :         persistence = RELPERSISTENCE_PERMANENT;
    4039             :     else
    4040        6894 :         persistence = rel->rd_rel->relpersistence;
    4041             : 
    4042             :     /* Reindex all the indexes. */
    4043        8778 :     i = 1;
    4044       16296 :     foreach(indexId, indexIds)
    4045             :     {
    4046        7568 :         Oid         indexOid = lfirst_oid(indexId);
    4047        7568 :         Oid         indexNamespaceId = get_rel_namespace(indexOid);
    4048             : 
    4049             :         /*
    4050             :          * Skip any invalid indexes on a TOAST table.  These can only be
    4051             :          * duplicate leftovers from a failed REINDEX CONCURRENTLY, and if
    4052             :          * rebuilt it would not be possible to drop them anymore.
    4053             :          */
    4054        7568 :         if (IsToastNamespace(indexNamespaceId) &&
    4055        2548 :             !get_index_isvalid(indexOid))
    4056             :         {
    4057           0 :             ereport(WARNING,
    4058             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    4059             :                      errmsg("cannot reindex invalid index \"%s.%s\" on TOAST table, skipping",
    4060             :                             get_namespace_name(indexNamespaceId),
    4061             :                             get_rel_name(indexOid))));
    4062             : 
    4063             :             /*
    4064             :              * Remove this invalid toast index from the reindex pending list,
    4065             :              * as it is skipped here due to the hard failure that would happen
    4066             :              * in reindex_index(), should we try to process it.
    4067             :              */
    4068           0 :             if (flags & REINDEX_REL_SUPPRESS_INDEX_USE)
    4069           0 :                 RemoveReindexPending(indexOid);
    4070           0 :             continue;
    4071             :         }
    4072             : 
    4073        7568 :         reindex_index(stmt, indexOid, !(flags & REINDEX_REL_CHECK_CONSTRAINTS),
    4074             :                       persistence, params);
    4075             : 
    4076        7518 :         CommandCounterIncrement();
    4077             : 
    4078             :         /* Index should no longer be in the pending list */
    4079             :         Assert(!ReindexIsProcessingIndex(indexOid));
    4080             : 
    4081             :         /* Set index rebuild count */
    4082        7518 :         pgstat_progress_update_param(PROGRESS_CLUSTER_INDEX_REBUILD_COUNT,
    4083             :                                      i);
    4084        7518 :         i++;
    4085             :     }
    4086             : 
    4087             :     /*
    4088             :      * Close rel, but continue to hold the lock.
    4089             :      */
    4090        8728 :     table_close(rel, NoLock);
    4091             : 
    4092        8728 :     result |= (indexIds != NIL);
    4093             : 
    4094        8728 :     return result;
    4095             : }
    4096             : 
    4097             : 
    4098             : /* ----------------------------------------------------------------
    4099             :  *      System index reindexing support
    4100             :  *
    4101             :  * When we are busy reindexing a system index, this code provides support
    4102             :  * for preventing catalog lookups from using that index.  We also make use
    4103             :  * of this to catch attempted uses of user indexes during reindexing of
    4104             :  * those indexes.  This information is propagated to parallel workers;
    4105             :  * attempting to change it during a parallel operation is not permitted.
    4106             :  * ----------------------------------------------------------------
    4107             :  */
    4108             : 
    4109             : static Oid  currentlyReindexedHeap = InvalidOid;
    4110             : static Oid  currentlyReindexedIndex = InvalidOid;
    4111             : static List *pendingReindexedIndexes = NIL;
    4112             : static int  reindexingNestLevel = 0;
    4113             : 
    4114             : /*
    4115             :  * ReindexIsProcessingHeap
    4116             :  *      True if heap specified by OID is currently being reindexed.
    4117             :  */
    4118             : bool
    4119           0 : ReindexIsProcessingHeap(Oid heapOid)
    4120             : {
    4121           0 :     return heapOid == currentlyReindexedHeap;
    4122             : }
    4123             : 
    4124             : /*
    4125             :  * ReindexIsCurrentlyProcessingIndex
    4126             :  *      True if index specified by OID is currently being reindexed.
    4127             :  */
    4128             : static bool
    4129         734 : ReindexIsCurrentlyProcessingIndex(Oid indexOid)
    4130             : {
    4131         734 :     return indexOid == currentlyReindexedIndex;
    4132             : }
    4133             : 
    4134             : /*
    4135             :  * ReindexIsProcessingIndex
    4136             :  *      True if index specified by OID is currently being reindexed,
    4137             :  *      or should be treated as invalid because it is awaiting reindex.
    4138             :  */
    4139             : bool
    4140    40242156 : ReindexIsProcessingIndex(Oid indexOid)
    4141             : {
    4142    80474218 :     return indexOid == currentlyReindexedIndex ||
    4143    40232062 :         list_member_oid(pendingReindexedIndexes, indexOid);
    4144             : }
    4145             : 
    4146             : /*
    4147             :  * SetReindexProcessing
    4148             :  *      Set flag that specified heap/index are being reindexed.
    4149             :  */
    4150             : static void
    4151        7676 : SetReindexProcessing(Oid heapOid, Oid indexOid)
    4152             : {
    4153             :     Assert(OidIsValid(heapOid) && OidIsValid(indexOid));
    4154             :     /* Reindexing is not re-entrant. */
    4155        7676 :     if (OidIsValid(currentlyReindexedHeap))
    4156           0 :         elog(ERROR, "cannot reindex while reindexing");
    4157        7676 :     currentlyReindexedHeap = heapOid;
    4158        7676 :     currentlyReindexedIndex = indexOid;
    4159             :     /* Index is no longer "pending" reindex. */
    4160        7676 :     RemoveReindexPending(indexOid);
    4161             :     /* This may have been set already, but in case it isn't, do so now. */
    4162        7676 :     reindexingNestLevel = GetCurrentTransactionNestLevel();
    4163        7676 : }
    4164             : 
    4165             : /*
    4166             :  * ResetReindexProcessing
    4167             :  *      Unset reindexing status.
    4168             :  */
    4169             : static void
    4170        7730 : ResetReindexProcessing(void)
    4171             : {
    4172        7730 :     currentlyReindexedHeap = InvalidOid;
    4173        7730 :     currentlyReindexedIndex = InvalidOid;
    4174             :     /* reindexingNestLevel remains set till end of (sub)transaction */
    4175        7730 : }
    4176             : 
    4177             : /*
    4178             :  * SetReindexPending
    4179             :  *      Mark the given indexes as pending reindex.
    4180             :  *
    4181             :  * NB: we assume that the current memory context stays valid throughout.
    4182             :  */
    4183             : static void
    4184        1964 : SetReindexPending(List *indexes)
    4185             : {
    4186             :     /* Reindexing is not re-entrant. */
    4187        1964 :     if (pendingReindexedIndexes)
    4188           0 :         elog(ERROR, "cannot reindex while reindexing");
    4189        1964 :     if (IsInParallelMode())
    4190           0 :         elog(ERROR, "cannot modify reindex state during a parallel operation");
    4191        1964 :     pendingReindexedIndexes = list_copy(indexes);
    4192        1964 :     reindexingNestLevel = GetCurrentTransactionNestLevel();
    4193        1964 : }
    4194             : 
    4195             : /*
    4196             :  * RemoveReindexPending
    4197             :  *      Remove the given index from the pending list.
    4198             :  */
    4199             : static void
    4200        7676 : RemoveReindexPending(Oid indexOid)
    4201             : {
    4202        7676 :     if (IsInParallelMode())
    4203           0 :         elog(ERROR, "cannot modify reindex state during a parallel operation");
    4204        7676 :     pendingReindexedIndexes = list_delete_oid(pendingReindexedIndexes,
    4205             :                                               indexOid);
    4206        7676 : }
    4207             : 
    4208             : /*
    4209             :  * ResetReindexState
    4210             :  *      Clear all reindexing state during (sub)transaction abort.
    4211             :  */
    4212             : void
    4213       57628 : ResetReindexState(int nestLevel)
    4214             : {
    4215             :     /*
    4216             :      * Because reindexing is not re-entrant, we don't need to cope with nested
    4217             :      * reindexing states.  We just need to avoid messing up the outer-level
    4218             :      * state in case a subtransaction fails within a REINDEX.  So checking the
    4219             :      * current nest level against that of the reindex operation is sufficient.
    4220             :      */
    4221       57628 :     if (reindexingNestLevel >= nestLevel)
    4222             :     {
    4223        1276 :         currentlyReindexedHeap = InvalidOid;
    4224        1276 :         currentlyReindexedIndex = InvalidOid;
    4225             : 
    4226             :         /*
    4227             :          * We needn't try to release the contents of pendingReindexedIndexes;
    4228             :          * that list should be in a transaction-lifespan context, so it will
    4229             :          * go away automatically.
    4230             :          */
    4231        1276 :         pendingReindexedIndexes = NIL;
    4232             : 
    4233        1276 :         reindexingNestLevel = 0;
    4234             :     }
    4235       57628 : }
    4236             : 
    4237             : /*
    4238             :  * EstimateReindexStateSpace
    4239             :  *      Estimate space needed to pass reindex state to parallel workers.
    4240             :  */
    4241             : Size
    4242         910 : EstimateReindexStateSpace(void)
    4243             : {
    4244             :     return offsetof(SerializedReindexState, pendingReindexedIndexes)
    4245         910 :         + mul_size(sizeof(Oid), list_length(pendingReindexedIndexes));
    4246             : }
    4247             : 
    4248             : /*
    4249             :  * SerializeReindexState
    4250             :  *      Serialize reindex state for parallel workers.
    4251             :  */
    4252             : void
    4253         910 : SerializeReindexState(Size maxsize, char *start_address)
    4254             : {
    4255         910 :     SerializedReindexState *sistate = (SerializedReindexState *) start_address;
    4256         910 :     int         c = 0;
    4257             :     ListCell   *lc;
    4258             : 
    4259         910 :     sistate->currentlyReindexedHeap = currentlyReindexedHeap;
    4260         910 :     sistate->currentlyReindexedIndex = currentlyReindexedIndex;
    4261         910 :     sistate->numPendingReindexedIndexes = list_length(pendingReindexedIndexes);
    4262         910 :     foreach(lc, pendingReindexedIndexes)
    4263           0 :         sistate->pendingReindexedIndexes[c++] = lfirst_oid(lc);
    4264         910 : }
    4265             : 
    4266             : /*
    4267             :  * RestoreReindexState
    4268             :  *      Restore reindex state in a parallel worker.
    4269             :  */
    4270             : void
    4271        2736 : RestoreReindexState(const void *reindexstate)
    4272             : {
    4273        2736 :     const SerializedReindexState *sistate = (const SerializedReindexState *) reindexstate;
    4274        2736 :     int         c = 0;
    4275             :     MemoryContext oldcontext;
    4276             : 
    4277        2736 :     currentlyReindexedHeap = sistate->currentlyReindexedHeap;
    4278        2736 :     currentlyReindexedIndex = sistate->currentlyReindexedIndex;
    4279             : 
    4280             :     Assert(pendingReindexedIndexes == NIL);
    4281        2736 :     oldcontext = MemoryContextSwitchTo(TopMemoryContext);
    4282        2736 :     for (c = 0; c < sistate->numPendingReindexedIndexes; ++c)
    4283           0 :         pendingReindexedIndexes =
    4284           0 :             lappend_oid(pendingReindexedIndexes,
    4285             :                         sistate->pendingReindexedIndexes[c]);
    4286        2736 :     MemoryContextSwitchTo(oldcontext);
    4287             : 
    4288             :     /* Note the worker has its own transaction nesting level */
    4289        2736 :     reindexingNestLevel = GetCurrentTransactionNestLevel();
    4290        2736 : }

Generated by: LCOV version 1.14