index.h File Reference

#include "catalog/objectaddress.h"
#include "nodes/execnodes.h"

Include dependency graph for index.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ReindexParams
struct	ValidateIndexState

Macros
#define	DEFAULT_INDEX_TYPE   "btree"
#define	REINDEXOPT_VERBOSE   0x01 /* print progress info */
#define	REINDEXOPT_REPORT_PROGRESS   0x02 /* report pgstat progress */
#define	REINDEXOPT_MISSING_OK   0x04 /* skip missing relations */
#define	REINDEXOPT_CONCURRENTLY   0x08 /* concurrent mode */
#define	INDEX_CREATE_IS_PRIMARY   (1 << 0)
#define	INDEX_CREATE_ADD_CONSTRAINT   (1 << 1)
#define	INDEX_CREATE_SKIP_BUILD   (1 << 2)
#define	INDEX_CREATE_CONCURRENT   (1 << 3)
#define	INDEX_CREATE_IF_NOT_EXISTS   (1 << 4)
#define	INDEX_CREATE_PARTITIONED   (1 << 5)
#define	INDEX_CREATE_INVALID   (1 << 6)
#define	INDEX_CREATE_SUPPRESS_PROGRESS   (1 << 7)
#define	INDEX_CONSTR_CREATE_MARK_AS_PRIMARY   (1 << 0)
#define	INDEX_CONSTR_CREATE_DEFERRABLE   (1 << 1)
#define	INDEX_CONSTR_CREATE_INIT_DEFERRED   (1 << 2)
#define	INDEX_CONSTR_CREATE_UPDATE_INDEX   (1 << 3)
#define	INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS   (1 << 4)
#define	INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS   (1 << 5)
#define	REINDEX_REL_PROCESS_TOAST   0x01
#define	REINDEX_REL_SUPPRESS_INDEX_USE   0x02
#define	REINDEX_REL_CHECK_CONSTRAINTS   0x04
#define	REINDEX_REL_FORCE_INDEXES_UNLOGGED   0x08
#define	REINDEX_REL_FORCE_INDEXES_PERMANENT   0x10

Typedefs
typedef struct AttrMap	AttrMap
typedef struct ReindexParams	ReindexParams
typedef struct ValidateIndexState	ValidateIndexState

Enumerations
enum	IndexStateFlagsAction { INDEX_CREATE_SET_READY , INDEX_CREATE_SET_VALID , INDEX_DROP_CLEAR_VALID , INDEX_DROP_SET_DEAD }

Functions
void	index_check_primary_key (Relation heapRel, const IndexInfo *indexInfo, bool is_alter_table, const IndexStmt *stmt)
Oid	index_create (Relation heapRelation, const char *indexRelationName, Oid indexRelationId, Oid parentIndexRelid, Oid parentConstraintId, RelFileNumber relFileNumber, IndexInfo *indexInfo, const List *indexColNames, Oid accessMethodId, Oid tableSpaceId, const Oid *collationIds, const Oid *opclassIds, const Datum *opclassOptions, const int16 *coloptions, const NullableDatum *stattargets, Datum reloptions, uint16 flags, uint16 constr_flags, bool allow_system_table_mods, bool is_internal, Oid *constraintId)
Oid	index_create_copy (Relation heapRelation, uint16 flags, Oid oldIndexId, Oid tablespaceOid, const char *newName)
void	index_concurrently_build (Oid heapRelationId, Oid indexRelationId)
void	index_concurrently_swap (Oid newIndexId, Oid oldIndexId, const char *oldName)
void	index_concurrently_set_dead (Oid heapId, Oid indexId)
ObjectAddress	index_constraint_create (Relation heapRelation, Oid indexRelationId, Oid parentConstraintId, const IndexInfo *indexInfo, const char *constraintName, char constraintType, uint16 constr_flags, bool allow_system_table_mods, bool is_internal)
void	index_drop (Oid indexId, bool concurrent, bool concurrent_lock_mode)
IndexInfo *	BuildIndexInfo (Relation index)
IndexInfo *	BuildDummyIndexInfo (Relation index)
bool	CompareIndexInfo (const IndexInfo *info1, const IndexInfo *info2, const Oid *collations1, const Oid *collations2, const Oid *opfamilies1, const Oid *opfamilies2, const AttrMap *attmap)
void	BuildSpeculativeIndexInfo (Relation index, IndexInfo *ii)
void	FormIndexDatum (IndexInfo *indexInfo, TupleTableSlot *slot, EState *estate, Datum *values, bool *isnull)
void	index_build (Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool isreindex, bool parallel, bool progress)
void	validate_index (Oid heapId, Oid indexId, Snapshot snapshot)
void	index_set_state_flags (Oid indexId, IndexStateFlagsAction action)
Oid	IndexGetRelation (Oid indexId, bool missing_ok)
void	reindex_index (const ReindexStmt *stmt, Oid indexId, bool skip_constraint_checks, char persistence, const ReindexParams *params)
bool	reindex_relation (const ReindexStmt *stmt, Oid relid, int flags, const ReindexParams *params)
bool	ReindexIsProcessingHeap (Oid heapOid)
bool	ReindexIsProcessingIndex (Oid indexOid)
void	ResetReindexState (int nestLevel)
Size	EstimateReindexStateSpace (void)
void	SerializeReindexState (Size maxsize, char *start_address)
void	RestoreReindexState (const void *reindexstate)
void	IndexSetParentIndex (Relation partitionIdx, Oid parentOid)
static int64	itemptr_encode (const ItemPointerData *itemptr)
static void	itemptr_decode (ItemPointer itemptr, int64 encoded)

Macro Definition Documentation

DEFAULT_INDEX_TYPE

#define DEFAULT_INDEX_TYPE   "btree"

Definition at line 27 of file index.h.

INDEX_CONSTR_CREATE_DEFERRABLE

#define INDEX_CONSTR_CREATE_DEFERRABLE   (1 << 1)

Definition at line 99 of file index.h.

INDEX_CONSTR_CREATE_INIT_DEFERRED

#define INDEX_CONSTR_CREATE_INIT_DEFERRED   (1 << 2)

Definition at line 100 of file index.h.

INDEX_CONSTR_CREATE_MARK_AS_PRIMARY

#define INDEX_CONSTR_CREATE_MARK_AS_PRIMARY   (1 << 0)

Definition at line 98 of file index.h.

INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS

#define INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS   (1 << 4)

Definition at line 102 of file index.h.

INDEX_CONSTR_CREATE_UPDATE_INDEX

#define INDEX_CONSTR_CREATE_UPDATE_INDEX   (1 << 3)

Definition at line 101 of file index.h.

INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS

#define INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS   (1 << 5)

Definition at line 103 of file index.h.

INDEX_CREATE_ADD_CONSTRAINT

#define INDEX_CREATE_ADD_CONSTRAINT   (1 << 1)

Definition at line 68 of file index.h.

INDEX_CREATE_CONCURRENT

#define INDEX_CREATE_CONCURRENT   (1 << 3)

Definition at line 70 of file index.h.

INDEX_CREATE_IF_NOT_EXISTS

#define INDEX_CREATE_IF_NOT_EXISTS   (1 << 4)

Definition at line 71 of file index.h.

INDEX_CREATE_INVALID

#define INDEX_CREATE_INVALID   (1 << 6)

Definition at line 73 of file index.h.

INDEX_CREATE_IS_PRIMARY

#define INDEX_CREATE_IS_PRIMARY   (1 << 0)

Definition at line 67 of file index.h.

INDEX_CREATE_PARTITIONED

#define INDEX_CREATE_PARTITIONED   (1 << 5)

Definition at line 72 of file index.h.

INDEX_CREATE_SKIP_BUILD

#define INDEX_CREATE_SKIP_BUILD   (1 << 2)

Definition at line 69 of file index.h.

INDEX_CREATE_SUPPRESS_PROGRESS

#define INDEX_CREATE_SUPPRESS_PROGRESS   (1 << 7)

Definition at line 74 of file index.h.

REINDEX_REL_CHECK_CONSTRAINTS

#define REINDEX_REL_CHECK_CONSTRAINTS   0x04

Definition at line 168 of file index.h.

REINDEX_REL_FORCE_INDEXES_PERMANENT

#define REINDEX_REL_FORCE_INDEXES_PERMANENT   0x10

Definition at line 170 of file index.h.

REINDEX_REL_FORCE_INDEXES_UNLOGGED

#define REINDEX_REL_FORCE_INDEXES_UNLOGGED   0x08

Definition at line 169 of file index.h.

REINDEX_REL_PROCESS_TOAST

#define REINDEX_REL_PROCESS_TOAST   0x01

Definition at line 166 of file index.h.

REINDEX_REL_SUPPRESS_INDEX_USE

#define REINDEX_REL_SUPPRESS_INDEX_USE   0x02

Definition at line 167 of file index.h.

REINDEXOPT_CONCURRENTLY

#define REINDEXOPT_CONCURRENTLY   0x08 /* concurrent mode */

Definition at line 50 of file index.h.

REINDEXOPT_MISSING_OK

#define REINDEXOPT_MISSING_OK   0x04 /* skip missing relations */

Definition at line 49 of file index.h.

REINDEXOPT_REPORT_PROGRESS

#define REINDEXOPT_REPORT_PROGRESS   0x02 /* report pgstat progress */

Definition at line 48 of file index.h.

REINDEXOPT_VERBOSE

#define REINDEXOPT_VERBOSE   0x01 /* print progress info */

Definition at line 47 of file index.h.

Typedef Documentation

AttrMap

typedef struct AttrMap AttrMap

Definition at line 24 of file index.h.

ReindexParams

typedef struct ReindexParams ReindexParams

ValidateIndexState

typedef struct ValidateIndexState ValidateIndexState

Enumeration Type Documentation

IndexStateFlagsAction

enum IndexStateFlagsAction

Enumerator
INDEX_CREATE_SET_READY
INDEX_CREATE_SET_VALID
INDEX_DROP_CLEAR_VALID
INDEX_DROP_SET_DEAD

Definition at line 30 of file index.h.

{
    INDEX_CREATE_SET_READY,
    INDEX_CREATE_SET_VALID,
    INDEX_DROP_CLEAR_VALID,
    INDEX_DROP_SET_DEAD,
} IndexStateFlagsAction;

Function Documentation

BuildDummyIndexInfo()

IndexInfo * BuildDummyIndexInfo ( Relation  index )

extern

Definition at line 2506 of file index.c.

{
    IndexInfo  *ii;
    Form_pg_index indexStruct = index->rd_index;
    int         i;
    int         numAtts;
 
    /* check the number of keys, and copy attr numbers into the IndexInfo */
    numAtts = indexStruct->indnatts;
    if (numAtts < 1 || numAtts > INDEX_MAX_KEYS)
        elog(ERROR, "invalid indnatts %d for index %u",
             numAtts, RelationGetRelid(index));
 
    /*
     * Create the node, using dummy index expressions, and pretending there is
     * no predicate.
     */
    ii = makeIndexInfo(indexStruct->indnatts,
                       indexStruct->indnkeyatts,
                       index->rd_rel->relam,
                       RelationGetDummyIndexExpressions(index),
                       NIL,
                       indexStruct->indisunique,
                       indexStruct->indnullsnotdistinct,
                       indexStruct->indisready,
                       false,
                       index->rd_indam->amsummarizing,
                       indexStruct->indisexclusion && indexStruct->indisunique);
 
    /* fill in attribute numbers */
    for (i = 0; i < numAtts; i++)
        ii->ii_IndexAttrNumbers[i] = indexStruct->indkey.values[i];
 
    /* We ignore the exclusion constraint if any */
 
    return ii;
}

References elog, ERROR, fb(), Form_pg_index, i, IndexInfo::ii_IndexAttrNumbers, INDEX_MAX_KEYS, makeIndexInfo(), NIL, RelationGetDummyIndexExpressions(), and RelationGetRelid.

Referenced by RelationTruncateIndexes().

BuildIndexInfo()

IndexInfo * BuildIndexInfo ( Relation  index )

extern

Definition at line 2446 of file index.c.

{
    IndexInfo  *ii;
    Form_pg_index indexStruct = index->rd_index;
    int         i;
    int         numAtts;
 
    /* check the number of keys, and copy attr numbers into the IndexInfo */
    numAtts = indexStruct->indnatts;
    if (numAtts < 1 || numAtts > INDEX_MAX_KEYS)
        elog(ERROR, "invalid indnatts %d for index %u",
             numAtts, RelationGetRelid(index));
 
    /*
     * Create the node, fetching any expressions needed for expressional
     * indexes and index predicate if any.
     */
    ii = makeIndexInfo(indexStruct->indnatts,
                       indexStruct->indnkeyatts,
                       index->rd_rel->relam,
                       RelationGetIndexExpressions(index),
                       RelationGetIndexPredicate(index),
                       indexStruct->indisunique,
                       indexStruct->indnullsnotdistinct,
                       indexStruct->indisready,
                       false,
                       index->rd_indam->amsummarizing,
                       indexStruct->indisexclusion && indexStruct->indisunique);
 
    /* fill in attribute numbers */
    for (i = 0; i < numAtts; i++)
        ii->ii_IndexAttrNumbers[i] = indexStruct->indkey.values[i];
 
    /* fetch exclusion constraint info if any */
    if (indexStruct->indisexclusion)
    {
        RelationGetExclusionInfo(index,
                                 &ii->ii_ExclusionOps,
                                 &ii->ii_ExclusionProcs,
                                 &ii->ii_ExclusionStrats);
    }
 
    return ii;
}

References elog, ERROR, fb(), Form_pg_index, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ExclusionProcs, IndexInfo::ii_ExclusionStrats, IndexInfo::ii_IndexAttrNumbers, INDEX_MAX_KEYS, makeIndexInfo(), RelationGetExclusionInfo(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), and RelationGetRelid.

Referenced by _brin_parallel_scan_and_build(), _bt_parallel_scan_and_sort(), _gin_parallel_scan_and_build(), ATExecAddIndexConstraint(), ATExecAttachPartitionIdx(), AttachPartitionEnsureIndexes(), brinsummarize(), bt_check_every_level(), build_index_value_desc(), DefineIndex(), do_analyze_rel(), ExecOpenIndices(), index_concurrently_build(), index_create_copy(), recheck_matched_pk_tuple(), reindex_index(), tuplesort_begin_cluster(), unique_key_recheck(), and validate_index().

BuildSpeculativeIndexInfo()

void BuildSpeculativeIndexInfo ( Relation  index, IndexInfo *  ii  )

extern

Definition at line 2699 of file index.c.

{
    int         indnkeyatts;
    int         i;
 
    indnkeyatts = IndexRelationGetNumberOfKeyAttributes(index);
 
    /*
     * fetch info for checking unique indexes
     */
    Assert(ii->ii_Unique);
 
    ii->ii_UniqueOps = palloc_array(Oid, indnkeyatts);
    ii->ii_UniqueProcs = palloc_array(Oid, indnkeyatts);
    ii->ii_UniqueStrats = palloc_array(uint16, indnkeyatts);
 
    /*
     * We have to look up the operator's strategy number.  This provides a
     * cross-check that the operator does match the index.
     */
    /* We need the func OIDs and strategy numbers too */
    for (i = 0; i < indnkeyatts; i++)
    {
        ii->ii_UniqueStrats[i] =
            IndexAmTranslateCompareType(COMPARE_EQ,
                                        index->rd_rel->relam,
                                        index->rd_opfamily[i],
                                        false);
        ii->ii_UniqueOps[i] =
            get_opfamily_member(index->rd_opfamily[i],
                                index->rd_opcintype[i],
                                index->rd_opcintype[i],
                                ii->ii_UniqueStrats[i]);
        if (!OidIsValid(ii->ii_UniqueOps[i]))
            elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                 ii->ii_UniqueStrats[i], index->rd_opcintype[i],
                 index->rd_opcintype[i], index->rd_opfamily[i]);
        ii->ii_UniqueProcs[i] = get_opcode(ii->ii_UniqueOps[i]);
    }
}

References Assert, COMPARE_EQ, elog, ERROR, fb(), get_opcode(), get_opfamily_member(), i, IndexInfo::ii_Unique, IndexInfo::ii_UniqueOps, IndexInfo::ii_UniqueProcs, IndexInfo::ii_UniqueStrats, IndexAmTranslateCompareType(), IndexRelationGetNumberOfKeyAttributes, OidIsValid, and palloc_array.

Referenced by BuildConflictIndexInfo(), and ExecOpenIndices().

CompareIndexInfo()

bool CompareIndexInfo ( const IndexInfo *  info1, const IndexInfo *  info2, const Oid *  collations1, const Oid *  collations2, const Oid *  opfamilies1, const Oid *  opfamilies2, const AttrMap *  attmap  )

extern

Definition at line 2555 of file index.c.

