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

Generated by: LCOV version 1.13