{
    int         i;
 
    if (info1->ii_Unique != info2->ii_Unique)
        return false;
 
    if (info1->ii_NullsNotDistinct != info2->ii_NullsNotDistinct)
        return false;
 
    /* indexes are only equivalent if they have the same access method */
    if (info1->ii_Am != info2->ii_Am)
        return false;
 
    /* and same number of attributes */
    if (info1->ii_NumIndexAttrs != info2->ii_NumIndexAttrs)
        return false;
 
    /* and same number of key attributes */
    if (info1->ii_NumIndexKeyAttrs != info2->ii_NumIndexKeyAttrs)
        return false;
 
    /*
     * and columns match through the attribute map (actual attribute numbers
     * might differ!)  Note that this checks that index columns that are
     * expressions appear in the same positions.  We will next compare the
     * expressions themselves.
     */
    for (i = 0; i < info1->ii_NumIndexAttrs; i++)
    {
        if (attmap->maplen < info2->ii_IndexAttrNumbers[i])
            elog(ERROR, "incorrect attribute map");
 
        /* ignore expressions for now (but check their collation/opfamily) */
        if (!(info1->ii_IndexAttrNumbers[i] == InvalidAttrNumber &&
              info2->ii_IndexAttrNumbers[i] == InvalidAttrNumber))
        {
            /* fail if just one index has an expression in this column */
            if (info1->ii_IndexAttrNumbers[i] == InvalidAttrNumber ||
                info2->ii_IndexAttrNumbers[i] == InvalidAttrNumber)
                return false;
 
            /* both are columns, so check for match after mapping */
            if (attmap->attnums[info2->ii_IndexAttrNumbers[i] - 1] !=
                info1->ii_IndexAttrNumbers[i])
                return false;
        }
 
        /* collation and opfamily are not valid for included columns */
        if (i >= info1->ii_NumIndexKeyAttrs)
            continue;
 
        if (collations1[i] != collations2[i])
            return false;
        if (opfamilies1[i] != opfamilies2[i])
            return false;
    }
 
    /*
     * For expression indexes: either both are expression indexes, or neither
     * is; if they are, make sure the expressions match.
     */
    if ((info1->ii_Expressions != NIL) != (info2->ii_Expressions != NIL))
        return false;
    if (info1->ii_Expressions != NIL)
    {
        bool        found_whole_row;
        Node       *mapped;
 
        mapped = map_variable_attnos((Node *) info2->ii_Expressions,
                                     1, 0, attmap,
                                     InvalidOid, &found_whole_row);
        if (found_whole_row)
        {
            /*
             * we could throw an error here, but seems out of scope for this
             * routine.
             */
            return false;
        }
 
        if (!equal(info1->ii_Expressions, mapped))
            return false;
    }
 
    /* Partial index predicates must be identical, if they exist */
    if ((info1->ii_Predicate == NULL) != (info2->ii_Predicate == NULL))
        return false;
    if (info1->ii_Predicate != NULL)
    {
        bool        found_whole_row;
        Node       *mapped;
 
        mapped = map_variable_attnos((Node *) info2->ii_Predicate,
                                     1, 0, attmap,
                                     InvalidOid, &found_whole_row);
        if (found_whole_row)
        {
            /*
             * we could throw an error here, but seems out of scope for this
             * routine.
             */
            return false;
        }
        if (!equal(info1->ii_Predicate, mapped))
            return false;
    }
 
    /* If they're exclusion indexes, their properties must be identical */
    if ((info1->ii_ExclusionOps == NULL) != (info2->ii_ExclusionOps == NULL))
        return false;
    if (info1->ii_ExclusionOps != NULL)
    {
        for (i = 0; i < info1->ii_NumIndexKeyAttrs; i++)
        {
            if (info1->ii_ExclusionOps[i] != info2->ii_ExclusionOps[i])
                return false;
            if (info1->ii_ExclusionProcs[i] != info2->ii_ExclusionProcs[i])
                return false;
            if (info1->ii_ExclusionStrats[i] != info2->ii_ExclusionStrats[i])
                return false;
        }
    }
 
    return true;
}

References elog, equal(), ERROR, fb(), i, InvalidAttrNumber, InvalidOid, map_variable_attnos(), and NIL.

Referenced by ATExecAttachPartitionIdx(), AttachPartitionEnsureIndexes(), and DefineIndex().

EstimateReindexStateSpace()

Size EstimateReindexStateSpace ( void  )

extern

Definition at line 4275 of file index.c.

{
    return offsetof(SerializedReindexState, pendingReindexedIndexes)
        + mul_size(sizeof(Oid), list_length(pendingReindexedIndexes));
}

References fb(), list_length(), mul_size(), and pendingReindexedIndexes.

Referenced by InitializeParallelDSM().

FormIndexDatum()

void FormIndexDatum ( IndexInfo *  indexInfo, TupleTableSlot *  slot, EState *  estate, Datum *  values, bool *  isnull  )

extern

Definition at line 2760 of file index.c.

{
    ListCell   *indexpr_item;
    int         i;
 
    if (indexInfo->ii_Expressions != NIL &&
        indexInfo->ii_ExpressionsState == NIL)
    {
        /* First time through, set up expression evaluation state */
        indexInfo->ii_ExpressionsState =
            ExecPrepareExprList(indexInfo->ii_Expressions, estate);
        /* Check caller has set up context correctly */
        Assert(GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
    }
    indexpr_item = list_head(indexInfo->ii_ExpressionsState);
 
    for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
    {
        int         keycol = indexInfo->ii_IndexAttrNumbers[i];
        Datum       iDatum;
        bool        isNull;
 
        if (keycol < 0)
            iDatum = slot_getsysattr(slot, keycol, &isNull);
        else if (keycol != 0)
        {
            /*
             * Plain index column; get the value we need directly from the
             * heap tuple.
             */
            iDatum = slot_getattr(slot, keycol, &isNull);
        }
        else
        {
            /*
             * Index expression --- need to evaluate it.
             */
            if (indexpr_item == NULL)
                elog(ERROR, "wrong number of index expressions");
            iDatum = ExecEvalExprSwitchContext((ExprState *) lfirst(indexpr_item),
                                               GetPerTupleExprContext(estate),
                                               &isNull);
            indexpr_item = lnext(indexInfo->ii_ExpressionsState, indexpr_item);
        }
        values[i] = iDatum;
        isnull[i] = isNull;
    }
 
    if (indexpr_item != NULL)
        elog(ERROR, "wrong number of index expressions");
}

References Assert, elog, ERROR, ExecEvalExprSwitchContext(), ExecPrepareExprList(), fb(), GetPerTupleExprContext, i, IndexInfo::ii_Expressions, IndexInfo::ii_ExpressionsState, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NumIndexAttrs, lfirst, list_head(), lnext(), NIL, slot_getattr(), slot_getsysattr(), and values.

Referenced by build_index_value_desc(), CatalogIndexInsert(), check_exclusion_or_unique_constraint(), comparetup_cluster_tiebreak(), compute_index_stats(), ExecCheckIndexConstraints(), ExecInsertIndexTuples(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), recheck_matched_pk_tuple(), and unique_key_recheck().

index_build()

void index_build ( Relation  heapRelation, Relation  indexRelation, IndexInfo *  indexInfo, bool  isreindex, bool  parallel, bool  progress  )

extern

Definition at line 3033 of file index.c.

{
    IndexBuildResult *stats;
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
 
    /*
     * sanity checks
     */
    Assert(RelationIsValid(indexRelation));
    Assert(indexRelation->rd_indam);
    Assert(indexRelation->rd_indam->ambuild);
    Assert(indexRelation->rd_indam->ambuildempty);
 
    /*
     * Determine worker process details for parallel CREATE INDEX.  Currently,
     * only btree, GIN, and BRIN have support for parallel builds.
     *
     * Note that planner considers parallel safety for us.
     */
    if (parallel && IsNormalProcessingMode() &&
        indexRelation->rd_indam->amcanbuildparallel)
        indexInfo->ii_ParallelWorkers =
            plan_create_index_workers(RelationGetRelid(heapRelation),
                                      RelationGetRelid(indexRelation));
 
    if (indexInfo->ii_ParallelWorkers == 0)
        ereport(DEBUG1,
                (errmsg_internal("building index \"%s\" on table \"%s\" serially",
                                 RelationGetRelationName(indexRelation),
                                 RelationGetRelationName(heapRelation))));
    else
        ereport(DEBUG1,
                (errmsg_internal("building index \"%s\" on table \"%s\" with request for %d parallel workers",
                                 RelationGetRelationName(indexRelation),
                                 RelationGetRelationName(heapRelation),
                                 indexInfo->ii_ParallelWorkers)));
 
    /*
     * Switch to the table owner's userid, so that any index functions are run
     * as that user.  Also lock down security-restricted operations and
     * arrange to make GUC variable changes local to this command.
     */
    GetUserIdAndSecContext(&save_userid, &save_sec_context);
    SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
                           save_sec_context | SECURITY_RESTRICTED_OPERATION);
    save_nestlevel = NewGUCNestLevel();
    RestrictSearchPath();
 
    /* Set up initial progress report status */
    if (progress)
    {
        const int   progress_index[] = {
            PROGRESS_CREATEIDX_PHASE,
            PROGRESS_CREATEIDX_SUBPHASE,
            PROGRESS_CREATEIDX_TUPLES_DONE,
            PROGRESS_CREATEIDX_TUPLES_TOTAL,
            PROGRESS_SCAN_BLOCKS_DONE,
            PROGRESS_SCAN_BLOCKS_TOTAL
        };
        const int64 progress_vals[] = {
            PROGRESS_CREATEIDX_PHASE_BUILD,
            PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE,
            0, 0, 0, 0
        };
 
        pgstat_progress_update_multi_param(6, progress_index, progress_vals);
    }
 
    /*
     * Call the access method's build procedure
     */
    stats = indexRelation->rd_indam->ambuild(heapRelation, indexRelation,
                                             indexInfo);
    Assert(stats);
 
    /*
     * If this is an unlogged index, we may need to write out an init fork for
     * it -- but we must first check whether one already exists.  If, for
     * example, an unlogged relation is truncated in the transaction that
     * created it, or truncated twice in a subsequent transaction, the
     * relfilenumber won't change, and nothing needs to be done here.
     */
    if (indexRelation->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
        !smgrexists(RelationGetSmgr(indexRelation), INIT_FORKNUM))
    {
        smgrcreate(RelationGetSmgr(indexRelation), INIT_FORKNUM, false);
        log_smgrcreate(&indexRelation->rd_locator, INIT_FORKNUM);
        indexRelation->rd_indam->ambuildempty(indexRelation);
    }
 
    /*
     * If we found any potentially broken HOT chains, mark the index as not
     * being usable until the current transaction is below the event horizon.
     * See src/backend/access/heap/README.HOT for discussion.  While it might
     * become safe to use the index earlier based on actual cleanup activity
     * and other active transactions, the test for that would be much more
     * complex and would require some form of blocking, so keep it simple and
     * fast by just using the current transaction.
     *
     * However, when reindexing an existing index, we should do nothing here.
     * Any HOT chains that are broken with respect to the index must predate
     * the index's original creation, so there is no need to change the
     * index's usability horizon.  Moreover, we *must not* try to change the
     * index's pg_index entry while reindexing pg_index itself, and this
     * optimization nicely prevents that.  The more complex rules needed for a
     * reindex are handled separately after this function returns.
     *
     * We also need not set indcheckxmin during a concurrent index build,
     * because we won't set indisvalid true until all transactions that care
     * about the broken HOT chains are gone.
     *
     * Therefore, this code path can only be taken during non-concurrent
     * CREATE INDEX.  Thus the fact that heap_update will set the pg_index
     * tuple's xmin doesn't matter, because that tuple was created in the
     * current transaction anyway.  That also means we don't need to worry
     * about any concurrent readers of the tuple; no other transaction can see
     * it yet.
     */
    if (indexInfo->ii_BrokenHotChain &&
        !isreindex &&
        !indexInfo->ii_Concurrent)
    {
        Oid         indexId = RelationGetRelid(indexRelation);
        Relation    pg_index;
        HeapTuple   indexTuple;
        Form_pg_index indexForm;
 
        pg_index = table_open(IndexRelationId, RowExclusiveLock);
 
        indexTuple = SearchSysCacheCopy1(INDEXRELID,
                                         ObjectIdGetDatum(indexId));
        if (!HeapTupleIsValid(indexTuple))
            elog(ERROR, "cache lookup failed for index %u", indexId);
        indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
 
        /* If it's a new index, indcheckxmin shouldn't be set ... */
        Assert(!indexForm->indcheckxmin);
 
        indexForm->indcheckxmin = true;
        CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
        heap_freetuple(indexTuple);
        table_close(pg_index, RowExclusiveLock);
    }
 
    /*
     * Update heap and index pg_class rows
     */
    index_update_stats(heapRelation,
                       true,
                       stats->heap_tuples);
 
    index_update_stats(indexRelation,
                       false,
                       stats->index_tuples);
 
    /* Make the updated catalog row versions visible */
    CommandCounterIncrement();
 
    /*
     * If it's for an exclusion constraint, make a second pass over the heap
     * to verify that the constraint is satisfied.  We must not do this until
     * the index is fully valid.  (Broken HOT chains shouldn't matter, though;
     * see comments for IndexCheckExclusion.)
     */
    if (indexInfo->ii_ExclusionOps != NULL)
        IndexCheckExclusion(heapRelation, indexRelation, indexInfo);
 
    /* Roll back any GUC changes executed by index functions */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
}

References IndexAmRoutine::ambuild, IndexAmRoutine::ambuildempty, IndexAmRoutine::amcanbuildparallel, Assert, AtEOXact_GUC(), CatalogTupleUpdate(), CommandCounterIncrement(), DEBUG1, elog, ereport, errmsg_internal(), ERROR, fb(), Form_pg_index, GETSTRUCT(), GetUserIdAndSecContext(), heap_freetuple(), IndexBuildResult::heap_tuples, HeapTupleIsValid, IndexInfo::ii_BrokenHotChain, IndexInfo::ii_Concurrent, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ParallelWorkers, IndexBuildResult::index_tuples, index_update_stats(), IndexCheckExclusion(), INIT_FORKNUM, IsNormalProcessingMode, log_smgrcreate(), NewGUCNestLevel(), ObjectIdGetDatum(), pgstat_progress_update_multi_param(), plan_create_index_workers(), progress, PROGRESS_CREATEIDX_PHASE, PROGRESS_CREATEIDX_PHASE_BUILD, PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE, PROGRESS_CREATEIDX_TUPLES_DONE, PROGRESS_CREATEIDX_TUPLES_TOTAL, PROGRESS_SCAN_BLOCKS_DONE, PROGRESS_SCAN_BLOCKS_TOTAL, RelationData::rd_indam, RelationData::rd_locator, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RelationGetSmgr(), RelationIsValid, RestrictSearchPath(), RowExclusiveLock, SearchSysCacheCopy1, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), smgrcreate(), smgrexists(), table_close(), and table_open().

Referenced by build_indices(), index_concurrently_build(), index_create(), reindex_index(), and RelationTruncateIndexes().

index_check_primary_key()

void index_check_primary_key ( Relation  heapRel, const IndexInfo *  indexInfo, bool  is_alter_table, const IndexStmt *  stmt  )

extern

Definition at line 203 of file index.c.

{
    int         i;
 
    /*
     * If ALTER TABLE or CREATE TABLE .. PARTITION OF, check that there isn't
     * already a PRIMARY KEY.  In CREATE TABLE for an ordinary relation, we
     * have faith that the parser rejected multiple pkey clauses; and CREATE
     * INDEX doesn't have a way to say PRIMARY KEY, so it's no problem either.
     */
    if ((is_alter_table || heapRel->rd_rel->relispartition) &&
        relationHasPrimaryKey(heapRel))
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("multiple primary keys for table \"%s\" are not allowed",
                        RelationGetRelationName(heapRel))));
    }
 
    /*
     * Indexes created with NULLS NOT DISTINCT cannot be used for primary key
     * constraints. While there is no direct syntax to reach here, it can be
     * done by creating a separate index and attaching it via ALTER TABLE ..
     * USING INDEX.
     */
    if (indexInfo->ii_NullsNotDistinct)
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                 errmsg("primary keys cannot use NULLS NOT DISTINCT indexes")));
    }
 
    /*
     * Check that all of the attributes in a primary key are marked as not
     * null.  (We don't really expect to see that; it'd mean the parser messed
     * up.  But it seems wise to check anyway.)
     */
    for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
    {
        AttrNumber  attnum = indexInfo->ii_IndexAttrNumbers[i];
        HeapTuple   atttuple;
        Form_pg_attribute attform;
 
        if (attnum == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("primary keys cannot be expressions")));
 
        /* System attributes are never null, so no need to check */
        if (attnum < 0)
            continue;
 
        atttuple = SearchSysCache2(ATTNUM,
                                   ObjectIdGetDatum(RelationGetRelid(heapRel)),
                                   Int16GetDatum(attnum));
        if (!HeapTupleIsValid(atttuple))
            elog(ERROR, "cache lookup failed for attribute %d of relation %u",
                 attnum, RelationGetRelid(heapRel));
        attform = (Form_pg_attribute) GETSTRUCT(atttuple);
 
        if (!attform->attnotnull)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("primary key column \"%s\" is not marked NOT NULL",
                            NameStr(attform->attname))));
 
        ReleaseSysCache(atttuple);
    }
}

References attnum, elog, ereport, errcode(), errmsg, ERROR, fb(), GETSTRUCT(), HeapTupleIsValid, i, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NullsNotDistinct, IndexInfo::ii_NumIndexKeyAttrs, Int16GetDatum(), NameStr, ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, relationHasPrimaryKey(), ReleaseSysCache(), and SearchSysCache2().

Referenced by ATExecAddIndexConstraint(), and DefineIndex().

index_concurrently_build()

void index_concurrently_build ( Oid  heapRelationId, Oid  indexRelationId  )

extern

Definition at line 1503 of file index.c.

{
    Relation    heapRel;
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
    Relation    indexRelation;
    IndexInfo  *indexInfo;
 
    /* This had better make sure that a snapshot is active */
    Assert(ActiveSnapshotSet());
 
    /* Open and lock the parent heap relation */
    heapRel = table_open(heapRelationId, ShareUpdateExclusiveLock);
 
    /*
     * Switch to the table owner's userid, so that any index functions are run
     * as that user.  Also lock down security-restricted operations and
     * arrange to make GUC variable changes local to this command.
     */
    GetUserIdAndSecContext(&save_userid, &save_sec_context);
    SetUserIdAndSecContext(heapRel->rd_rel->relowner,
                           save_sec_context | SECURITY_RESTRICTED_OPERATION);
    save_nestlevel = NewGUCNestLevel();
    RestrictSearchPath();
 
    indexRelation = index_open(indexRelationId, RowExclusiveLock);
 
    /*
     * We have to re-build the IndexInfo struct, since it was lost in the
     * commit of the transaction where this concurrent index was created at
     * the catalog level.
     */
    indexInfo = BuildIndexInfo(indexRelation);
    Assert(!indexInfo->ii_ReadyForInserts);
    indexInfo->ii_Concurrent = true;
    indexInfo->ii_BrokenHotChain = false;
 
    /* Now build the index */
    index_build(heapRel, indexRelation, indexInfo, false, true, true);
 
    /* Roll back any GUC changes executed by index functions */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
 
    /* Close both the relations, but keep the locks */
    table_close(heapRel, NoLock);
    index_close(indexRelation, NoLock);
 
    /*
     * Update the pg_index row to mark the index as ready for inserts. Once we
     * commit this transaction, any new transactions that open the table must
     * insert new entries into the index for insertions and non-HOT updates.
     */
    index_set_state_flags(indexRelationId, INDEX_CREATE_SET_READY);
}

References ActiveSnapshotSet(), Assert, AtEOXact_GUC(), BuildIndexInfo(), fb(), GetUserIdAndSecContext(), IndexInfo::ii_BrokenHotChain, IndexInfo::ii_Concurrent, IndexInfo::ii_ReadyForInserts, index_build(), index_close(), INDEX_CREATE_SET_READY, index_open(), index_set_state_flags(), NewGUCNestLevel(), NoLock, RelationData::rd_rel, RestrictSearchPath(), RowExclusiveLock, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), ShareUpdateExclusiveLock, table_close(), and table_open().

Referenced by DefineIndex(), and ReindexRelationConcurrently().

index_concurrently_set_dead()

void index_concurrently_set_dead ( Oid  heapId, Oid  indexId  )

extern

Definition at line 1841 of file index.c.

{
    Relation    userHeapRelation;
    Relation    userIndexRelation;
 
    /*
     * No more predicate locks will be acquired on this index, and we're about
     * to stop doing inserts into the index which could show conflicts with
     * existing predicate locks, so now is the time to move them to the heap
     * relation.
     */
    userHeapRelation = table_open(heapId, ShareUpdateExclusiveLock);
    userIndexRelation = index_open(indexId, ShareUpdateExclusiveLock);
    TransferPredicateLocksToHeapRelation(userIndexRelation);
 
    /*
     * Now we are sure that nobody uses the index for queries; they just might
     * have it open for updating it.  So now we can unset indisready and
     * indislive, then wait till nobody could be using it at all anymore.
     */
    index_set_state_flags(indexId, INDEX_DROP_SET_DEAD);
 
    /*
     * Invalidate the relcache for the table, so that after this commit all
     * sessions will refresh the table's index list.  Forgetting just the
     * index's relcache entry is not enough.
     */
    CacheInvalidateRelcache(userHeapRelation);
 
    /*
     * Close the relations again, though still holding session lock.
     */
    table_close(userHeapRelation, NoLock);
    index_close(userIndexRelation, NoLock);
}

References CacheInvalidateRelcache(), fb(), index_close(), INDEX_DROP_SET_DEAD, index_open(), index_set_state_flags(), NoLock, ShareUpdateExclusiveLock, table_close(), table_open(), and TransferPredicateLocksToHeapRelation().

Referenced by index_drop(), and ReindexRelationConcurrently().

index_concurrently_swap()

void index_concurrently_swap ( Oid  newIndexId, Oid  oldIndexId, const char *  oldName  )

extern

Definition at line 1570 of file index.c.

{
    Relation    pg_class,
                pg_index,
                pg_constraint,
                pg_trigger;
    Relation    oldClassRel,
                newClassRel;
    HeapTuple   oldClassTuple,
                newClassTuple;
    Form_pg_class oldClassForm,
                newClassForm;
    HeapTuple   oldIndexTuple,
                newIndexTuple;
    Form_pg_index oldIndexForm,
                newIndexForm;
    bool        isPartition;
    Oid         indexConstraintOid;
    List       *constraintOids = NIL;
    ListCell   *lc;
 
    /*
     * Take a necessary lock on the old and new index before swapping them.
     */
    oldClassRel = relation_open(oldIndexId, ShareUpdateExclusiveLock);
    newClassRel = relation_open(newIndexId, ShareUpdateExclusiveLock);
 
    /* Now swap names and dependencies of those indexes */
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    oldClassTuple = SearchSysCacheCopy1(RELOID,
                                        ObjectIdGetDatum(oldIndexId));
    if (!HeapTupleIsValid(oldClassTuple))
        elog(ERROR, "could not find tuple for relation %u", oldIndexId);
    newClassTuple = SearchSysCacheCopy1(RELOID,
                                        ObjectIdGetDatum(newIndexId));
    if (!HeapTupleIsValid(newClassTuple))
        elog(ERROR, "could not find tuple for relation %u", newIndexId);
 
    oldClassForm = (Form_pg_class) GETSTRUCT(oldClassTuple);
    newClassForm = (Form_pg_class) GETSTRUCT(newClassTuple);
 
    /* Swap the names */
    namestrcpy(&newClassForm->relname, NameStr(oldClassForm->relname));
    namestrcpy(&oldClassForm->relname, oldName);
 
    /* Swap the partition flags to track inheritance properly */
    isPartition = newClassForm->relispartition;
    newClassForm->relispartition = oldClassForm->relispartition;
    oldClassForm->relispartition = isPartition;
 
    CatalogTupleUpdate(pg_class, &oldClassTuple->t_self, oldClassTuple);
    CatalogTupleUpdate(pg_class, &newClassTuple->t_self, newClassTuple);
 
    heap_freetuple(oldClassTuple);
    heap_freetuple(newClassTuple);
 
    /* Now swap index info */
    pg_index = table_open(IndexRelationId, RowExclusiveLock);
 
    oldIndexTuple = SearchSysCacheCopy1(INDEXRELID,
                                        ObjectIdGetDatum(oldIndexId));
    if (!HeapTupleIsValid(oldIndexTuple))
        elog(ERROR, "could not find tuple for relation %u", oldIndexId);
    newIndexTuple = SearchSysCacheCopy1(INDEXRELID,
                                        ObjectIdGetDatum(newIndexId));
    if (!HeapTupleIsValid(newIndexTuple))
        elog(ERROR, "could not find tuple for relation %u", newIndexId);
 
    oldIndexForm = (Form_pg_index) GETSTRUCT(oldIndexTuple);
    newIndexForm = (Form_pg_index) GETSTRUCT(newIndexTuple);
 
    /*
     * Copy constraint flags from the old index. This is safe because the old
     * index guaranteed uniqueness.
     */
    newIndexForm->indisprimary = oldIndexForm->indisprimary;
    oldIndexForm->indisprimary = false;
    newIndexForm->indisexclusion = oldIndexForm->indisexclusion;
    oldIndexForm->indisexclusion = false;
    newIndexForm->indimmediate = oldIndexForm->indimmediate;
    oldIndexForm->indimmediate = true;
 
    /* Preserve indisreplident in the new index */
    newIndexForm->indisreplident = oldIndexForm->indisreplident;
 
    /* Preserve indisclustered in the new index */
    newIndexForm->indisclustered = oldIndexForm->indisclustered;
 
    /*
     * Mark the new index as valid, and the old index as invalid similarly to
     * what index_set_state_flags() does.
     */
    newIndexForm->indisvalid = true;
    oldIndexForm->indisvalid = false;
    oldIndexForm->indisclustered = false;
    oldIndexForm->indisreplident = false;
 
    CatalogTupleUpdate(pg_index, &oldIndexTuple->t_self, oldIndexTuple);
    CatalogTupleUpdate(pg_index, &newIndexTuple->t_self, newIndexTuple);
 
    heap_freetuple(oldIndexTuple);
    heap_freetuple(newIndexTuple);
 
    /*
     * Move constraints and triggers over to the new index
     */
 
    constraintOids = get_index_ref_constraints(oldIndexId);
 
    indexConstraintOid = get_index_constraint(oldIndexId);
 
    if (OidIsValid(indexConstraintOid))
        constraintOids = lappend_oid(constraintOids, indexConstraintOid);
 
    pg_constraint = table_open(ConstraintRelationId, RowExclusiveLock);
    pg_trigger = table_open(TriggerRelationId, RowExclusiveLock);
 
    foreach(lc, constraintOids)
    {
        HeapTuple   constraintTuple,
                    triggerTuple;
        Form_pg_constraint conForm;
        ScanKeyData key[1];
        SysScanDesc scan;
        Oid         constraintOid = lfirst_oid(lc);
 
        /* Move the constraint from the old to the new index */
        constraintTuple = SearchSysCacheCopy1(CONSTROID,
                                              ObjectIdGetDatum(constraintOid));
        if (!HeapTupleIsValid(constraintTuple))
            elog(ERROR, "could not find tuple for constraint %u", constraintOid);
 
        conForm = ((Form_pg_constraint) GETSTRUCT(constraintTuple));
 
        if (conForm->conindid == oldIndexId)
        {
            conForm->conindid = newIndexId;
 
            CatalogTupleUpdate(pg_constraint, &constraintTuple->t_self, constraintTuple);
        }
 
        heap_freetuple(constraintTuple);
 
        /* Search for trigger records */
        ScanKeyInit(&key[0],
                    Anum_pg_trigger_tgconstraint,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(constraintOid));
 
        scan = systable_beginscan(pg_trigger, TriggerConstraintIndexId, true,
                                  NULL, 1, key);
 
        while (HeapTupleIsValid((triggerTuple = systable_getnext(scan))))
        {
            Form_pg_trigger tgForm = (Form_pg_trigger) GETSTRUCT(triggerTuple);
 
            if (tgForm->tgconstrindid != oldIndexId)
                continue;
 
            /* Make a modifiable copy */
            triggerTuple = heap_copytuple(triggerTuple);
            tgForm = (Form_pg_trigger) GETSTRUCT(triggerTuple);
 
            tgForm->tgconstrindid = newIndexId;
 
            CatalogTupleUpdate(pg_trigger, &triggerTuple->t_self, triggerTuple);
 
            heap_freetuple(triggerTuple);
        }
 
        systable_endscan(scan);
    }
 
    /*
     * Move comment if any
     */
    {
        Relation    description;
        ScanKeyData skey[3];
        SysScanDesc sd;
        HeapTuple   tuple;
        Datum       values[Natts_pg_description] = {0};
        bool        nulls[Natts_pg_description] = {0};
        bool        replaces[Natts_pg_description] = {0};
 
        values[Anum_pg_description_objoid - 1] = ObjectIdGetDatum(newIndexId);
        replaces[Anum_pg_description_objoid - 1] = true;
 
        ScanKeyInit(&skey[0],
                    Anum_pg_description_objoid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(oldIndexId));
        ScanKeyInit(&skey[1],
                    Anum_pg_description_classoid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(RelationRelationId));
        ScanKeyInit(&skey[2],
                    Anum_pg_description_objsubid,
                    BTEqualStrategyNumber, F_INT4EQ,
                    Int32GetDatum(0));
 
        description = table_open(DescriptionRelationId, RowExclusiveLock);
 
        sd = systable_beginscan(description, DescriptionObjIndexId, true,
                                NULL, 3, skey);
 
        while ((tuple = systable_getnext(sd)) != NULL)
        {
            tuple = heap_modify_tuple(tuple, RelationGetDescr(description),
                                      values, nulls, replaces);
            CatalogTupleUpdate(description, &tuple->t_self, tuple);
 
            break;              /* Assume there can be only one match */
        }
 
        systable_endscan(sd);
        table_close(description, NoLock);
    }
 
    /*
     * Swap inheritance relationship with parent index
     */
    if (get_rel_relispartition(oldIndexId))
    {
        List       *ancestors = get_partition_ancestors(oldIndexId);
        Oid         parentIndexRelid = linitial_oid(ancestors);
 
        DeleteInheritsTuple(oldIndexId, parentIndexRelid, false, NULL);
        StoreSingleInheritance(newIndexId, parentIndexRelid, 1);
 
        list_free(ancestors);
    }
 
    /*
     * Swap all dependencies of and on the old index to the new one, and
     * vice-versa.  Note that a call to CommandCounterIncrement() would cause
     * duplicate entries in pg_depend, so this should not be done.
     */
    changeDependenciesOf(RelationRelationId, newIndexId, oldIndexId);
    changeDependenciesOn(RelationRelationId, newIndexId, oldIndexId);
 
    changeDependenciesOf(RelationRelationId, oldIndexId, newIndexId);
    changeDependenciesOn(RelationRelationId, oldIndexId, newIndexId);
 
    /* copy over statistics from old to new index */
    pgstat_copy_relation_stats(newClassRel, oldClassRel);
 
    /* Copy data of pg_statistic from the old index to the new one */
    CopyStatistics(oldIndexId, newIndexId);
 
    /* Close relations */
    table_close(pg_class, RowExclusiveLock);
    table_close(pg_index, RowExclusiveLock);
    table_close(pg_constraint, RowExclusiveLock);
    table_close(pg_trigger, RowExclusiveLock);
 
    /* The lock taken previously is not released until the end of transaction */
    relation_close(oldClassRel, NoLock);
    relation_close(newClassRel, NoLock);
}

References BTEqualStrategyNumber, CatalogTupleUpdate(), changeDependenciesOf(), changeDependenciesOn(), CopyStatistics(), DeleteInheritsTuple(), description, elog, ERROR, fb(), Form_pg_constraint, Form_pg_index, Form_pg_trigger, get_index_constraint(), get_index_ref_constraints(), get_partition_ancestors(), get_rel_relispartition(), GETSTRUCT(), heap_copytuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, Int32GetDatum(), lappend_oid(), lfirst_oid, linitial_oid, list_free(), NameStr, namestrcpy(), NIL, NoLock, ObjectIdGetDatum(), OidIsValid, pgstat_copy_relation_stats(), relation_close(), relation_open(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), SearchSysCacheCopy1, ShareUpdateExclusiveLock, StoreSingleInheritance(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), and values.

Referenced by ReindexRelationConcurrently().

index_constraint_create()

ObjectAddress index_constraint_create ( Relation  heapRelation, Oid  indexRelationId, Oid  parentConstraintId, const IndexInfo *  indexInfo, const char *  constraintName, char  constraintType, uint16  constr_flags, bool  allow_system_table_mods, bool  is_internal  )

extern

Definition at line 1903 of file index.c.

{
    Oid         namespaceId = RelationGetNamespace(heapRelation);
    ObjectAddress myself,
                idxaddr;
    Oid         conOid;
    bool        deferrable;
    bool        initdeferred;
    bool        mark_as_primary;
    bool        islocal;
    bool        noinherit;
    bool        is_without_overlaps;
    int16       inhcount;
 
    deferrable = (constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) != 0;
    initdeferred = (constr_flags & INDEX_CONSTR_CREATE_INIT_DEFERRED) != 0;
    mark_as_primary = (constr_flags & INDEX_CONSTR_CREATE_MARK_AS_PRIMARY) != 0;
    is_without_overlaps = (constr_flags & INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS) != 0;
 
    /* constraint creation support doesn't work while bootstrapping */
    Assert(!IsBootstrapProcessingMode());
 
    /* enforce system-table restriction */
    if (!allow_system_table_mods &&
        IsSystemRelation(heapRelation) &&
        IsNormalProcessingMode())
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("user-defined indexes on system catalog tables are not supported")));
 
    /* primary/unique constraints shouldn't have any expressions */
    if (indexInfo->ii_Expressions &&
        constraintType != CONSTRAINT_EXCLUSION)
        elog(ERROR, "constraints cannot have index expressions");
 
    /*
     * If we're manufacturing a constraint for a pre-existing index, we need
     * to get rid of the existing auto dependencies for the index (the ones
     * that index_create() would have made instead of calling this function).
     *
     * Note: this code would not necessarily do the right thing if the index
     * has any expressions or predicate, but we'd never be turning such an
     * index into a UNIQUE or PRIMARY KEY constraint.
     */
    if (constr_flags & INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS)
        deleteDependencyRecordsForClass(RelationRelationId, indexRelationId,
                                        RelationRelationId, DEPENDENCY_AUTO);
 
    if (OidIsValid(parentConstraintId))
    {
        islocal = false;
        inhcount = 1;
        noinherit = false;
    }
    else
    {
        islocal = true;
        inhcount = 0;
        noinherit = true;
    }
 
    /*
     * Construct a pg_constraint entry.
     */
    conOid = CreateConstraintEntry(constraintName,
                                   namespaceId,
                                   constraintType,
                                   deferrable,
                                   initdeferred,
                                   true,    /* Is Enforced */
                                   true,
                                   parentConstraintId,
                                   RelationGetRelid(heapRelation),
                                   indexInfo->ii_IndexAttrNumbers,
                                   indexInfo->ii_NumIndexKeyAttrs,
                                   indexInfo->ii_NumIndexAttrs,
                                   InvalidOid,  /* no domain */
                                   indexRelationId, /* index OID */
                                   InvalidOid,  /* no foreign key */
                                   NULL,
                                   NULL,
                                   NULL,
                                   NULL,
                                   0,
                                   ' ',
                                   ' ',
                                   NULL,
                                   0,
                                   ' ',
                                   indexInfo->ii_ExclusionOps,
                                   NULL,    /* no check constraint */
                                   NULL,
                                   islocal,
                                   inhcount,
                                   noinherit,
                                   is_without_overlaps,
                                   is_internal);
 
    /*
     * Register the index as internally dependent on the constraint.
     *
     * Note that the constraint has a dependency on the table, so we don't
     * need (or want) any direct dependency from the index to the table.
     */
    ObjectAddressSet(myself, ConstraintRelationId, conOid);
    ObjectAddressSet(idxaddr, RelationRelationId, indexRelationId);
    recordDependencyOn(&idxaddr, &myself, DEPENDENCY_INTERNAL);
 
    /*
     * Also, if this is a constraint on a partition, give it partition-type
     * dependencies on the parent constraint as well as the table.
     */
    if (OidIsValid(parentConstraintId))
    {
        ObjectAddress referenced;
 
        ObjectAddressSet(referenced, ConstraintRelationId, parentConstraintId);
        recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
        ObjectAddressSet(referenced, RelationRelationId,
                         RelationGetRelid(heapRelation));
        recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
    }
 
    /*
     * If the constraint is deferrable, create the deferred uniqueness
     * checking trigger.  (The trigger will be given an internal dependency on
     * the constraint by CreateTrigger.)
     */
    if (deferrable)
    {
        CreateTrigStmt *trigger = makeNode(CreateTrigStmt);
 
        trigger->replace = false;
        trigger->isconstraint = true;
        trigger->trigname = (constraintType == CONSTRAINT_PRIMARY) ?
            "PK_ConstraintTrigger" :
            "Unique_ConstraintTrigger";
        trigger->relation = NULL;
        trigger->funcname = SystemFuncName("unique_key_recheck");
        trigger->args = NIL;
        trigger->row = true;
        trigger->timing = TRIGGER_TYPE_AFTER;
        trigger->events = TRIGGER_TYPE_INSERT | TRIGGER_TYPE_UPDATE;
        trigger->columns = NIL;
        trigger->whenClause = NULL;
        trigger->transitionRels = NIL;
        trigger->deferrable = true;
        trigger->initdeferred = initdeferred;
        trigger->constrrel = NULL;
 
        (void) CreateTrigger(trigger, NULL, RelationGetRelid(heapRelation),
                             InvalidOid, conOid, indexRelationId, InvalidOid,
                             InvalidOid, NULL, true, false);
    }
 
    /*
     * If needed, mark the index as primary and/or deferred in pg_index.
     *
     * Note: When making an existing index into a constraint, caller must have
     * a table lock that prevents concurrent table updates; otherwise, there
     * is a risk that concurrent readers of the table will miss seeing this
     * index at all.
     */
    if ((constr_flags & INDEX_CONSTR_CREATE_UPDATE_INDEX) &&
        (mark_as_primary || deferrable))
    {
        Relation    pg_index;
        HeapTuple   indexTuple;
        Form_pg_index indexForm;
        bool        dirty = false;
        bool        marked_as_primary = false;
 
        pg_index = table_open(IndexRelationId, RowExclusiveLock);
 
        indexTuple = SearchSysCacheCopy1(INDEXRELID,
                                         ObjectIdGetDatum(indexRelationId));
        if (!HeapTupleIsValid(indexTuple))
            elog(ERROR, "cache lookup failed for index %u", indexRelationId);
        indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
 
        if (mark_as_primary && !indexForm->indisprimary)
        {
            indexForm->indisprimary = true;
            dirty = true;
            marked_as_primary = true;
        }
 
        if (deferrable && indexForm->indimmediate)
        {
            indexForm->indimmediate = false;
            dirty = true;
        }
 
        if (dirty)
        {
            CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
            /*
             * When we mark an existing index as primary, force a relcache
             * flush on its parent table, so that all sessions will become
             * aware that the table now has a primary key.  This is important
             * because it affects some replication behaviors.
             */
            if (marked_as_primary)
                CacheInvalidateRelcache(heapRelation);
 
            InvokeObjectPostAlterHookArg(IndexRelationId, indexRelationId, 0,
                                         InvalidOid, is_internal);
        }
 
        heap_freetuple(indexTuple);
        table_close(pg_index, RowExclusiveLock);
    }
 
    return myself;
}

References Assert, CacheInvalidateRelcache(), CatalogTupleUpdate(), CreateConstraintEntry(), CreateTrigger(), deleteDependencyRecordsForClass(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_index, GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Expressions, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NumIndexAttrs, IndexInfo::ii_NumIndexKeyAttrs, INDEX_CONSTR_CREATE_DEFERRABLE, INDEX_CONSTR_CREATE_INIT_DEFERRED, INDEX_CONSTR_CREATE_MARK_AS_PRIMARY, INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS, INDEX_CONSTR_CREATE_UPDATE_INDEX, INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS, InvalidOid, InvokeObjectPostAlterHookArg, IsBootstrapProcessingMode, IsNormalProcessingMode, IsSystemRelation(), makeNode, NIL, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, recordDependencyOn(), RelationGetNamespace, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, SystemFuncName(), table_close(), and table_open().

Referenced by ATExecAddIndexConstraint(), and index_create().

index_create()

Oid index_create ( Relation  heapRelation, const char *  indexRelationName, Oid  indexRelationId, Oid  parentIndexRelid, Oid  parentConstraintId, RelFileNumber  relFileNumber, IndexInfo *  indexInfo, const List *  indexColNames, Oid  accessMethodId, Oid  tableSpaceId, const Oid *  collationIds, const Oid *  opclassIds, const Datum *  opclassOptions, const int16 *  coloptions, const NullableDatum *  stattargets, Datum  reloptions, uint16  flags, uint16  constr_flags, bool  allow_system_table_mods, bool  is_internal, Oid *  constraintId  )

extern

Definition at line 730 of file index.c.

{
    Oid         heapRelationId = RelationGetRelid(heapRelation);
    Relation    pg_class;
    Relation    indexRelation;
    TupleDesc   indexTupDesc;
    bool        shared_relation;
    bool        mapped_relation;
    bool        is_exclusion;
    Oid         namespaceId;
    int         i;
    char        relpersistence;
    bool        isprimary = (flags & INDEX_CREATE_IS_PRIMARY) != 0;
    bool        invalid = (flags & INDEX_CREATE_INVALID) != 0;
    bool        concurrent = (flags & INDEX_CREATE_CONCURRENT) != 0;
    bool        partitioned = (flags & INDEX_CREATE_PARTITIONED) != 0;
    bool        progress = (flags & INDEX_CREATE_SUPPRESS_PROGRESS) == 0;
    char        relkind;
    TransactionId relfrozenxid;
    MultiXactId relminmxid;
    bool        create_storage = !RelFileNumberIsValid(relFileNumber);
 
    /* constraint flags can only be set when a constraint is requested */
    Assert((constr_flags == 0) ||
           ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0));
    /* partitioned indexes must never be "built" by themselves */
    Assert(!partitioned || (flags & INDEX_CREATE_SKIP_BUILD));
 
    relkind = partitioned ? RELKIND_PARTITIONED_INDEX : RELKIND_INDEX;
    is_exclusion = (indexInfo->ii_ExclusionOps != NULL);
 
    pg_class = table_open(RelationRelationId, RowExclusiveLock);
 
    /*
     * The index will be in the same namespace as its parent table, and is
     * shared across databases if and only if the parent is.  Likewise, it
     * will use the relfilenumber map if and only if the parent does; and it
     * inherits the parent's relpersistence.
     */
    namespaceId = RelationGetNamespace(heapRelation);
    shared_relation = heapRelation->rd_rel->relisshared;
    mapped_relation = RelationIsMapped(heapRelation);
    relpersistence = heapRelation->rd_rel->relpersistence;
 
    /*
     * check parameters
     */
    if (indexInfo->ii_NumIndexAttrs < 1)
        elog(ERROR, "must index at least one column");
 
    if (!allow_system_table_mods &&
        IsSystemRelation(heapRelation) &&
        IsNormalProcessingMode())
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("user-defined indexes on system catalog tables are not supported")));
 
    /*
     * Btree text_pattern_ops uses texteq as the equality operator, which is
     * fine as long as the collation is deterministic; texteq then reduces to
     * bitwise equality and so it is semantically compatible with the other
     * operators and functions in that opclass.  But with a nondeterministic
     * collation, texteq could yield results that are incompatible with the
     * actual behavior of the index (which is determined by the opclass's
     * comparison function).  We prevent such problems by refusing creation of
     * an index with that opclass and a nondeterministic collation.
     *
     * The same applies to varchar_pattern_ops and bpchar_pattern_ops.  If we
     * find more cases, we might decide to create a real mechanism for marking
     * opclasses as incompatible with nondeterminism; but for now, this small
     * hack suffices.
     *
     * Another solution is to use a special operator, not texteq, as the
     * equality opclass member; but that is undesirable because it would
     * prevent index usage in many queries that work fine today.
     */
    for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
    {
        Oid         collation = collationIds[i];
        Oid         opclass = opclassIds[i];
 
        if (collation)
        {
            if ((opclass == TEXT_BTREE_PATTERN_OPS_OID ||
                 opclass == VARCHAR_BTREE_PATTERN_OPS_OID ||
                 opclass == BPCHAR_BTREE_PATTERN_OPS_OID) &&
                !get_collation_isdeterministic(collation))
            {
                HeapTuple   classtup;
 
                classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
                if (!HeapTupleIsValid(classtup))
                    elog(ERROR, "cache lookup failed for operator class %u", opclass);
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("nondeterministic collations are not supported for operator class \"%s\"",
                                NameStr(((Form_pg_opclass) GETSTRUCT(classtup))->opcname))));
                ReleaseSysCache(classtup);
            }
        }
    }
 
    /*
     * Concurrent index build on a system catalog is unsafe because we tend to
     * release locks before committing in catalogs.
     */
    if (concurrent &&
        IsCatalogRelation(heapRelation))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("concurrent index creation on system catalog tables is not supported")));
 
    /*
     * This case is currently not supported.  There's no way to ask for it in
     * the grammar with CREATE INDEX, but it can happen with REINDEX.
     */
    if (concurrent && is_exclusion)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("concurrent index creation for exclusion constraints is not supported")));
 
    /*
     * We cannot allow indexing a shared relation after initdb (because
     * there's no way to make the entry in other databases' pg_class).
     */
    if (shared_relation && !IsBootstrapProcessingMode())
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("shared indexes cannot be created after initdb")));
 
    /*
     * Shared relations must be in pg_global, too (last-ditch check)
     */
    if (shared_relation && tableSpaceId != GLOBALTABLESPACE_OID)
        elog(ERROR, "shared relations must be placed in pg_global tablespace");
 
    /*
     * Check for duplicate name (both as to the index, and as to the
     * associated constraint if any).  Such cases would fail on the relevant
     * catalogs' unique indexes anyway, but we prefer to give a friendlier
     * error message.
     */
    if (get_relname_relid(indexRelationName, namespaceId))
    {
        if ((flags & INDEX_CREATE_IF_NOT_EXISTS) != 0)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" already exists, skipping",
                            indexRelationName)));
            table_close(pg_class, RowExclusiveLock);
            return InvalidOid;
        }
 
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("relation \"%s\" already exists",
                        indexRelationName)));
    }
 
    if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0 &&
        ConstraintNameIsUsed(CONSTRAINT_RELATION, heapRelationId,
                             indexRelationName))
    {
        /*
         * INDEX_CREATE_IF_NOT_EXISTS does not apply here, since the
         * conflicting constraint is not an index.
         */
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("constraint \"%s\" for relation \"%s\" already exists",
                        indexRelationName, RelationGetRelationName(heapRelation))));
    }
 
    /*
     * construct tuple descriptor for index tuples
     */
    indexTupDesc = ConstructTupleDescriptor(heapRelation,
                                            indexInfo,
                                            indexColNames,
                                            accessMethodId,
                                            collationIds,
                                            opclassIds);
 
    /*
     * Allocate an OID for the index, unless we were told what to use.
     *
     * The OID will be the relfilenumber as well, so make sure it doesn't
     * collide with either pg_class OIDs or existing physical files.
     */
    if (!OidIsValid(indexRelationId))
    {
        /* Use binary-upgrade override for pg_class.oid and relfilenumber */
        if (IsBinaryUpgrade)
        {
            if (!OidIsValid(binary_upgrade_next_index_pg_class_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("pg_class index OID value not set when in binary upgrade mode")));
 
            indexRelationId = binary_upgrade_next_index_pg_class_oid;
            binary_upgrade_next_index_pg_class_oid = InvalidOid;
 
            /* Override the index relfilenumber */
            if ((relkind == RELKIND_INDEX) &&
                (!RelFileNumberIsValid(binary_upgrade_next_index_pg_class_relfilenumber)))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("index relfilenumber value not set when in binary upgrade mode")));
            relFileNumber = binary_upgrade_next_index_pg_class_relfilenumber;
            binary_upgrade_next_index_pg_class_relfilenumber = InvalidRelFileNumber;
 
            /*
             * Note that we want create_storage = true for binary upgrade. The
             * storage we create here will be replaced later, but we need to
             * have something on disk in the meanwhile.
             */
            Assert(create_storage);
        }
        else
        {
            indexRelationId =
                GetNewRelFileNumber(tableSpaceId, pg_class, relpersistence);
        }
    }
 
    /*
     * create the index relation's relcache entry and, if necessary, the
     * physical disk file. (If we fail further down, it's the smgr's
     * responsibility to remove the disk file again, if any.)
     */
    indexRelation = heap_create(indexRelationName,
                                namespaceId,
                                tableSpaceId,
                                indexRelationId,
                                relFileNumber,
                                accessMethodId,
                                indexTupDesc,
                                relkind,
                                relpersistence,
                                shared_relation,
                                mapped_relation,
                                allow_system_table_mods,
                                &relfrozenxid,
                                &relminmxid,
                                create_storage);
 
    Assert(relfrozenxid == InvalidTransactionId);
    Assert(relminmxid == InvalidMultiXactId);
    Assert(indexRelationId == RelationGetRelid(indexRelation));
 
    /*
     * Obtain exclusive lock on it.  Although no other transactions can see it
     * until we commit, this prevents deadlock-risk complaints from lock
     * manager in cases such as CLUSTER.
     */
    LockRelation(indexRelation, AccessExclusiveLock);
 
    /*
     * Fill in fields of the index's pg_class entry that are not set correctly
     * by heap_create.
     *
     * XXX should have a cleaner way to create cataloged indexes
     */
    indexRelation->rd_rel->relowner = heapRelation->rd_rel->relowner;
    indexRelation->rd_rel->relam = accessMethodId;
    indexRelation->rd_rel->relispartition = OidIsValid(parentIndexRelid);
 
    /*
     * store index's pg_class entry
     */
    InsertPgClassTuple(pg_class, indexRelation,
                       RelationGetRelid(indexRelation),
                       (Datum) 0,
                       reloptions);
 
    /* done with pg_class */
    table_close(pg_class, RowExclusiveLock);
 
    /*
     * now update the object id's of all the attribute tuple forms in the
     * index relation's tuple descriptor
     */
    InitializeAttributeOids(indexRelation,
                            indexInfo->ii_NumIndexAttrs,
                            indexRelationId);
 
    /*
     * append ATTRIBUTE tuples for the index
     */
    AppendAttributeTuples(indexRelation, opclassOptions, stattargets);
 
    /* ----------------
     *    update pg_index
     *    (append INDEX tuple)
     *
     *    Note that this stows away a representation of "predicate".
     *    (Or, could define a rule to maintain the predicate) --Nels, Feb '92
     * ----------------
     */
    UpdateIndexRelation(indexRelationId, heapRelationId, parentIndexRelid,
                        indexInfo,
                        collationIds, opclassIds, coloptions,
                        isprimary, is_exclusion,
                        (constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
                        !concurrent && !invalid,
                        !concurrent);
 
    /*
     * Register relcache invalidation on the indexes' heap relation, to
     * maintain consistency of its index list
     */
    CacheInvalidateRelcache(heapRelation);
 
    /* update pg_inherits and the parent's relhassubclass, if needed */
    if (OidIsValid(parentIndexRelid))
    {
        StoreSingleInheritance(indexRelationId, parentIndexRelid, 1);
        LockRelationOid(parentIndexRelid, ShareUpdateExclusiveLock);
        SetRelationHasSubclass(parentIndexRelid, true);
    }
 
    /*
     * Register constraint and dependencies for the index.
     *
     * If the index is from a CONSTRAINT clause, construct a pg_constraint
     * entry.  The index will be linked to the constraint, which in turn is
     * linked to the table.  If it's not a CONSTRAINT, we need to make a
     * dependency directly on the table.
     *
     * We don't need a dependency on the namespace, because there'll be an
     * indirect dependency via our parent table.
     *
     * During bootstrap we can't register any dependencies, and we don't try
     * to make a constraint either.
     */
    if (!IsBootstrapProcessingMode())
    {
        ObjectAddress myself,
                    referenced;
        ObjectAddresses *addrs;
 
        ObjectAddressSet(myself, RelationRelationId, indexRelationId);
 
        if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0)
        {
            char        constraintType;
            ObjectAddress localaddr;
 
            if (isprimary)
                constraintType = CONSTRAINT_PRIMARY;
            else if (indexInfo->ii_Unique)
                constraintType = CONSTRAINT_UNIQUE;
            else if (is_exclusion)
                constraintType = CONSTRAINT_EXCLUSION;
            else
            {
                elog(ERROR, "constraint must be PRIMARY, UNIQUE or EXCLUDE");
                constraintType = 0; /* keep compiler quiet */
            }
 
            localaddr = index_constraint_create(heapRelation,
                                                indexRelationId,
                                                parentConstraintId,
                                                indexInfo,
                                                indexRelationName,
                                                constraintType,
                                                constr_flags,
                                                allow_system_table_mods,
                                                is_internal);
            if (constraintId)
                *constraintId = localaddr.objectId;
        }
        else
        {
            bool        have_simple_col = false;
 
            addrs = new_object_addresses();
 
            /* Create auto dependencies on simply-referenced columns */
            for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
            {
                if (indexInfo->ii_IndexAttrNumbers[i] != 0)
                {
                    ObjectAddressSubSet(referenced, RelationRelationId,
                                        heapRelationId,
                                        indexInfo->ii_IndexAttrNumbers[i]);
                    add_exact_object_address(&referenced, addrs);
                    have_simple_col = true;
                }
            }
 
            /*
             * If there are no simply-referenced columns, give the index an
             * auto dependency on the whole table.  In most cases, this will
             * be redundant, but it might not be if the index expressions and
             * predicate contain no Vars or only whole-row Vars.
             */
            if (!have_simple_col)
            {
                ObjectAddressSet(referenced, RelationRelationId,
                                 heapRelationId);
                add_exact_object_address(&referenced, addrs);
            }
 
            record_object_address_dependencies(&myself, addrs, DEPENDENCY_AUTO);
            free_object_addresses(addrs);
        }
 
        /*
         * If this is an index partition, create partition dependencies on
         * both the parent index and the table.  (Note: these must be *in
         * addition to*, not instead of, all other dependencies.  Otherwise
         * we'll be short some dependencies after DETACH PARTITION.)
         */
        if (OidIsValid(parentIndexRelid))
        {
            ObjectAddressSet(referenced, RelationRelationId, parentIndexRelid);
            recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
 
            ObjectAddressSet(referenced, RelationRelationId, heapRelationId);
            recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
        }
 
        /* placeholder for normal dependencies */
        addrs = new_object_addresses();
 
        /* Store dependency on collations */
 
        /* The default collation is pinned, so don't bother recording it */
        for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
        {
            if (OidIsValid(collationIds[i]) && collationIds[i] != DEFAULT_COLLATION_OID)
            {
                ObjectAddressSet(referenced, CollationRelationId, collationIds[i]);
                add_exact_object_address(&referenced, addrs);
            }
        }
 
        /* Store dependency on operator classes */
        for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
        {
            ObjectAddressSet(referenced, OperatorClassRelationId, opclassIds[i]);
            add_exact_object_address(&referenced, addrs);
        }
 
        record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
        free_object_addresses(addrs);
 
        /* Store dependencies on anything mentioned in index expressions */
        if (indexInfo->ii_Expressions)
        {
            recordDependencyOnSingleRelExpr(&myself,
                                            (Node *) indexInfo->ii_Expressions,
                                            heapRelationId,
                                            DEPENDENCY_NORMAL,
                                            DEPENDENCY_AUTO, false);
        }
 
        /* Store dependencies on anything mentioned in predicate */
        if (indexInfo->ii_Predicate)
        {
            recordDependencyOnSingleRelExpr(&myself,
                                            (Node *) indexInfo->ii_Predicate,
                                            heapRelationId,
                                            DEPENDENCY_NORMAL,
                                            DEPENDENCY_AUTO, false);
        }
    }
    else
    {
        /* Bootstrap mode - assert we weren't asked for constraint support */
        Assert((flags & INDEX_CREATE_ADD_CONSTRAINT) == 0);
    }
 
    /* Post creation hook for new index */
    InvokeObjectPostCreateHookArg(RelationRelationId,
                                  indexRelationId, 0, is_internal);
 
    /*
     * Advance the command counter so that we can see the newly-entered
     * catalog tuples for the index.
     */
    CommandCounterIncrement();
 
    /*
     * In bootstrap mode, we have to fill in the index strategy structure with
     * information from the catalogs.  If we aren't bootstrapping, then the
     * relcache entry has already been rebuilt thanks to sinval update during
     * CommandCounterIncrement.
     */
    if (IsBootstrapProcessingMode())
        RelationInitIndexAccessInfo(indexRelation);
    else
        Assert(indexRelation->rd_indexcxt != NULL);
 
    indexRelation->rd_index->indnkeyatts = indexInfo->ii_NumIndexKeyAttrs;
 
    /* Validate opclass-specific options */
    if (opclassOptions)
        for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
            (void) index_opclass_options(indexRelation, i + 1,
                                         opclassOptions[i],
                                         true);
 
    /*
     * If this is bootstrap (initdb) time, then we don't actually fill in the
     * index yet.  We'll be creating more indexes and classes later, so we
     * delay filling them in until just before we're done with bootstrapping.
     * Similarly, if the caller specified to skip the build then filling the
     * index is delayed till later (ALTER TABLE can save work in some cases
     * with this).  Otherwise, we call the AM routine that constructs the
     * index.
     */
    if (IsBootstrapProcessingMode())
    {
        index_register(heapRelationId, indexRelationId, indexInfo);
    }
    else if ((flags & INDEX_CREATE_SKIP_BUILD) != 0)
    {
        /*
         * Caller is responsible for filling the index later on.  However,
         * we'd better make sure that the heap relation is correctly marked as
         * having an index.
         */
        index_update_stats(heapRelation,
                           true,
                           -1.0);
        /* Make the above update visible */
        CommandCounterIncrement();
    }
    else
    {
        index_build(heapRelation, indexRelation, indexInfo, false, true,
                    progress);
    }
 
    /*
     * Close the index; but we keep the lock that we acquired above until end
     * of transaction.  Closing the heap is caller's responsibility.
     */
    index_close(indexRelation, NoLock);
 
    return indexRelationId;
}

References AccessExclusiveLock, add_exact_object_address(), AppendAttributeTuples(), Assert, binary_upgrade_next_index_pg_class_oid, binary_upgrade_next_index_pg_class_relfilenumber, CacheInvalidateRelcache(), CommandCounterIncrement(), CONSTRAINT_RELATION, ConstraintNameIsUsed(), ConstructTupleDescriptor(), DEPENDENCY_AUTO, DEPENDENCY_NORMAL, DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg, ERROR, fb(), Form_pg_opclass, free_object_addresses(), get_collation_isdeterministic(), get_relname_relid(), GetNewRelFileNumber(), GETSTRUCT(), heap_create(), HeapTupleIsValid, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Expressions, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NumIndexAttrs, IndexInfo::ii_NumIndexKeyAttrs, IndexInfo::ii_Predicate, IndexInfo::ii_Unique, index_build(), index_close(), INDEX_CONSTR_CREATE_DEFERRABLE, index_constraint_create(), INDEX_CREATE_ADD_CONSTRAINT, INDEX_CREATE_CONCURRENT, INDEX_CREATE_IF_NOT_EXISTS, INDEX_CREATE_INVALID, INDEX_CREATE_IS_PRIMARY, INDEX_CREATE_PARTITIONED, INDEX_CREATE_SKIP_BUILD, INDEX_CREATE_SUPPRESS_PROGRESS, index_opclass_options(), index_register(), index_update_stats(), InitializeAttributeOids(), InsertPgClassTuple(), invalid, InvalidMultiXactId, InvalidOid, InvalidRelFileNumber, InvalidTransactionId, InvokeObjectPostCreateHookArg, IsBinaryUpgrade, IsBootstrapProcessingMode, IsCatalogRelation(), IsNormalProcessingMode, IsSystemRelation(), LockRelation(), LockRelationOid(), NameStr, new_object_addresses(), NoLock, NOTICE, ObjectAddressSet, ObjectAddressSubSet, ObjectIdGetDatum(), OidIsValid, progress, RelationData::rd_index, RelationData::rd_indexcxt, RelationData::rd_rel, record_object_address_dependencies(), recordDependencyOn(), recordDependencyOnSingleRelExpr(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RelationInitIndexAccessInfo(), RelationIsMapped, ReleaseSysCache(), RelFileNumberIsValid, RowExclusiveLock, SearchSysCache1(), SetRelationHasSubclass(), ShareUpdateExclusiveLock, StoreSingleInheritance(), table_close(), table_open(), and UpdateIndexRelation().

Referenced by create_toast_table(), DefineIndex(), and index_create_copy().

index_create_copy()

Oid index_create_copy ( Relation  heapRelation, uint16  flags, Oid  oldIndexId, Oid  tablespaceOid, const char *  newName  )

extern

Definition at line 1306 of file index.c.

{
    Relation    indexRelation;
    IndexInfo  *oldInfo,
               *newInfo;
    Oid         newIndexId = InvalidOid;
    bool        concurrently = (flags & INDEX_CREATE_CONCURRENT) != 0;
    HeapTuple   indexTuple,
                classTuple;
    Datum       indclassDatum,
                colOptionDatum,
                reloptionsDatum;
    Datum      *opclassOptions;
    oidvector  *indclass;
    int2vector *indcoloptions;
    NullableDatum *stattargets;
    bool        isnull;
    List       *indexColNames = NIL;
    List       *indexExprs = NIL;
    List       *indexPreds = NIL;
 
    indexRelation = index_open(oldIndexId, RowExclusiveLock);
 
    /* The new index needs some information from the old index */
    oldInfo = BuildIndexInfo(indexRelation);
 
    /*
     * Concurrent build of an index with exclusion constraints is not
     * supported.
     */
    if (oldInfo->ii_ExclusionOps != NULL && concurrently)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("concurrent index creation for exclusion constraints is not supported")));
 
    /* Get the array of class and column options IDs from index info */
    indexTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(oldIndexId));
    if (!HeapTupleIsValid(indexTuple))
        elog(ERROR, "cache lookup failed for index %u", oldIndexId);
    indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
                                           Anum_pg_index_indclass);
    indclass = (oidvector *) DatumGetPointer(indclassDatum);
 
    colOptionDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
                                            Anum_pg_index_indoption);
    indcoloptions = (int2vector *) DatumGetPointer(colOptionDatum);
 
    /* Fetch reloptions of index if any */
    classTuple = SearchSysCache1(RELOID, ObjectIdGetDatum(oldIndexId));
    if (!HeapTupleIsValid(classTuple))
        elog(ERROR, "cache lookup failed for relation %u", oldIndexId);
    reloptionsDatum = SysCacheGetAttr(RELOID, classTuple,
                                      Anum_pg_class_reloptions, &isnull);
 
    /*
     * Fetch the list of expressions and predicates directly from the
     * catalogs.  This cannot rely on the information from IndexInfo of the
     * old index as these have been flattened for the planner.
     */
    if (oldInfo->ii_Expressions != NIL)
    {
        Datum       exprDatum;
        char       *exprString;
 
        exprDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
                                           Anum_pg_index_indexprs);
        exprString = TextDatumGetCString(exprDatum);
        indexExprs = (List *) stringToNode(exprString);
        pfree(exprString);
    }
    if (oldInfo->ii_Predicate != NIL)
    {
        Datum       predDatum;
        char       *predString;
 
        predDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
                                           Anum_pg_index_indpred);
        predString = TextDatumGetCString(predDatum);
        indexPreds = (List *) stringToNode(predString);
 
        /* Also convert to implicit-AND format */
        indexPreds = make_ands_implicit((Expr *) indexPreds);
        pfree(predString);
    }
 
    /*
     * Build the index information for the new index.
     */
    newInfo = makeIndexInfo(oldInfo->ii_NumIndexAttrs,
                            oldInfo->ii_NumIndexKeyAttrs,
                            oldInfo->ii_Am,
                            indexExprs,
                            indexPreds,
                            oldInfo->ii_Unique,
                            oldInfo->ii_NullsNotDistinct,
                            !concurrently,  /* isready */
                            concurrently,   /* concurrent */
                            indexRelation->rd_indam->amsummarizing,
                            oldInfo->ii_WithoutOverlaps);
 
    /* fetch exclusion constraint info if any */
    if (indexRelation->rd_index->indisexclusion)
    {
        /*
         * XXX Beware: we're making newInfo point to oldInfo-owned memory.  It
         * would be more orthodox to palloc+memcpy, but we don't need that
         * here at present.
         */
        newInfo->ii_ExclusionOps = oldInfo->ii_ExclusionOps;
        newInfo->ii_ExclusionProcs = oldInfo->ii_ExclusionProcs;
        newInfo->ii_ExclusionStrats = oldInfo->ii_ExclusionStrats;
    }
 
    /*
     * Extract the list of column names and the column numbers for the new
     * index information.  All this information will be used for the index
     * creation.
     */
    for (int i = 0; i < oldInfo->ii_NumIndexAttrs; i++)
    {
        TupleDesc   indexTupDesc = RelationGetDescr(indexRelation);
        Form_pg_attribute att = TupleDescAttr(indexTupDesc, i);
 
        indexColNames = lappend(indexColNames, NameStr(att->attname));
        newInfo->ii_IndexAttrNumbers[i] = oldInfo->ii_IndexAttrNumbers[i];
    }
 
    /* Extract opclass options for each attribute */
    opclassOptions = palloc0_array(Datum, newInfo->ii_NumIndexAttrs);
    for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
        opclassOptions[i] = get_attoptions(oldIndexId, i + 1);
 
    /* Extract statistic targets for each attribute */
    stattargets = palloc0_array(NullableDatum, newInfo->ii_NumIndexAttrs);
    for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
    {
        HeapTuple   tp;
        Datum       dat;
 
        tp = SearchSysCache2(ATTNUM, ObjectIdGetDatum(oldIndexId), Int16GetDatum(i + 1));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for attribute %d of relation %u",
                 i + 1, oldIndexId);
        dat = SysCacheGetAttr(ATTNUM, tp, Anum_pg_attribute_attstattarget, &isnull);
        ReleaseSysCache(tp);
        stattargets[i].value = dat;
        stattargets[i].isnull = isnull;
    }
 
    /*
     * Now create the new index.
     *
     * For a partition index, we adjust the partition dependency later, to
     * ensure a consistent state at all times.  That is why parentIndexRelid
     * is not set here.
     */
    newIndexId = index_create(heapRelation,
                              newName,
                              InvalidOid,   /* indexRelationId */
                              InvalidOid,   /* parentIndexRelid */
                              InvalidOid,   /* parentConstraintId */
                              InvalidRelFileNumber, /* relFileNumber */
                              newInfo,
                              indexColNames,
                              indexRelation->rd_rel->relam,
                              tablespaceOid,
                              indexRelation->rd_indcollation,
                              indclass->values,
                              opclassOptions,
                              indcoloptions->values,
                              stattargets,
                              reloptionsDatum,
                              flags,
                              0,
                              true, /* allow table to be a system catalog? */
                              false,    /* is_internal? */
                              NULL);
 
    /* Close the relations used and clean up */
    index_close(indexRelation, NoLock);
    ReleaseSysCache(indexTuple);
    ReleaseSysCache(classTuple);
 
    return newIndexId;
}

References IndexAmRoutine::amsummarizing, BuildIndexInfo(), DatumGetPointer(), elog, ereport, errcode(), errmsg, ERROR, fb(), get_attoptions(), HeapTupleIsValid, i, index_close(), index_create(), INDEX_CREATE_CONCURRENT, index_open(), Int16GetDatum(), InvalidOid, InvalidRelFileNumber, lappend(), make_ands_implicit(), makeIndexInfo(), NameStr, NIL, NoLock, ObjectIdGetDatum(), palloc0_array, pfree(), RelationData::rd_indam, RelationData::rd_indcollation, RelationData::rd_index, RelationData::rd_rel, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, and TupleDescAttr().

Referenced by build_new_indexes(), and ReindexRelationConcurrently().

index_drop()

void index_drop ( Oid  indexId, bool  concurrent, bool  concurrent_lock_mode  )

extern

Definition at line 2140 of file index.c.

{
    Oid         heapId;
    Relation    userHeapRelation;
    Relation    userIndexRelation;
    Relation    indexRelation;
    HeapTuple   tuple;
    bool        hasexprs;
    LockRelId   heaprelid,
                indexrelid;
    LOCKTAG     heaplocktag;
    LOCKMODE    lockmode;
 
    /*
     * A temporary relation uses a non-concurrent DROP.  Other backends can't
     * access a temporary relation, so there's no harm in grabbing a stronger
     * lock (see comments in RemoveRelations), and a non-concurrent DROP is
     * more efficient.
     */
    Assert(get_rel_persistence(indexId) != RELPERSISTENCE_TEMP ||
           (!concurrent && !concurrent_lock_mode));
 
    /*
     * To drop an index safely, we must grab exclusive lock on its parent
     * table.  Exclusive lock on the index alone is insufficient because
     * another backend might be about to execute a query on the parent table.
     * If it relies on a previously cached list of index OIDs, then it could
     * attempt to access the just-dropped index.  We must therefore take a
     * table lock strong enough to prevent all queries on the table from
     * proceeding until we commit and send out a shared-cache-inval notice
     * that will make them update their index lists.
     *
     * In the concurrent case we avoid this requirement by disabling index use
     * in multiple steps and waiting out any transactions that might be using
     * the index, so we don't need exclusive lock on the parent table. Instead
     * we take ShareUpdateExclusiveLock, to ensure that two sessions aren't
     * doing CREATE/DROP INDEX CONCURRENTLY on the same index.  (We will get
     * AccessExclusiveLock on the index below, once we're sure nobody else is
     * using it.)
     */
    heapId = IndexGetRelation(indexId, false);
    lockmode = (concurrent || concurrent_lock_mode) ? ShareUpdateExclusiveLock : AccessExclusiveLock;
    userHeapRelation = table_open(heapId, lockmode);
    userIndexRelation = index_open(indexId, lockmode);
 
    /*
     * We might still have open queries using it in our own session, which the
     * above locking won't prevent, so test explicitly.
     */
    CheckTableNotInUse(userIndexRelation, "DROP INDEX");
 
    /*
     * Drop Index Concurrently is more or less the reverse process of Create
     * Index Concurrently.
     *
     * First we unset indisvalid so queries starting afterwards don't use the
     * index to answer queries anymore.  We have to keep indisready = true so
     * transactions that are still scanning the index can continue to see
     * valid index contents.  For instance, if they are using READ COMMITTED
     * mode, and another transaction makes changes and commits, they need to
     * see those new tuples in the index.
     *
     * After all transactions that could possibly have used the index for
     * queries end, we can unset indisready and indislive, then wait till
     * nobody could be touching it anymore.  (Note: we need indislive because
     * this state must be distinct from the initial state during CREATE INDEX
     * CONCURRENTLY, which has indislive true while indisready and indisvalid
     * are false.  That's because in that state, transactions must examine the
     * index for HOT-safety decisions, while in this state we don't want them
     * to open it at all.)
     *
     * Since all predicate locks on the index are about to be made invalid, we
     * must promote them to predicate locks on the heap.  In the
     * non-concurrent case we can just do that now.  In the concurrent case
     * it's a bit trickier.  The predicate locks must be moved when there are
     * no index scans in progress on the index and no more can subsequently
     * start, so that no new predicate locks can be made on the index.  Also,
     * they must be moved before heap inserts stop maintaining the index, else
     * the conflict with the predicate lock on the index gap could be missed
     * before the lock on the heap relation is in place to detect a conflict
     * based on the heap tuple insert.
     */
    if (concurrent)
    {
        /*
         * We must commit our transaction in order to make the first pg_index
         * state update visible to other sessions.  If the DROP machinery has
         * already performed any other actions (removal of other objects,
         * pg_depend entries, etc), the commit would make those actions
         * permanent, which would leave us with inconsistent catalog state if
         * we fail partway through the following sequence.  Since DROP INDEX
         * CONCURRENTLY is restricted to dropping just one index that has no
         * dependencies, we should get here before anything's been done ---
         * but let's check that to be sure.  We can verify that the current
         * transaction has not executed any transactional updates by checking
         * that no XID has been assigned.
         */
        if (GetTopTransactionIdIfAny() != InvalidTransactionId)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("DROP INDEX CONCURRENTLY must be first action in transaction")));
 
        /*
         * Mark index invalid by updating its pg_index entry
         */
        index_set_state_flags(indexId, INDEX_DROP_CLEAR_VALID);
 
        /*
         * Invalidate the relcache for the table, so that after this commit
         * all sessions will refresh any cached plans that might reference the
         * index.
         */
        CacheInvalidateRelcache(userHeapRelation);
 
        /* save lockrelid and locktag for below, then close but keep locks */
        heaprelid = userHeapRelation->rd_lockInfo.lockRelId;
        SET_LOCKTAG_RELATION(heaplocktag, heaprelid.dbId, heaprelid.relId);
        indexrelid = userIndexRelation->rd_lockInfo.lockRelId;
 
        table_close(userHeapRelation, NoLock);
        index_close(userIndexRelation, NoLock);
 
        /*
         * We must commit our current transaction so that the indisvalid
         * update becomes visible to other transactions; then start another.
         * Note that any previously-built data structures are lost in the
         * commit.  The only data we keep past here are the relation IDs.
         *
         * Before committing, get a session-level lock on the table, to ensure
         * that neither it nor the index can be dropped before we finish. This
         * cannot block, even if someone else is waiting for access, because
         * we already have the same lock within our transaction.
         */
        LockRelationIdForSession(&heaprelid, ShareUpdateExclusiveLock);
        LockRelationIdForSession(&indexrelid, ShareUpdateExclusiveLock);
 
        PopActiveSnapshot();
        CommitTransactionCommand();
        StartTransactionCommand();
 
        /*
         * Now we must wait until no running transaction could be using the
         * index for a query.  Use AccessExclusiveLock here to check for
         * running transactions that hold locks of any kind on the table. Note
         * we do not need to worry about xacts that open the table for reading
         * after this point; they will see the index as invalid when they open
         * the relation.
         *
         * Note: the reason we use actual lock acquisition here, rather than
         * just checking the ProcArray and sleeping, is that deadlock is
         * possible if one of the transactions in question is blocked trying
         * to acquire an exclusive lock on our table.  The lock code will
         * detect deadlock and error out properly.
         *
         * Note: we report progress through WaitForLockers() unconditionally
         * here, even though it will only be used when we're called by REINDEX
         * CONCURRENTLY and not when called by DROP INDEX CONCURRENTLY.
         */
        WaitForLockers(heaplocktag, AccessExclusiveLock, true);
 
        /*
         * Updating pg_index might involve TOAST table access, so ensure we
         * have a valid snapshot.
         */
        PushActiveSnapshot(GetTransactionSnapshot());
 
        /* Finish invalidation of index and mark it as dead */
        index_concurrently_set_dead(heapId, indexId);
 
        PopActiveSnapshot();
 
        /*
         * Again, commit the transaction to make the pg_index update visible
         * to other sessions.
         */
        CommitTransactionCommand();
        StartTransactionCommand();
 
        /*
         * Wait till every transaction that saw the old index state has
         * finished.  See above about progress reporting.
         */
        WaitForLockers(heaplocktag, AccessExclusiveLock, true);
 
        /*
         * Re-open relations to allow us to complete our actions.
         *
         * At this point, nothing should be accessing the index, but lets
         * leave nothing to chance and grab AccessExclusiveLock on the index
         * before the physical deletion.
         */
        userHeapRelation = table_open(heapId, ShareUpdateExclusiveLock);
        userIndexRelation = index_open(indexId, AccessExclusiveLock);
    }
    else
    {
        /* Not concurrent, so just transfer predicate locks and we're good */
        TransferPredicateLocksToHeapRelation(userIndexRelation);
    }
 
    /*
     * Schedule physical removal of the files (if any)
     */
    if (RELKIND_HAS_STORAGE(userIndexRelation->rd_rel->relkind))
        RelationDropStorage(userIndexRelation);
 
    /* ensure that stats are dropped if transaction commits */
    pgstat_drop_relation(userIndexRelation);
 
    /*
     * Close and flush the index's relcache entry, to ensure relcache doesn't
     * try to rebuild it while we're deleting catalog entries. We keep the
     * lock though.
     */
    index_close(userIndexRelation, NoLock);
 
    RelationForgetRelation(indexId);
 
    /*
     * Updating pg_index might involve TOAST table access, so ensure we have a
     * valid snapshot.
     */
    PushActiveSnapshot(GetTransactionSnapshot());
 
    /*
     * fix INDEX relation, and check for expressional index
     */
    indexRelation = table_open(IndexRelationId, RowExclusiveLock);
 
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for index %u", indexId);
 
    hasexprs = !heap_attisnull(tuple, Anum_pg_index_indexprs,
                               RelationGetDescr(indexRelation));
 
    CatalogTupleDelete(indexRelation, &tuple->t_self);
 
    ReleaseSysCache(tuple);
    table_close(indexRelation, RowExclusiveLock);
 
    PopActiveSnapshot();
 
    /*
     * if it has any expression columns, we might have stored statistics about
     * them.
     */
    if (hasexprs)
        RemoveStatistics(indexId, 0);
 
    /*
     * fix ATTRIBUTE relation
     */
    DeleteAttributeTuples(indexId);
 
    /*
     * fix RELATION relation
     */
    DeleteRelationTuple(indexId);
 
    /*
     * fix INHERITS relation
     */
    DeleteInheritsTuple(indexId, InvalidOid, false, NULL);
 
    /*
     * We are presently too lazy to attempt to compute the new correct value
     * of relhasindex (the next VACUUM will fix it if necessary). So there is
     * no need to update the pg_class tuple for the owning relation. But we
     * must send out a shared-cache-inval notice on the owning relation to
     * ensure other backends update their relcache lists of indexes.  (In the
     * concurrent case, this is redundant but harmless.)
     */
    CacheInvalidateRelcache(userHeapRelation);
 
    /*
     * Close owning rel, but keep lock
     */
    table_close(userHeapRelation, NoLock);
 
    /*
     * Release the session locks before we go.
     */
    if (concurrent)
    {
        UnlockRelationIdForSession(&heaprelid, ShareUpdateExclusiveLock);
        UnlockRelationIdForSession(&indexrelid, ShareUpdateExclusiveLock);
    }
}

References AccessExclusiveLock, Assert, CacheInvalidateRelcache(), CatalogTupleDelete(), CheckTableNotInUse(), CommitTransactionCommand(), LockRelId::dbId, DeleteAttributeTuples(), DeleteInheritsTuple(), DeleteRelationTuple(), elog, ereport, errcode(), errmsg, ERROR, fb(), get_rel_persistence(), GetTopTransactionIdIfAny(), GetTransactionSnapshot(), heap_attisnull(), HeapTupleIsValid, index_close(), index_concurrently_set_dead(), INDEX_DROP_CLEAR_VALID, index_open(), index_set_state_flags(), IndexGetRelation(), InvalidOid, InvalidTransactionId, LockRelationIdForSession(), NoLock, ObjectIdGetDatum(), pgstat_drop_relation(), PopActiveSnapshot(), PushActiveSnapshot(), RelationDropStorage(), RelationForgetRelation(), RelationGetDescr, ReleaseSysCache(), LockRelId::relId, RemoveStatistics(), RowExclusiveLock, SearchSysCache1(), SET_LOCKTAG_RELATION, ShareUpdateExclusiveLock, StartTransactionCommand(), HeapTupleData::t_self, table_close(), table_open(), TransferPredicateLocksToHeapRelation(), UnlockRelationIdForSession(), and WaitForLockers().

Referenced by doDeletion().

index_set_state_flags()

void index_set_state_flags ( Oid  indexId, IndexStateFlagsAction  action  )

extern

Definition at line 3536 of file index.c.

{
    Relation    pg_index;
    HeapTuple   indexTuple;
    Form_pg_index indexForm;
 
    /* Open pg_index and fetch a writable copy of the index's tuple */
    pg_index = table_open(IndexRelationId, RowExclusiveLock);
 
    indexTuple = SearchSysCacheCopy1(INDEXRELID,
                                     ObjectIdGetDatum(indexId));
    if (!HeapTupleIsValid(indexTuple))
        elog(ERROR, "cache lookup failed for index %u", indexId);
    indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
 
    /* Perform the requested state change on the copy */
    switch (action)
    {
        case INDEX_CREATE_SET_READY:
            /* Set indisready during a CREATE INDEX CONCURRENTLY sequence */
            Assert(indexForm->indislive);
            Assert(!indexForm->indisready);
            Assert(!indexForm->indisvalid);
            indexForm->indisready = true;
            break;
        case INDEX_CREATE_SET_VALID:
            /* Set indisvalid during a CREATE INDEX CONCURRENTLY sequence */
            Assert(indexForm->indislive);
            Assert(indexForm->indisready);
            Assert(!indexForm->indisvalid);
            indexForm->indisvalid = true;
            break;
        case INDEX_DROP_CLEAR_VALID:
 
            /*
             * Clear indisvalid during a DROP INDEX CONCURRENTLY sequence
             *
             * If indisready == true we leave it set so the index still gets
             * maintained by active transactions.  We only need to ensure that
             * indisvalid is false.  (We don't assert that either is initially
             * true, though, since we want to be able to retry a DROP INDEX
             * CONCURRENTLY that failed partway through.)
             *
             * Note: the CLUSTER logic assumes that indisclustered cannot be
             * set on any invalid index, so clear that flag too.  For
             * cleanliness, also clear indisreplident.
             */
            indexForm->indisvalid = false;
            indexForm->indisclustered = false;
            indexForm->indisreplident = false;
            break;
        case INDEX_DROP_SET_DEAD:
 
            /*
             * Clear indisready/indislive during DROP INDEX CONCURRENTLY
             *
             * We clear both indisready and indislive, because we not only
             * want to stop updates, we want to prevent sessions from touching
             * the index at all.
             */
            Assert(!indexForm->indisvalid);
            Assert(!indexForm->indisclustered);
            Assert(!indexForm->indisreplident);
            indexForm->indisready = false;
            indexForm->indislive = false;
            break;
    }
 
    /* ... and update it */
    CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
    table_close(pg_index, RowExclusiveLock);
}

References Assert, CatalogTupleUpdate(), elog, ERROR, fb(), Form_pg_index, GETSTRUCT(), HeapTupleIsValid, INDEX_CREATE_SET_READY, INDEX_CREATE_SET_VALID, INDEX_DROP_CLEAR_VALID, INDEX_DROP_SET_DEAD, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by DefineIndex(), index_concurrently_build(), index_concurrently_set_dead(), and index_drop().

IndexGetRelation()

Oid IndexGetRelation ( Oid  indexId, bool  missing_ok  )

extern

Definition at line 3616 of file index.c.

{
    HeapTuple   tuple;
    Form_pg_index index;
    Oid         result;
 
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
    if (!HeapTupleIsValid(tuple))
    {
        if (missing_ok)
            return InvalidOid;
        elog(ERROR, "cache lookup failed for index %u", indexId);
    }
    index = (Form_pg_index) GETSTRUCT(tuple);
    Assert(index->indexrelid == indexId);
 
    result = index->indrelid;
    ReleaseSysCache(tuple);
    return result;
}

References Assert, elog, ERROR, fb(), Form_pg_index, GETSTRUCT(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), ReleaseSysCache(), result, and SearchSysCache1().

Referenced by amcheck_lock_relation_and_check(), ATPostAlterTypeCleanup(), brin_desummarize_range(), brin_summarize_range(), bringetbitmap(), brinvacuumcleanup(), CheckIndexCompatible(), DetachPartitionFinalize(), get_tables_to_repack_partitioned(), index_drop(), pg_prewarm(), RangeVarCallbackForAttachIndex(), RangeVarCallbackForDropRelation(), RangeVarCallbackForReindexIndex(), RangeVarCallbackForStats(), reindex_index(), and ReindexRelationConcurrently().

IndexSetParentIndex()

void IndexSetParentIndex ( Relation  partitionIdx, Oid  parentOid  )

extern

Definition at line 4601 of file indexcmds.c.

{
    Relation    pg_inherits;
    ScanKeyData key[2];
    SysScanDesc scan;
    Oid         partRelid = RelationGetRelid(partitionIdx);
    HeapTuple   tuple;
    bool        fix_dependencies;
 
    /* Make sure this is an index */
    Assert(partitionIdx->rd_rel->relkind == RELKIND_INDEX ||
           partitionIdx->rd_rel->relkind == RELKIND_PARTITIONED_INDEX);
 
    /*
     * Scan pg_inherits for rows linking our index to some parent.
     */
    pg_inherits = relation_open(InheritsRelationId, RowExclusiveLock);
    ScanKeyInit(&key[0],
                Anum_pg_inherits_inhrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(partRelid));
    ScanKeyInit(&key[1],
                Anum_pg_inherits_inhseqno,
                BTEqualStrategyNumber, F_INT4EQ,
                Int32GetDatum(1));
    scan = systable_beginscan(pg_inherits, InheritsRelidSeqnoIndexId, true,
                              NULL, 2, key);
    tuple = systable_getnext(scan);
 
    if (!HeapTupleIsValid(tuple))
    {
        if (parentOid == InvalidOid)
        {
            /*
             * No pg_inherits row, and no parent wanted: nothing to do in this
             * case.
             */
            fix_dependencies = false;
        }
        else
        {
            StoreSingleInheritance(partRelid, parentOid, 1);
            fix_dependencies = true;
        }
    }
    else
    {
        Form_pg_inherits inhForm = (Form_pg_inherits) GETSTRUCT(tuple);
 
        if (parentOid == InvalidOid)
        {
            /*
             * There exists a pg_inherits row, which we want to clear; do so.
             */
            CatalogTupleDelete(pg_inherits, &tuple->t_self);
            fix_dependencies = true;
        }
        else
        {
            /*
             * A pg_inherits row exists.  If it's the same we want, then we're
             * good; if it differs, that amounts to a corrupt catalog and
             * should not happen.
             */
            if (inhForm->inhparent != parentOid)
            {
                /* unexpected: we should not get called in this case */
                elog(ERROR, "bogus pg_inherit row: inhrelid %u inhparent %u",
                     inhForm->inhrelid, inhForm->inhparent);
            }
 
            /* already in the right state */
            fix_dependencies = false;
        }
    }
 
    /* done with pg_inherits */
    systable_endscan(scan);
    relation_close(pg_inherits, RowExclusiveLock);
 
    /* set relhassubclass if an index partition has been added to the parent */
    if (OidIsValid(parentOid))
    {
        LockRelationOid(parentOid, ShareUpdateExclusiveLock);
        SetRelationHasSubclass(parentOid, true);
    }
 
    /* set relispartition correctly on the partition */
    update_relispartition(partRelid, OidIsValid(parentOid));
 
    if (fix_dependencies)
    {
        /*
         * Insert/delete pg_depend rows.  If setting a parent, add PARTITION
         * dependencies on the parent index and the table; if removing a
         * parent, delete PARTITION dependencies.
         */
        if (OidIsValid(parentOid))
        {
            ObjectAddress partIdx;
            ObjectAddress parentIdx;
            ObjectAddress partitionTbl;
 
            ObjectAddressSet(partIdx, RelationRelationId, partRelid);
            ObjectAddressSet(parentIdx, RelationRelationId, parentOid);
            ObjectAddressSet(partitionTbl, RelationRelationId,
                             partitionIdx->rd_index->indrelid);
            recordDependencyOn(&partIdx, &parentIdx,
                               DEPENDENCY_PARTITION_PRI);
            recordDependencyOn(&partIdx, &partitionTbl,
                               DEPENDENCY_PARTITION_SEC);
        }
        else
        {
            deleteDependencyRecordsForClass(RelationRelationId, partRelid,
                                            RelationRelationId,
                                            DEPENDENCY_PARTITION_PRI);
            deleteDependencyRecordsForClass(RelationRelationId, partRelid,
                                            RelationRelationId,
                                            DEPENDENCY_PARTITION_SEC);
        }
 
        /* make our updates visible */
        CommandCounterIncrement();
    }
}

References Assert, BTEqualStrategyNumber, CatalogTupleDelete(), CommandCounterIncrement(), deleteDependencyRecordsForClass(), DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ERROR, fb(), fix_dependencies(), Form_pg_inherits, GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), InvalidOid, LockRelationOid(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, RelationData::rd_index, RelationData::rd_rel, recordDependencyOn(), relation_close(), relation_open(), RelationGetRelid, RowExclusiveLock, ScanKeyInit(), SetRelationHasSubclass(), ShareUpdateExclusiveLock, StoreSingleInheritance(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, and update_relispartition().

Referenced by ATExecAttachPartitionIdx(), AttachPartitionEnsureIndexes(), DefineIndex(), and DetachPartitionFinalize().

itemptr_decode()

static void itemptr_decode ( ItemPointer  itemptr, int64  encoded  )

inlinestatic

Definition at line 218 of file index.h.

{
    BlockNumber block = (BlockNumber) (encoded >> 16);
    OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
 
    ItemPointerSet(itemptr, block, offset);
}

References fb(), and ItemPointerSet().

Referenced by heapam_index_validate_scan().

itemptr_encode()

static int64 itemptr_encode ( const ItemPointerData *  itemptr )

inlinestatic

Definition at line 197 of file index.h.

{
    BlockNumber block = ItemPointerGetBlockNumber(itemptr);
    OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
    int64       encoded;
 
    /*
     * Use the 16 least significant bits for the offset.  32 adjacent bits are
     * used for the block number.  Since remaining bits are unused, there
     * cannot be negative encoded values (We assume a two's complement
     * representation).
     */
    encoded = ((uint64) block << 16) | (uint16) offset;
 
    return encoded;
}

References fb(), ItemPointerGetBlockNumber(), and ItemPointerGetOffsetNumber().

Referenced by validate_index_callback().

reindex_index()

void reindex_index ( const ReindexStmt *  stmt, Oid  indexId, bool  skip_constraint_checks, char  persistence, const ReindexParams *  params  )

extern

Definition at line 3641 of file index.c.

{
    Relation    iRel,
                heapRelation;
    Oid         heapId;
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
    IndexInfo  *indexInfo;
    bool        skipped_constraint = false;
    PGRUsage    ru0;
    bool        progress = ((params->options & REINDEXOPT_REPORT_PROGRESS) != 0);
    bool        set_tablespace = false;
 
    pg_rusage_init(&ru0);
 
    /*
     * Open and lock the parent heap relation.  ShareLock is sufficient since
     * we only need to be sure no schema or data changes are going on.
     */
    heapId = IndexGetRelation(indexId,
                              (params->options & REINDEXOPT_MISSING_OK) != 0);
    /* if relation is missing, leave */
    if (!OidIsValid(heapId))
        return;
 
    if ((params->options & REINDEXOPT_MISSING_OK) != 0)
        heapRelation = try_table_open(heapId, ShareLock);
    else
        heapRelation = table_open(heapId, ShareLock);
 
    /* if relation is gone, leave */
    if (!heapRelation)
        return;
 
    /*
     * Switch to the table owner's userid, so that any index functions are run
     * as that user.  Also lock down security-restricted operations and
     * arrange to make GUC variable changes local to this command.
     */
    GetUserIdAndSecContext(&save_userid, &save_sec_context);
    SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
                           save_sec_context | SECURITY_RESTRICTED_OPERATION);
    save_nestlevel = NewGUCNestLevel();
    RestrictSearchPath();
 
    if (progress)
    {
        const int   progress_cols[] = {
            PROGRESS_CREATEIDX_COMMAND,
            PROGRESS_CREATEIDX_INDEX_OID
        };
        const int64 progress_vals[] = {
            PROGRESS_CREATEIDX_COMMAND_REINDEX,
            indexId
        };
 
        pgstat_progress_start_command(PROGRESS_COMMAND_CREATE_INDEX,
                                      heapId);
        pgstat_progress_update_multi_param(2, progress_cols, progress_vals);
    }
 
    /*
     * Open the target index relation and get an exclusive lock on it, to
     * ensure that no one else is touching this particular index.
     */
    if ((params->options & REINDEXOPT_MISSING_OK) != 0)
        iRel = try_index_open(indexId, AccessExclusiveLock);
    else
        iRel = index_open(indexId, AccessExclusiveLock);
 
    /* if index relation is gone, leave */
    if (!iRel)
    {
        /* Roll back any GUC changes */
        AtEOXact_GUC(false, save_nestlevel);
 
        /* Restore userid and security context */
        SetUserIdAndSecContext(save_userid, save_sec_context);
 
        /* Close parent heap relation, but keep locks */
        table_close(heapRelation, NoLock);
        return;
    }
 
    if (progress)
        pgstat_progress_update_param(PROGRESS_CREATEIDX_ACCESS_METHOD_OID,
                                     iRel->rd_rel->relam);
 
    /*
     * If a statement is available, telling that this comes from a REINDEX
     * command, collect the index for event triggers.
     */
    if (stmt)
    {
        ObjectAddress address;
 
        ObjectAddressSet(address, RelationRelationId, indexId);
        EventTriggerCollectSimpleCommand(address,
                                         InvalidObjectAddress,
                                         (const Node *) stmt);
    }
 
    /*
     * Partitioned indexes should never get processed here, as they have no
     * physical storage.
     */
    if (iRel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
        elog(ERROR, "cannot reindex partitioned index \"%s.%s\"",
             get_namespace_name(RelationGetNamespace(iRel)),
             RelationGetRelationName(iRel));
 
    /*
     * Don't allow reindex on temp tables of other backends ... their local
     * buffer manager is not going to cope.
     */
    if (RELATION_IS_OTHER_TEMP(iRel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot reindex temporary tables of other sessions")));
 
    /*
     * Don't allow reindex of an invalid index on TOAST table.  This is a
     * leftover from a failed REINDEX CONCURRENTLY, and if rebuilt it would
     * not be possible to drop it anymore.
     */
    if (IsToastNamespace(RelationGetNamespace(iRel)) &&
        !get_index_isvalid(indexId))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot reindex invalid index on TOAST table")));
 
    /*
     * System relations cannot be moved even if allow_system_table_mods is
     * enabled to keep things consistent with the concurrent case where all
     * the indexes of a relation are processed in series, including indexes of
     * toast relations.
     *
     * Note that this check is not part of CheckRelationTableSpaceMove() as it
     * gets used for ALTER TABLE SET TABLESPACE that could cascade across
     * toast relations.
     */
    if (OidIsValid(params->tablespaceOid) &&
        IsSystemRelation(iRel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot move system relation \"%s\"",
                        RelationGetRelationName(iRel))));
 
    /* Check if the tablespace of this index needs to be changed */
    if (OidIsValid(params->tablespaceOid) &&
        CheckRelationTableSpaceMove(iRel, params->tablespaceOid))
        set_tablespace = true;
 
    /*
     * Also check for active uses of the index in the current transaction; we
     * don't want to reindex underneath an open indexscan.
     */
    CheckTableNotInUse(iRel, "REINDEX INDEX");
 
    /* Set new tablespace, if requested */
    if (set_tablespace)
    {
        /* Update its pg_class row */
        SetRelationTableSpace(iRel, params->tablespaceOid, InvalidOid);
 
        /*
         * Schedule unlinking of the old index storage at transaction commit.
         */
        RelationDropStorage(iRel);
        RelationAssumeNewRelfilelocator(iRel);
 
        /* Make sure the reltablespace change is visible */
        CommandCounterIncrement();
    }
 
    /*
     * All predicate locks on the index are about to be made invalid. Promote
     * them to relation locks on the heap.
     */
    TransferPredicateLocksToHeapRelation(iRel);
 
    /* Fetch info needed for index_build */
    indexInfo = BuildIndexInfo(iRel);
 
    /* If requested, skip checking uniqueness/exclusion constraints */
    if (skip_constraint_checks)
    {
        if (indexInfo->ii_Unique || indexInfo->ii_ExclusionOps != NULL)
            skipped_constraint = true;
        indexInfo->ii_Unique = false;
        indexInfo->ii_ExclusionOps = NULL;
        indexInfo->ii_ExclusionProcs = NULL;
        indexInfo->ii_ExclusionStrats = NULL;
    }
 
    /* Suppress use of the target index while rebuilding it */
    SetReindexProcessing(heapId, indexId);
 
    /* Create a new physical relation for the index */
    RelationSetNewRelfilenumber(iRel, persistence);
 
    /* Initialize the index and rebuild */
    /* Note: we do not need to re-establish pkey setting */
    index_build(heapRelation, iRel, indexInfo, true, true, progress);
 
    /* Re-allow use of target index */
    ResetReindexProcessing();
 
    /*
     * If the index is marked invalid/not-ready/dead (ie, it's from a failed
     * CREATE INDEX CONCURRENTLY, or a DROP INDEX CONCURRENTLY failed midway),
     * and we didn't skip a uniqueness check, we can now mark it valid.  This
     * allows REINDEX to be used to clean up in such cases.
     *
     * We can also reset indcheckxmin, because we have now done a
     * non-concurrent index build, *except* in the case where index_build
     * found some still-broken HOT chains. If it did, and we don't have to
     * change any of the other flags, we just leave indcheckxmin alone (note
     * that index_build won't have changed it, because this is a reindex).
     * This is okay and desirable because not updating the tuple leaves the
     * index's usability horizon (recorded as the tuple's xmin value) the same
     * as it was.
     *
     * But, if the index was invalid/not-ready/dead and there were broken HOT
     * chains, we had better force indcheckxmin true, because the normal
     * argument that the HOT chains couldn't conflict with the index is
     * suspect for an invalid index.  (A conflict is definitely possible if
     * the index was dead.  It probably shouldn't happen otherwise, but let's
     * be conservative.)  In this case advancing the usability horizon is
     * appropriate.
     *
     * Another reason for avoiding unnecessary updates here is that while
     * reindexing pg_index itself, we must not try to update tuples in it.
     * pg_index's indexes should always have these flags in their clean state,
     * so that won't happen.
     */
    if (!skipped_constraint)
    {
        Relation    pg_index;
        HeapTuple   indexTuple;
        Form_pg_index indexForm;
        bool        index_bad;
 
        pg_index = table_open(IndexRelationId, RowExclusiveLock);
 
        indexTuple = SearchSysCacheCopy1(INDEXRELID,
                                         ObjectIdGetDatum(indexId));
        if (!HeapTupleIsValid(indexTuple))
            elog(ERROR, "cache lookup failed for index %u", indexId);
        indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
 
        index_bad = (!indexForm->indisvalid ||
                     !indexForm->indisready ||
                     !indexForm->indislive);
        if (index_bad ||
            (indexForm->indcheckxmin && !indexInfo->ii_BrokenHotChain))
        {
            if (!indexInfo->ii_BrokenHotChain)
                indexForm->indcheckxmin = false;
            else if (index_bad)
                indexForm->indcheckxmin = true;
            indexForm->indisvalid = true;
            indexForm->indisready = true;
            indexForm->indislive = true;
            CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
            /*
             * Invalidate the relcache for the table, so that after we commit
             * all sessions will refresh the table's index list.  This ensures
             * that if anyone misses seeing the pg_index row during this
             * update, they'll refresh their list before attempting any update
             * on the table.
             */
            CacheInvalidateRelcache(heapRelation);
        }
 
        table_close(pg_index, RowExclusiveLock);
    }
 
    /* Log what we did */
    if ((params->options & REINDEXOPT_VERBOSE) != 0)
        ereport(INFO,
                (errmsg("index \"%s\" was reindexed",
                        get_rel_name(indexId)),
                 errdetail_internal("%s",
                                    pg_rusage_show(&ru0))));
 
    /* Roll back any GUC changes executed by index functions */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
 
    /* Close rels, but keep locks */
    index_close(iRel, NoLock);
    table_close(heapRelation, NoLock);
 
    if (progress)
        pgstat_progress_end_command();
}

References AccessExclusiveLock, AtEOXact_GUC(), BuildIndexInfo(), CacheInvalidateRelcache(), CatalogTupleUpdate(), CheckRelationTableSpaceMove(), CheckTableNotInUse(), CommandCounterIncrement(), elog, ereport, errcode(), errdetail_internal(), errmsg, ERROR, EventTriggerCollectSimpleCommand(), fb(), Form_pg_index, get_index_isvalid(), get_namespace_name(), get_rel_name(), GETSTRUCT(), GetUserIdAndSecContext(), HeapTupleIsValid, IndexInfo::ii_BrokenHotChain, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ExclusionProcs, IndexInfo::ii_ExclusionStrats, IndexInfo::ii_Unique, index_build(), index_close(), index_open(), IndexGetRelation(), INFO, InvalidObjectAddress, InvalidOid, IsSystemRelation(), IsToastNamespace(), NewGUCNestLevel(), NoLock, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, ReindexParams::options, pg_rusage_init(), pg_rusage_show(), pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), progress, PROGRESS_COMMAND_CREATE_INDEX, PROGRESS_CREATEIDX_ACCESS_METHOD_OID, PROGRESS_CREATEIDX_COMMAND, PROGRESS_CREATEIDX_COMMAND_REINDEX, PROGRESS_CREATEIDX_INDEX_OID, RelationData::rd_rel, REINDEXOPT_MISSING_OK, REINDEXOPT_REPORT_PROGRESS, REINDEXOPT_VERBOSE, RELATION_IS_OTHER_TEMP, RelationAssumeNewRelfilelocator(), RelationDropStorage(), RelationGetNamespace, RelationGetRelationName, RelationSetNewRelfilenumber(), ResetReindexProcessing(), RestrictSearchPath(), RowExclusiveLock, SearchSysCacheCopy1, SECURITY_RESTRICTED_OPERATION, SetReindexProcessing(), SetRelationTableSpace(), SetUserIdAndSecContext(), ShareLock, stmt, table_close(), table_open(), ReindexParams::tablespaceOid, TransferPredicateLocksToHeapRelation(), try_index_open(), and try_table_open().

Referenced by reindex_relation(), ReindexIndex(), and ReindexMultipleInternal().

reindex_relation()

bool reindex_relation ( const ReindexStmt *  stmt, Oid  relid, int  flags, const ReindexParams *  params  )

extern

Definition at line 3981 of file index.c.

{
    Relation    rel;
    Oid         toast_relid;
    List       *indexIds;
    char        persistence;
    bool        result = false;
    ListCell   *indexId;
    int         i;
 
    /*
     * Open and lock the relation.  ShareLock is sufficient since we only need
     * to prevent schema and data changes in it.  The lock level used here
     * should match ReindexTable().
     */
    if ((params->options & REINDEXOPT_MISSING_OK) != 0)
        rel = try_table_open(relid, ShareLock);
    else
        rel = table_open(relid, ShareLock);
 
    /* if relation is gone, leave */
    if (!rel)
        return false;
 
    /*
     * Partitioned tables should never get processed here, as they have no
     * physical storage.
     */
    if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        elog(ERROR, "cannot reindex partitioned table \"%s.%s\"",
             get_namespace_name(RelationGetNamespace(rel)),
             RelationGetRelationName(rel));
 
    toast_relid = rel->rd_rel->reltoastrelid;
 
    /*
     * Get the list of index OIDs for this relation.  (We trust the relcache
     * to get this with a sequential scan if ignoring system indexes.)
     */
    indexIds = RelationGetIndexList(rel);
 
    if (flags & REINDEX_REL_SUPPRESS_INDEX_USE)
    {
        /* Suppress use of all the indexes until they are rebuilt */
        SetReindexPending(indexIds);
 
        /*
         * Make the new heap contents visible --- now things might be
         * inconsistent!
         */
        CommandCounterIncrement();
    }
 
    /*
     * Reindex the toast table, if any, before the main table.
     *
     * This helps in cases where a corruption in the toast table's index would
     * otherwise error and stop REINDEX TABLE command when it tries to fetch a
     * toasted datum.  This way. the toast table's index is rebuilt and fixed
     * before it is used for reindexing the main table.
     *
     * It is critical to call reindex_relation() *after* the call to
     * RelationGetIndexList() returning the list of indexes on the relation,
     * because reindex_relation() will call CommandCounterIncrement() after
     * every reindex_index().  See REINDEX_REL_SUPPRESS_INDEX_USE for more
     * details.
     */
    if ((flags & REINDEX_REL_PROCESS_TOAST) && OidIsValid(toast_relid))
    {
        /*
         * Note that this should fail if the toast relation is missing, so
         * reset REINDEXOPT_MISSING_OK.  Even if a new tablespace is set for
         * the parent relation, the indexes on its toast table are not moved.
         * This rule is enforced by setting tablespaceOid to InvalidOid.
         */
        ReindexParams newparams = *params;
 
        newparams.options &= ~(REINDEXOPT_MISSING_OK);
        newparams.tablespaceOid = InvalidOid;
        result |= reindex_relation(stmt, toast_relid, flags, &newparams);
    }
 
    /*
     * Compute persistence of indexes: same as that of owning rel, unless
     * caller specified otherwise.
     */
    if (flags & REINDEX_REL_FORCE_INDEXES_UNLOGGED)
        persistence = RELPERSISTENCE_UNLOGGED;
    else if (flags & REINDEX_REL_FORCE_INDEXES_PERMANENT)
        persistence = RELPERSISTENCE_PERMANENT;
    else
        persistence = rel->rd_rel->relpersistence;
 
    /* Reindex all the indexes. */
    i = 1;
    foreach(indexId, indexIds)
    {
        Oid         indexOid = lfirst_oid(indexId);
        Oid         indexNamespaceId = get_rel_namespace(indexOid);
 
        /*
         * Skip any invalid indexes on a TOAST table.  These can only be
         * duplicate leftovers from a failed REINDEX CONCURRENTLY, and if
         * rebuilt it would not be possible to drop them anymore.
         */
        if (IsToastNamespace(indexNamespaceId) &&
            !get_index_isvalid(indexOid))
        {
            ereport(WARNING,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot reindex invalid index \"%s.%s\" on TOAST table, skipping",
                            get_namespace_name(indexNamespaceId),
                            get_rel_name(indexOid))));
 
            /*
             * Remove this invalid toast index from the reindex pending list,
             * as it is skipped here due to the hard failure that would happen
             * in reindex_index(), should we try to process it.
             */
            if (flags & REINDEX_REL_SUPPRESS_INDEX_USE)
                RemoveReindexPending(indexOid);
            continue;
        }
 
        reindex_index(stmt, indexOid, !(flags & REINDEX_REL_CHECK_CONSTRAINTS),
                      persistence, params);
 
        CommandCounterIncrement();
 
        /* Index should no longer be in the pending list */
        Assert(!ReindexIsProcessingIndex(indexOid));
 
        /* Set index rebuild count */
        pgstat_progress_update_param(PROGRESS_REPACK_INDEX_REBUILD_COUNT,
                                     i);
        i++;
    }
 
    /*
     * Close rel, but continue to hold the lock.
     */
    table_close(rel, NoLock);
 
    result |= (indexIds != NIL);
 
    return result;
}

References Assert, CommandCounterIncrement(), elog, ereport, errcode(), errmsg, ERROR, fb(), get_index_isvalid(), get_namespace_name(), get_rel_name(), get_rel_namespace(), i, InvalidOid, IsToastNamespace(), lfirst_oid, NIL, NoLock, OidIsValid, ReindexParams::options, pgstat_progress_update_param(), PROGRESS_REPACK_INDEX_REBUILD_COUNT, RelationData::rd_rel, reindex_index(), REINDEX_REL_CHECK_CONSTRAINTS, REINDEX_REL_FORCE_INDEXES_PERMANENT, REINDEX_REL_FORCE_INDEXES_UNLOGGED, REINDEX_REL_PROCESS_TOAST, REINDEX_REL_SUPPRESS_INDEX_USE, reindex_relation(), ReindexIsProcessingIndex(), REINDEXOPT_MISSING_OK, RelationGetIndexList(), RelationGetNamespace, RelationGetRelationName, RemoveReindexPending(), result, SetReindexPending(), ShareLock, stmt, table_close(), table_open(), try_table_open(), and WARNING.

Referenced by ExecuteTruncateGuts(), finish_heap_swap(), reindex_relation(), ReindexMultipleInternal(), and ReindexTable().

ReindexIsProcessingHeap()

bool ReindexIsProcessingHeap ( Oid  heapOid )

extern

Definition at line 4152 of file index.c.

{
    return heapOid == currentlyReindexedHeap;
}

References currentlyReindexedHeap.

ReindexIsProcessingIndex()

bool ReindexIsProcessingIndex ( Oid  indexOid )

extern

Definition at line 4173 of file index.c.

{
    return indexOid == currentlyReindexedIndex ||
        list_member_oid(pendingReindexedIndexes, indexOid);
}

References currentlyReindexedIndex, list_member_oid(), and pendingReindexedIndexes.

Referenced by CatalogIndexInsert(), reindex_relation(), systable_beginscan(), and systable_beginscan_ordered().

ResetReindexState()

void ResetReindexState ( int  nestLevel )

extern

Definition at line 4246 of file index.c.

{
    /*
     * Because reindexing is not re-entrant, we don't need to cope with nested
     * reindexing states.  We just need to avoid messing up the outer-level
     * state in case a subtransaction fails within a REINDEX.  So checking the
     * current nest level against that of the reindex operation is sufficient.
     */
    if (reindexingNestLevel >= nestLevel)
    {
        currentlyReindexedHeap = InvalidOid;
        currentlyReindexedIndex = InvalidOid;
 
        /*
         * We needn't try to release the contents of pendingReindexedIndexes;
         * that list should be in a transaction-lifespan context, so it will
         * go away automatically.
         */
        pendingReindexedIndexes = NIL;
 
        reindexingNestLevel = 0;
    }
}

References currentlyReindexedHeap, currentlyReindexedIndex, InvalidOid, NIL, pendingReindexedIndexes, and reindexingNestLevel.

Referenced by AbortSubTransaction(), and AbortTransaction().

RestoreReindexState()

void RestoreReindexState ( const void *  reindexstate )

extern

Definition at line 4304 of file index.c.

{
    const SerializedReindexState *sistate = (const SerializedReindexState *) reindexstate;
    int         c = 0;
    MemoryContext oldcontext;
 
    currentlyReindexedHeap = sistate->currentlyReindexedHeap;
    currentlyReindexedIndex = sistate->currentlyReindexedIndex;
 
    Assert(pendingReindexedIndexes == NIL);
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
    for (c = 0; c < sistate->numPendingReindexedIndexes; ++c)
        pendingReindexedIndexes =
            lappend_oid(pendingReindexedIndexes,
                        sistate->pendingReindexedIndexes[c]);
    MemoryContextSwitchTo(oldcontext);
 
    /* Note the worker has its own transaction nesting level */
    reindexingNestLevel = GetCurrentTransactionNestLevel();
}

References Assert, currentlyReindexedHeap, currentlyReindexedIndex, fb(), GetCurrentTransactionNestLevel(), lappend_oid(), MemoryContextSwitchTo(), NIL, pendingReindexedIndexes, reindexingNestLevel, and TopMemoryContext.

Referenced by ParallelWorkerMain().

SerializeReindexState()

void SerializeReindexState ( Size  maxsize, char *  start_address  )

extern

Definition at line 4286 of file index.c.

{
    SerializedReindexState *sistate = (SerializedReindexState *) start_address;
    int         c = 0;
    ListCell   *lc;
 
    sistate->currentlyReindexedHeap = currentlyReindexedHeap;
    sistate->currentlyReindexedIndex = currentlyReindexedIndex;
    sistate->numPendingReindexedIndexes = list_length(pendingReindexedIndexes);
    foreach(lc, pendingReindexedIndexes)
        sistate->pendingReindexedIndexes[c++] = lfirst_oid(lc);
}

References currentlyReindexedHeap, currentlyReindexedIndex, fb(), lfirst_oid, list_length(), and pendingReindexedIndexes.

Referenced by InitializeParallelDSM().

validate_index()

void validate_index ( Oid  heapId, Oid  indexId, Snapshot  snapshot  )

extern

Definition at line 3383 of file index.c.

{
    Relation    heapRelation,
                indexRelation;
    IndexInfo  *indexInfo;
    IndexVacuumInfo ivinfo;
    ValidateIndexState state;
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
 
    {
        const int   progress_index[] = {
            PROGRESS_CREATEIDX_PHASE,
            PROGRESS_CREATEIDX_TUPLES_DONE,
            PROGRESS_CREATEIDX_TUPLES_TOTAL,
            PROGRESS_SCAN_BLOCKS_DONE,
            PROGRESS_SCAN_BLOCKS_TOTAL
        };
        const int64 progress_vals[] = {
            PROGRESS_CREATEIDX_PHASE_VALIDATE_IDXSCAN,
            0, 0, 0, 0
        };
 
        pgstat_progress_update_multi_param(5, progress_index, progress_vals);
    }
 
    /* Open and lock the parent heap relation */
    heapRelation = table_open(heapId, ShareUpdateExclusiveLock);
 
    /*
     * Switch to the table owner's userid, so that any index functions are run
     * as that user.  Also lock down security-restricted operations and
     * arrange to make GUC variable changes local to this command.
     */
    GetUserIdAndSecContext(&save_userid, &save_sec_context);
    SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
                           save_sec_context | SECURITY_RESTRICTED_OPERATION);
    save_nestlevel = NewGUCNestLevel();
    RestrictSearchPath();
 
    indexRelation = index_open(indexId, RowExclusiveLock);
 
    /*
     * Fetch info needed for index_insert.  (You might think this should be
     * passed in from DefineIndex, but its copy is long gone due to having
     * been built in a previous transaction.)
     */
    indexInfo = BuildIndexInfo(indexRelation);
 
    /* mark build is concurrent just for consistency */
    indexInfo->ii_Concurrent = true;
 
    /*
     * Scan the index and gather up all the TIDs into a tuplesort object.
     */
    ivinfo.index = indexRelation;
    ivinfo.heaprel = heapRelation;
    ivinfo.analyze_only = false;
    ivinfo.report_progress = true;
    ivinfo.estimated_count = true;
    ivinfo.message_level = DEBUG2;
    ivinfo.num_heap_tuples = heapRelation->rd_rel->reltuples;
    ivinfo.strategy = NULL;
 
    /*
     * Encode TIDs as int8 values for the sort, rather than directly sorting
     * item pointers.  This can be significantly faster, primarily because TID
     * is a pass-by-reference type on all platforms, whereas int8 is
     * pass-by-value on most platforms.
     */
    state.tuplesort = tuplesort_begin_datum(INT8OID, Int8LessOperator,
                                            InvalidOid, false,
                                            maintenance_work_mem,
                                            NULL, TUPLESORT_NONE);
    state.htups = state.itups = state.tups_inserted = 0;
 
    /* ambulkdelete updates progress metrics */
    (void) index_bulk_delete(&ivinfo, NULL,
                             validate_index_callback, &state);
 
    /* Execute the sort */
    {
        const int   progress_index[] = {
            PROGRESS_CREATEIDX_PHASE,
            PROGRESS_SCAN_BLOCKS_DONE,
            PROGRESS_SCAN_BLOCKS_TOTAL
        };
        const int64 progress_vals[] = {
            PROGRESS_CREATEIDX_PHASE_VALIDATE_SORT,
            0, 0
        };
 
        pgstat_progress_update_multi_param(3, progress_index, progress_vals);
    }
    tuplesort_performsort(state.tuplesort);
 
    /*
     * Now scan the heap and "merge" it with the index
     */
    pgstat_progress_update_param(PROGRESS_CREATEIDX_PHASE,
                                 PROGRESS_CREATEIDX_PHASE_VALIDATE_TABLESCAN);
    table_index_validate_scan(heapRelation,
                              indexRelation,
                              indexInfo,
                              snapshot,
                              &state);
 
    /* Done with tuplesort object */
    tuplesort_end(state.tuplesort);
 
    /* Make sure to release resources cached in indexInfo (if needed). */
    index_insert_cleanup(indexRelation, indexInfo);
 
    elog(DEBUG2,
         "validate_index found %.0f heap tuples, %.0f index tuples; inserted %.0f missing tuples",
         state.htups, state.itups, state.tups_inserted);
 
    /* Roll back any GUC changes executed by index functions */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
 
    /* Close rels, but keep locks */
    index_close(indexRelation, NoLock);
    table_close(heapRelation, NoLock);
}

References AtEOXact_GUC(), BuildIndexInfo(), DEBUG2, elog, fb(), GetUserIdAndSecContext(), IndexInfo::ii_Concurrent, index_bulk_delete(), index_close(), index_insert_cleanup(), index_open(), InvalidOid, maintenance_work_mem, NewGUCNestLevel(), NoLock, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_CREATEIDX_PHASE, PROGRESS_CREATEIDX_PHASE_VALIDATE_IDXSCAN, PROGRESS_CREATEIDX_PHASE_VALIDATE_SORT, PROGRESS_CREATEIDX_PHASE_VALIDATE_TABLESCAN, PROGRESS_CREATEIDX_TUPLES_DONE, PROGRESS_CREATEIDX_TUPLES_TOTAL, PROGRESS_SCAN_BLOCKS_DONE, PROGRESS_SCAN_BLOCKS_TOTAL, RelationData::rd_rel, RestrictSearchPath(), RowExclusiveLock, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), ShareUpdateExclusiveLock, table_close(), table_index_validate_scan(), table_open(), tuplesort_begin_datum(), tuplesort_end(), TUPLESORT_NONE, tuplesort_performsort(), and validate_index_callback().

Referenced by DefineIndex(), and ReindexRelationConcurrently().