PostgreSQL Source Code  git master
index.h File Reference
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_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 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 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, bits16 flags, bits16 constr_flags, bool allow_system_table_mods, bool is_internal, Oid *constraintId)
 
Oid index_concurrently_create_copy (Relation heapRelation, 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, bits16 constr_flags, bool allow_system_table_mods, bool is_internal)
 
void index_drop (Oid indexId, bool concurrent, bool concurrent_lock_mode)
 
IndexInfoBuildIndexInfo (Relation index)
 
IndexInfoBuildDummyIndexInfo (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)
 
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 (ItemPointer itemptr)
 
static void itemptr_decode (ItemPointer itemptr, int64 encoded)
 

Macro Definition Documentation

◆ DEFAULT_INDEX_TYPE

#define DEFAULT_INDEX_TYPE   "btree"

Definition at line 21 of file index.h.

◆ INDEX_CONSTR_CREATE_DEFERRABLE

#define INDEX_CONSTR_CREATE_DEFERRABLE   (1 << 1)

Definition at line 92 of file index.h.

◆ INDEX_CONSTR_CREATE_INIT_DEFERRED

#define INDEX_CONSTR_CREATE_INIT_DEFERRED   (1 << 2)

Definition at line 93 of file index.h.

◆ INDEX_CONSTR_CREATE_MARK_AS_PRIMARY

#define INDEX_CONSTR_CREATE_MARK_AS_PRIMARY   (1 << 0)

Definition at line 91 of file index.h.

◆ INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS

#define INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS   (1 << 4)

Definition at line 95 of file index.h.

◆ INDEX_CONSTR_CREATE_UPDATE_INDEX

#define INDEX_CONSTR_CREATE_UPDATE_INDEX   (1 << 3)

Definition at line 94 of file index.h.

◆ INDEX_CREATE_ADD_CONSTRAINT

#define INDEX_CREATE_ADD_CONSTRAINT   (1 << 1)

Definition at line 62 of file index.h.

◆ INDEX_CREATE_CONCURRENT

#define INDEX_CREATE_CONCURRENT   (1 << 3)

Definition at line 64 of file index.h.

◆ INDEX_CREATE_IF_NOT_EXISTS

#define INDEX_CREATE_IF_NOT_EXISTS   (1 << 4)

Definition at line 65 of file index.h.

◆ INDEX_CREATE_INVALID

#define INDEX_CREATE_INVALID   (1 << 6)

Definition at line 67 of file index.h.

◆ INDEX_CREATE_IS_PRIMARY

#define INDEX_CREATE_IS_PRIMARY   (1 << 0)

Definition at line 61 of file index.h.

◆ INDEX_CREATE_PARTITIONED

#define INDEX_CREATE_PARTITIONED   (1 << 5)

Definition at line 66 of file index.h.

◆ INDEX_CREATE_SKIP_BUILD

#define INDEX_CREATE_SKIP_BUILD   (1 << 2)

Definition at line 63 of file index.h.

◆ REINDEX_REL_CHECK_CONSTRAINTS

#define REINDEX_REL_CHECK_CONSTRAINTS   0x04

Definition at line 160 of file index.h.

◆ REINDEX_REL_FORCE_INDEXES_PERMANENT

#define REINDEX_REL_FORCE_INDEXES_PERMANENT   0x10

Definition at line 162 of file index.h.

◆ REINDEX_REL_FORCE_INDEXES_UNLOGGED

#define REINDEX_REL_FORCE_INDEXES_UNLOGGED   0x08

Definition at line 161 of file index.h.

◆ REINDEX_REL_PROCESS_TOAST

#define REINDEX_REL_PROCESS_TOAST   0x01

Definition at line 158 of file index.h.

◆ REINDEX_REL_SUPPRESS_INDEX_USE

#define REINDEX_REL_SUPPRESS_INDEX_USE   0x02

Definition at line 159 of file index.h.

◆ REINDEXOPT_CONCURRENTLY

#define REINDEXOPT_CONCURRENTLY   0x08 /* concurrent mode */

Definition at line 44 of file index.h.

◆ REINDEXOPT_MISSING_OK

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

Definition at line 43 of file index.h.

◆ REINDEXOPT_REPORT_PROGRESS

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

Definition at line 42 of file index.h.

◆ REINDEXOPT_VERBOSE

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

Definition at line 41 of file index.h.

Typedef Documentation

◆ ReindexParams

typedef struct ReindexParams ReindexParams

◆ ValidateIndexState

Enumeration Type Documentation

◆ IndexStateFlagsAction

Enumerator
INDEX_CREATE_SET_READY 
INDEX_CREATE_SET_VALID 
INDEX_DROP_CLEAR_VALID 
INDEX_DROP_SET_DEAD 

Definition at line 24 of file index.h.

25 {
IndexStateFlagsAction
Definition: index.h:25
@ INDEX_CREATE_SET_VALID
Definition: index.h:27
@ INDEX_DROP_CLEAR_VALID
Definition: index.h:28
@ INDEX_DROP_SET_DEAD
Definition: index.h:29
@ INDEX_CREATE_SET_READY
Definition: index.h:26

Function Documentation

◆ BuildDummyIndexInfo()

IndexInfo* BuildDummyIndexInfo ( Relation  index)

Definition at line 2462 of file index.c.

2463 {
2464  IndexInfo *ii;
2465  Form_pg_index indexStruct = index->rd_index;
2466  int i;
2467  int numAtts;
2468 
2469  /* check the number of keys, and copy attr numbers into the IndexInfo */
2470  numAtts = indexStruct->indnatts;
2471  if (numAtts < 1 || numAtts > INDEX_MAX_KEYS)
2472  elog(ERROR, "invalid indnatts %d for index %u",
2473  numAtts, RelationGetRelid(index));
2474 
2475  /*
2476  * Create the node, using dummy index expressions, and pretending there is
2477  * no predicate.
2478  */
2479  ii = makeIndexInfo(indexStruct->indnatts,
2480  indexStruct->indnkeyatts,
2481  index->rd_rel->relam,
2483  NIL,
2484  indexStruct->indisunique,
2485  indexStruct->indnullsnotdistinct,
2486  indexStruct->indisready,
2487  false,
2488  index->rd_indam->amsummarizing);
2489 
2490  /* fill in attribute numbers */
2491  for (i = 0; i < numAtts; i++)
2492  ii->ii_IndexAttrNumbers[i] = indexStruct->indkey.values[i];
2493 
2494  /* We ignore the exclusion constraint if any */
2495 
2496  return ii;
2497 }
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
int i
Definition: isn.c:73
IndexInfo * makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions, List *predicates, bool unique, bool nulls_not_distinct, bool isready, bool concurrent, bool summarizing)
Definition: makefuncs.c:761
#define INDEX_MAX_KEYS
FormData_pg_index * Form_pg_index
Definition: pg_index.h:70
#define NIL
Definition: pg_list.h:68
#define RelationGetRelid(relation)
Definition: rel.h:505
List * RelationGetDummyIndexExpressions(Relation relation)
Definition: relcache.c:5096
AttrNumber ii_IndexAttrNumbers[INDEX_MAX_KEYS]
Definition: execnodes.h:186
Definition: type.h:95

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

Referenced by RelationTruncateIndexes().

◆ BuildIndexInfo()

IndexInfo* BuildIndexInfo ( Relation  index)

Definition at line 2403 of file index.c.

2404 {
2405  IndexInfo *ii;
2406  Form_pg_index indexStruct = index->rd_index;
2407  int i;
2408  int numAtts;
2409 
2410  /* check the number of keys, and copy attr numbers into the IndexInfo */
2411  numAtts = indexStruct->indnatts;
2412  if (numAtts < 1 || numAtts > INDEX_MAX_KEYS)
2413  elog(ERROR, "invalid indnatts %d for index %u",
2414  numAtts, RelationGetRelid(index));
2415 
2416  /*
2417  * Create the node, fetching any expressions needed for expressional
2418  * indexes and index predicate if any.
2419  */
2420  ii = makeIndexInfo(indexStruct->indnatts,
2421  indexStruct->indnkeyatts,
2422  index->rd_rel->relam,
2425  indexStruct->indisunique,
2426  indexStruct->indnullsnotdistinct,
2427  indexStruct->indisready,
2428  false,
2429  index->rd_indam->amsummarizing);
2430 
2431  /* fill in attribute numbers */
2432  for (i = 0; i < numAtts; i++)
2433  ii->ii_IndexAttrNumbers[i] = indexStruct->indkey.values[i];
2434 
2435  /* fetch exclusion constraint info if any */
2436  if (indexStruct->indisexclusion)
2437  {
2439  &ii->ii_ExclusionOps,
2440  &ii->ii_ExclusionProcs,
2441  &ii->ii_ExclusionStrats);
2442  }
2443 
2444  return ii;
2445 }
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
List * RelationGetIndexPredicate(Relation relation)
Definition: relcache.c:5150
void RelationGetExclusionInfo(Relation indexRelation, Oid **operators, Oid **procs, uint16 **strategies)
Definition: relcache.c:5590
List * RelationGetIndexExpressions(Relation relation)
Definition: relcache.c:5037
uint16 * ii_ExclusionStrats
Definition: execnodes.h:193
Oid * ii_ExclusionOps
Definition: execnodes.h:191
Oid * ii_ExclusionProcs
Definition: execnodes.h:192

References elog, ERROR, i, if(), 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(), ATExecAddIndexConstraint(), ATExecAttachPartitionIdx(), AttachPartitionEnsureIndexes(), brinsummarize(), bt_check_every_level(), DefineIndex(), do_analyze_rel(), ExecOpenIndices(), FindReplTupleInLocalRel(), FindUsableIndexForReplicaIdentityFull(), index_concurrently_build(), index_concurrently_create_copy(), reindex_index(), tuplesort_begin_cluster(), and validate_index().

◆ BuildSpeculativeIndexInfo()

void BuildSpeculativeIndexInfo ( Relation  index,
IndexInfo ii 
)

Definition at line 2641 of file index.c.

2642 {
2643  int indnkeyatts;
2644  int i;
2645 
2647 
2648  /*
2649  * fetch info for checking unique indexes
2650  */
2651  Assert(ii->ii_Unique);
2652 
2653  if (index->rd_rel->relam != BTREE_AM_OID)
2654  elog(ERROR, "unexpected non-btree speculative unique index");
2655 
2656  ii->ii_UniqueOps = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
2657  ii->ii_UniqueProcs = (Oid *) palloc(sizeof(Oid) * indnkeyatts);
2658  ii->ii_UniqueStrats = (uint16 *) palloc(sizeof(uint16) * indnkeyatts);
2659 
2660  /*
2661  * We have to look up the operator's strategy number. This provides a
2662  * cross-check that the operator does match the index.
2663  */
2664  /* We need the func OIDs and strategy numbers too */
2665  for (i = 0; i < indnkeyatts; i++)
2666  {
2668  ii->ii_UniqueOps[i] =
2669  get_opfamily_member(index->rd_opfamily[i],
2670  index->rd_opcintype[i],
2671  index->rd_opcintype[i],
2672  ii->ii_UniqueStrats[i]);
2673  if (!OidIsValid(ii->ii_UniqueOps[i]))
2674  elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
2675  ii->ii_UniqueStrats[i], index->rd_opcintype[i],
2676  index->rd_opcintype[i], index->rd_opfamily[i]);
2677  ii->ii_UniqueProcs[i] = get_opcode(ii->ii_UniqueOps[i]);
2678  }
2679 }
unsigned short uint16
Definition: c.h:505
#define Assert(condition)
Definition: c.h:858
#define OidIsValid(objectId)
Definition: c.h:775
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1285
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Definition: lsyscache.c:166
void * palloc(Size size)
Definition: mcxt.c:1316
unsigned int Oid
Definition: postgres_ext.h:31
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition: rel.h:524
#define BTEqualStrategyNumber
Definition: stratnum.h:31
bool ii_Unique
Definition: execnodes.h:197
Oid * ii_UniqueOps
Definition: execnodes.h:194
uint16 * ii_UniqueStrats
Definition: execnodes.h:196
Oid * ii_UniqueProcs
Definition: execnodes.h:195

References Assert, BTEqualStrategyNumber, elog, ERROR, get_opcode(), get_opfamily_member(), i, IndexInfo::ii_Unique, IndexInfo::ii_UniqueOps, IndexInfo::ii_UniqueProcs, IndexInfo::ii_UniqueStrats, IndexRelationGetNumberOfKeyAttributes, OidIsValid, and palloc().

Referenced by 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 
)

Definition at line 2510 of file index.c.

2514 {
2515  int i;
2516 
2517  if (info1->ii_Unique != info2->ii_Unique)
2518  return false;
2519 
2520  if (info1->ii_NullsNotDistinct != info2->ii_NullsNotDistinct)
2521  return false;
2522 
2523  /* indexes are only equivalent if they have the same access method */
2524  if (info1->ii_Am != info2->ii_Am)
2525  return false;
2526 
2527  /* and same number of attributes */
2528  if (info1->ii_NumIndexAttrs != info2->ii_NumIndexAttrs)
2529  return false;
2530 
2531  /* and same number of key attributes */
2532  if (info1->ii_NumIndexKeyAttrs != info2->ii_NumIndexKeyAttrs)
2533  return false;
2534 
2535  /*
2536  * and columns match through the attribute map (actual attribute numbers
2537  * might differ!) Note that this checks that index columns that are
2538  * expressions appear in the same positions. We will next compare the
2539  * expressions themselves.
2540  */
2541  for (i = 0; i < info1->ii_NumIndexAttrs; i++)
2542  {
2543  if (attmap->maplen < info2->ii_IndexAttrNumbers[i])
2544  elog(ERROR, "incorrect attribute map");
2545 
2546  /* ignore expressions for now (but check their collation/opfamily) */
2547  if (!(info1->ii_IndexAttrNumbers[i] == InvalidAttrNumber &&
2549  {
2550  /* fail if just one index has an expression in this column */
2551  if (info1->ii_IndexAttrNumbers[i] == InvalidAttrNumber ||
2553  return false;
2554 
2555  /* both are columns, so check for match after mapping */
2556  if (attmap->attnums[info2->ii_IndexAttrNumbers[i] - 1] !=
2557  info1->ii_IndexAttrNumbers[i])
2558  return false;
2559  }
2560 
2561  /* collation and opfamily are not valid for included columns */
2562  if (i >= info1->ii_NumIndexKeyAttrs)
2563  continue;
2564 
2565  if (collations1[i] != collations2[i])
2566  return false;
2567  if (opfamilies1[i] != opfamilies2[i])
2568  return false;
2569  }
2570 
2571  /*
2572  * For expression indexes: either both are expression indexes, or neither
2573  * is; if they are, make sure the expressions match.
2574  */
2575  if ((info1->ii_Expressions != NIL) != (info2->ii_Expressions != NIL))
2576  return false;
2577  if (info1->ii_Expressions != NIL)
2578  {
2579  bool found_whole_row;
2580  Node *mapped;
2581 
2582  mapped = map_variable_attnos((Node *) info2->ii_Expressions,
2583  1, 0, attmap,
2584  InvalidOid, &found_whole_row);
2585  if (found_whole_row)
2586  {
2587  /*
2588  * we could throw an error here, but seems out of scope for this
2589  * routine.
2590  */
2591  return false;
2592  }
2593 
2594  if (!equal(info1->ii_Expressions, mapped))
2595  return false;
2596  }
2597 
2598  /* Partial index predicates must be identical, if they exist */
2599  if ((info1->ii_Predicate == NULL) != (info2->ii_Predicate == NULL))
2600  return false;
2601  if (info1->ii_Predicate != NULL)
2602  {
2603  bool found_whole_row;
2604  Node *mapped;
2605 
2606  mapped = map_variable_attnos((Node *) info2->ii_Predicate,
2607  1, 0, attmap,
2608  InvalidOid, &found_whole_row);
2609  if (found_whole_row)
2610  {
2611  /*
2612  * we could throw an error here, but seems out of scope for this
2613  * routine.
2614  */
2615  return false;
2616  }
2617  if (!equal(info1->ii_Predicate, mapped))
2618  return false;
2619  }
2620 
2621  /* No support currently for comparing exclusion indexes. */
2622  if (info1->ii_ExclusionOps != NULL || info2->ii_ExclusionOps != NULL)
2623  return false;
2624 
2625  return true;
2626 }
#define InvalidAttrNumber
Definition: attnum.h:23
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
#define InvalidOid
Definition: postgres_ext.h:36
Node * map_variable_attnos(Node *node, int target_varno, int sublevels_up, const AttrMap *attno_map, Oid to_rowtype, bool *found_whole_row)
int maplen
Definition: attmap.h:37
AttrNumber * attnums
Definition: attmap.h:36
int ii_NumIndexAttrs
Definition: execnodes.h:184
bool ii_NullsNotDistinct
Definition: execnodes.h:198
int ii_NumIndexKeyAttrs
Definition: execnodes.h:185
List * ii_Expressions
Definition: execnodes.h:187
Oid ii_Am
Definition: execnodes.h:206
List * ii_Predicate
Definition: execnodes.h:189
Definition: nodes.h:129

References AttrMap::attnums, elog, equal(), ERROR, i, IndexInfo::ii_Am, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Expressions, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NullsNotDistinct, IndexInfo::ii_NumIndexAttrs, IndexInfo::ii_NumIndexKeyAttrs, IndexInfo::ii_Predicate, IndexInfo::ii_Unique, InvalidAttrNumber, InvalidOid, map_variable_attnos(), AttrMap::maplen, and NIL.

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

◆ EstimateReindexStateSpace()

Size EstimateReindexStateSpace ( void  )

Definition at line 4174 of file index.c.

4175 {
4178 }
static List * pendingReindexedIndexes
Definition: index.c:4043
static int list_length(const List *l)
Definition: pg_list.h:152
Size mul_size(Size s1, Size s2)
Definition: shmem.c:510

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

Referenced by InitializeParallelDSM().

◆ FormIndexDatum()

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

Definition at line 2701 of file index.c.

2706 {
2707  ListCell *indexpr_item;
2708  int i;
2709 
2710  if (indexInfo->ii_Expressions != NIL &&
2711  indexInfo->ii_ExpressionsState == NIL)
2712  {
2713  /* First time through, set up expression evaluation state */
2714  indexInfo->ii_ExpressionsState =
2715  ExecPrepareExprList(indexInfo->ii_Expressions, estate);
2716  /* Check caller has set up context correctly */
2717  Assert(GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
2718  }
2719  indexpr_item = list_head(indexInfo->ii_ExpressionsState);
2720 
2721  for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
2722  {
2723  int keycol = indexInfo->ii_IndexAttrNumbers[i];
2724  Datum iDatum;
2725  bool isNull;
2726 
2727  if (keycol < 0)
2728  iDatum = slot_getsysattr(slot, keycol, &isNull);
2729  else if (keycol != 0)
2730  {
2731  /*
2732  * Plain index column; get the value we need directly from the
2733  * heap tuple.
2734  */
2735  iDatum = slot_getattr(slot, keycol, &isNull);
2736  }
2737  else
2738  {
2739  /*
2740  * Index expression --- need to evaluate it.
2741  */
2742  if (indexpr_item == NULL)
2743  elog(ERROR, "wrong number of index expressions");
2744  iDatum = ExecEvalExprSwitchContext((ExprState *) lfirst(indexpr_item),
2745  GetPerTupleExprContext(estate),
2746  &isNull);
2747  indexpr_item = lnext(indexInfo->ii_ExpressionsState, indexpr_item);
2748  }
2749  values[i] = iDatum;
2750  isnull[i] = isNull;
2751  }
2752 
2753  if (indexpr_item != NULL)
2754  elog(ERROR, "wrong number of index expressions");
2755 }
static Datum values[MAXATTR]
Definition: bootstrap.c:152
List * ExecPrepareExprList(List *nodes, EState *estate)
Definition: execExpr.c:813
#define GetPerTupleExprContext(estate)
Definition: executor.h:550
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:348
#define lfirst(lc)
Definition: pg_list.h:172
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
uintptr_t Datum
Definition: postgres.h:64
List * ii_ExpressionsState
Definition: execnodes.h:188
static Datum slot_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:416
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:395

References Assert, elog, ERROR, ExecEvalExprSwitchContext(), ExecPrepareExprList(), 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 CatalogIndexInsert(), check_exclusion_or_unique_constraint(), comparetup_cluster_tiebreak(), compute_index_stats(), ExecCheckIndexConstraints(), ExecInsertIndexTuples(), heapam_index_build_range_scan(), heapam_index_validate_scan(), and IndexCheckExclusion().

◆ index_build()

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

Definition at line 2941 of file index.c.

2946 {
2947  IndexBuildResult *stats;
2948  Oid save_userid;
2949  int save_sec_context;
2950  int save_nestlevel;
2951 
2952  /*
2953  * sanity checks
2954  */
2955  Assert(RelationIsValid(indexRelation));
2956  Assert(PointerIsValid(indexRelation->rd_indam));
2957  Assert(PointerIsValid(indexRelation->rd_indam->ambuild));
2958  Assert(PointerIsValid(indexRelation->rd_indam->ambuildempty));
2959 
2960  /*
2961  * Determine worker process details for parallel CREATE INDEX. Currently,
2962  * only btree has support for parallel builds.
2963  *
2964  * Note that planner considers parallel safety for us.
2965  */
2966  if (parallel && IsNormalProcessingMode() &&
2967  indexRelation->rd_indam->amcanbuildparallel)
2968  indexInfo->ii_ParallelWorkers =
2970  RelationGetRelid(indexRelation));
2971 
2972  if (indexInfo->ii_ParallelWorkers == 0)
2973  ereport(DEBUG1,
2974  (errmsg_internal("building index \"%s\" on table \"%s\" serially",
2975  RelationGetRelationName(indexRelation),
2976  RelationGetRelationName(heapRelation))));
2977  else
2978  ereport(DEBUG1,
2979  (errmsg_internal("building index \"%s\" on table \"%s\" with request for %d parallel workers",
2980  RelationGetRelationName(indexRelation),
2981  RelationGetRelationName(heapRelation),
2982  indexInfo->ii_ParallelWorkers)));
2983 
2984  /*
2985  * Switch to the table owner's userid, so that any index functions are run
2986  * as that user. Also lock down security-restricted operations and
2987  * arrange to make GUC variable changes local to this command.
2988  */
2989  GetUserIdAndSecContext(&save_userid, &save_sec_context);
2990  SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
2991  save_sec_context | SECURITY_RESTRICTED_OPERATION);
2992  save_nestlevel = NewGUCNestLevel();
2994 
2995  /* Set up initial progress report status */
2996  {
2997  const int progress_index[] = {
3004  };
3005  const int64 progress_vals[] = {
3008  0, 0, 0, 0
3009  };
3010 
3011  pgstat_progress_update_multi_param(6, progress_index, progress_vals);
3012  }
3013 
3014  /*
3015  * Call the access method's build procedure
3016  */
3017  stats = indexRelation->rd_indam->ambuild(heapRelation, indexRelation,
3018  indexInfo);
3019  Assert(PointerIsValid(stats));
3020 
3021  /*
3022  * If this is an unlogged index, we may need to write out an init fork for
3023  * it -- but we must first check whether one already exists. If, for
3024  * example, an unlogged relation is truncated in the transaction that
3025  * created it, or truncated twice in a subsequent transaction, the
3026  * relfilenumber won't change, and nothing needs to be done here.
3027  */
3028  if (indexRelation->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
3029  !smgrexists(RelationGetSmgr(indexRelation), INIT_FORKNUM))
3030  {
3031  smgrcreate(RelationGetSmgr(indexRelation), INIT_FORKNUM, false);
3032  log_smgrcreate(&indexRelation->rd_locator, INIT_FORKNUM);
3033  indexRelation->rd_indam->ambuildempty(indexRelation);
3034  }
3035 
3036  /*
3037  * If we found any potentially broken HOT chains, mark the index as not
3038  * being usable until the current transaction is below the event horizon.
3039  * See src/backend/access/heap/README.HOT for discussion. While it might
3040  * become safe to use the index earlier based on actual cleanup activity
3041  * and other active transactions, the test for that would be much more
3042  * complex and would require some form of blocking, so keep it simple and
3043  * fast by just using the current transaction.
3044  *
3045  * However, when reindexing an existing index, we should do nothing here.
3046  * Any HOT chains that are broken with respect to the index must predate
3047  * the index's original creation, so there is no need to change the
3048  * index's usability horizon. Moreover, we *must not* try to change the
3049  * index's pg_index entry while reindexing pg_index itself, and this
3050  * optimization nicely prevents that. The more complex rules needed for a
3051  * reindex are handled separately after this function returns.
3052  *
3053  * We also need not set indcheckxmin during a concurrent index build,
3054  * because we won't set indisvalid true until all transactions that care
3055  * about the broken HOT chains are gone.
3056  *
3057  * Therefore, this code path can only be taken during non-concurrent
3058  * CREATE INDEX. Thus the fact that heap_update will set the pg_index
3059  * tuple's xmin doesn't matter, because that tuple was created in the
3060  * current transaction anyway. That also means we don't need to worry
3061  * about any concurrent readers of the tuple; no other transaction can see
3062  * it yet.
3063  */
3064  if (indexInfo->ii_BrokenHotChain &&
3065  !isreindex &&
3066  !indexInfo->ii_Concurrent)
3067  {
3068  Oid indexId = RelationGetRelid(indexRelation);
3069  Relation pg_index;
3070  HeapTuple indexTuple;
3071  Form_pg_index indexForm;
3072 
3073  pg_index = table_open(IndexRelationId, RowExclusiveLock);
3074 
3075  indexTuple = SearchSysCacheCopy1(INDEXRELID,
3076  ObjectIdGetDatum(indexId));
3077  if (!HeapTupleIsValid(indexTuple))
3078  elog(ERROR, "cache lookup failed for index %u", indexId);
3079  indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
3080 
3081  /* If it's a new index, indcheckxmin shouldn't be set ... */
3082  Assert(!indexForm->indcheckxmin);
3083 
3084  indexForm->indcheckxmin = true;
3085  CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
3086 
3087  heap_freetuple(indexTuple);
3088  table_close(pg_index, RowExclusiveLock);
3089  }
3090 
3091  /*
3092  * Update heap and index pg_class rows
3093  */
3094  index_update_stats(heapRelation,
3095  true,
3096  stats->heap_tuples);
3097 
3098  index_update_stats(indexRelation,
3099  false,
3100  stats->index_tuples);
3101 
3102  /* Make the updated catalog row versions visible */
3104 
3105  /*
3106  * If it's for an exclusion constraint, make a second pass over the heap
3107  * to verify that the constraint is satisfied. We must not do this until
3108  * the index is fully valid. (Broken HOT chains shouldn't matter, though;
3109  * see comments for IndexCheckExclusion.)
3110  */
3111  if (indexInfo->ii_ExclusionOps != NULL)
3112  IndexCheckExclusion(heapRelation, indexRelation, indexInfo);
3113 
3114  /* Roll back any GUC changes executed by index functions */
3115  AtEOXact_GUC(false, save_nestlevel);
3116 
3117  /* Restore userid and security context */
3118  SetUserIdAndSecContext(save_userid, save_sec_context);
3119 }
void pgstat_progress_update_multi_param(int nparam, const int *index, const int64 *val)
#define PointerIsValid(pointer)
Definition: c.h:763
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
#define DEBUG1
Definition: elog.h:30
#define ereport(elevel,...)
Definition: elog.h:149
int NewGUCNestLevel(void)
Definition: guc.c:2237
void RestrictSearchPath(void)
Definition: guc.c:2248
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2264
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
static void index_update_stats(Relation rel, bool hasindex, double reltuples)
Definition: index.c:2780
static void IndexCheckExclusion(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo)
Definition: index.c:3134
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
#define RowExclusiveLock
Definition: lockdefs.h:38
#define SECURITY_RESTRICTED_OPERATION
Definition: miscadmin.h:315
#define IsNormalProcessingMode()
Definition: miscadmin.h:456
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition: miscinit.c:635
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition: miscinit.c:642
int plan_create_index_workers(Oid tableOid, Oid indexOid)
Definition: planner.c:6781
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define PROGRESS_CREATEIDX_PHASE_BUILD
Definition: progress.h:94
#define PROGRESS_CREATEIDX_TUPLES_TOTAL
Definition: progress.h:86
#define PROGRESS_SCAN_BLOCKS_DONE
Definition: progress.h:122
#define PROGRESS_CREATEIDX_TUPLES_DONE
Definition: progress.h:87
#define PROGRESS_CREATEIDX_SUBPHASE
Definition: progress.h:85
#define PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE
Definition: progress.h:106
#define PROGRESS_CREATEIDX_PHASE
Definition: progress.h:84
#define PROGRESS_SCAN_BLOCKS_TOTAL
Definition: progress.h:121
static SMgrRelation RelationGetSmgr(Relation rel)
Definition: rel.h:567
#define RelationGetRelationName(relation)
Definition: rel.h:539
#define RelationIsValid(relation)
Definition: rel.h:478
@ INIT_FORKNUM
Definition: relpath.h:53
void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
Definition: smgr.c:411
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:398
void log_smgrcreate(const RelFileLocator *rlocator, ForkNumber forkNum)
Definition: storage.c:186
ItemPointerData t_self
Definition: htup.h:65
ambuildempty_function ambuildempty
Definition: amapi.h:268
ambuild_function ambuild
Definition: amapi.h:267
bool amcanbuildparallel
Definition: amapi.h:248
double heap_tuples
Definition: genam.h:32
double index_tuples
Definition: genam.h:33
bool ii_BrokenHotChain
Definition: execnodes.h:203
int ii_ParallelWorkers
Definition: execnodes.h:205
bool ii_Concurrent
Definition: execnodes.h:202
struct IndexAmRoutine * rd_indam
Definition: rel.h:206
RelFileLocator rd_locator
Definition: rel.h:57
Form_pg_class rd_rel
Definition: rel.h:111
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:86
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void CommandCounterIncrement(void)
Definition: xact.c:1097

References IndexAmRoutine::ambuild, IndexAmRoutine::ambuildempty, IndexAmRoutine::amcanbuildparallel, Assert, AtEOXact_GUC(), CatalogTupleUpdate(), CommandCounterIncrement(), DEBUG1, elog, ereport, errmsg_internal(), ERROR, 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(), PointerIsValid, 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(), HeapTupleData::t_self, 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 
)

Definition at line 201 of file index.c.

205 {
206  int i;
207 
208  /*
209  * If ALTER TABLE or CREATE TABLE .. PARTITION OF, check that there isn't
210  * already a PRIMARY KEY. In CREATE TABLE for an ordinary relation, we
211  * have faith that the parser rejected multiple pkey clauses; and CREATE
212  * INDEX doesn't have a way to say PRIMARY KEY, so it's no problem either.
213  */
214  if ((is_alter_table || heapRel->rd_rel->relispartition) &&
215  relationHasPrimaryKey(heapRel))
216  {
217  ereport(ERROR,
218  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
219  errmsg("multiple primary keys for table \"%s\" are not allowed",
220  RelationGetRelationName(heapRel))));
221  }
222 
223  /*
224  * Indexes created with NULLS NOT DISTINCT cannot be used for primary key
225  * constraints. While there is no direct syntax to reach here, it can be
226  * done by creating a separate index and attaching it via ALTER TABLE ..
227  * USING INDEX.
228  */
229  if (indexInfo->ii_NullsNotDistinct)
230  {
231  ereport(ERROR,
232  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
233  errmsg("primary keys cannot use NULLS NOT DISTINCT indexes")));
234  }
235 
236  /*
237  * Check that all of the attributes in a primary key are marked as not
238  * null. (We don't really expect to see that; it'd mean the parser messed
239  * up. But it seems wise to check anyway.)
240  */
241  for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
242  {
243  AttrNumber attnum = indexInfo->ii_IndexAttrNumbers[i];
244  HeapTuple atttuple;
245  Form_pg_attribute attform;
246 
247  if (attnum == 0)
248  ereport(ERROR,
249  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
250  errmsg("primary keys cannot be expressions")));
251 
252  /* System attributes are never null, so no need to check */
253  if (attnum < 0)
254  continue;
255 
256  atttuple = SearchSysCache2(ATTNUM,
259  if (!HeapTupleIsValid(atttuple))
260  elog(ERROR, "cache lookup failed for attribute %d of relation %u",
261  attnum, RelationGetRelid(heapRel));
262  attform = (Form_pg_attribute) GETSTRUCT(atttuple);
263 
264  if (!attform->attnotnull)
265  ereport(ERROR,
266  (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
267  errmsg("primary key column \"%s\" is not marked NOT NULL",
268  NameStr(attform->attname))));
269 
270  ReleaseSysCache(atttuple);
271  }
272 }
int16 AttrNumber
Definition: attnum.h:21
#define NameStr(name)
Definition: c.h:746
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
static bool relationHasPrimaryKey(Relation rel)
Definition: index.c:147
int16 attnum
Definition: pg_attribute.h:74
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:172
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)
Definition: syscache.c:229

References attnum, elog, ereport, errcode(), errmsg(), ERROR, 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 
)

Definition at line 1481 of file index.c.

1483 {
1484  Relation heapRel;
1485  Oid save_userid;
1486  int save_sec_context;
1487  int save_nestlevel;
1488  Relation indexRelation;
1489  IndexInfo *indexInfo;
1490 
1491  /* This had better make sure that a snapshot is active */
1493 
1494  /* Open and lock the parent heap relation */
1495  heapRel = table_open(heapRelationId, ShareUpdateExclusiveLock);
1496 
1497  /*
1498  * Switch to the table owner's userid, so that any index functions are run
1499  * as that user. Also lock down security-restricted operations and
1500  * arrange to make GUC variable changes local to this command.
1501  */
1502  GetUserIdAndSecContext(&save_userid, &save_sec_context);
1503  SetUserIdAndSecContext(heapRel->rd_rel->relowner,
1504  save_sec_context | SECURITY_RESTRICTED_OPERATION);
1505  save_nestlevel = NewGUCNestLevel();
1507 
1508  indexRelation = index_open(indexRelationId, RowExclusiveLock);
1509 
1510  /*
1511  * We have to re-build the IndexInfo struct, since it was lost in the
1512  * commit of the transaction where this concurrent index was created at
1513  * the catalog level.
1514  */
1515  indexInfo = BuildIndexInfo(indexRelation);
1516  Assert(!indexInfo->ii_ReadyForInserts);
1517  indexInfo->ii_Concurrent = true;
1518  indexInfo->ii_BrokenHotChain = false;
1519 
1520  /* Now build the index */
1521  index_build(heapRel, indexRelation, indexInfo, false, true);
1522 
1523  /* Roll back any GUC changes executed by index functions */
1524  AtEOXact_GUC(false, save_nestlevel);
1525 
1526  /* Restore userid and security context */
1527  SetUserIdAndSecContext(save_userid, save_sec_context);
1528 
1529  /* Close both the relations, but keep the locks */
1530  table_close(heapRel, NoLock);
1531  index_close(indexRelation, NoLock);
1532 
1533  /*
1534  * Update the pg_index row to mark the index as ready for inserts. Once we
1535  * commit this transaction, any new transactions that open the table must
1536  * insert new entries into the index for insertions and non-HOT updates.
1537  */
1539 }
void index_set_state_flags(Oid indexId, IndexStateFlagsAction action)
Definition: index.c:3443
void index_build(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool isreindex, bool parallel)
Definition: index.c:2941
IndexInfo * BuildIndexInfo(Relation index)
Definition: index.c:2403
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
#define NoLock
Definition: lockdefs.h:34
#define ShareUpdateExclusiveLock
Definition: lockdefs.h:39
bool ActiveSnapshotSet(void)
Definition: snapmgr.c:782
bool ii_ReadyForInserts
Definition: execnodes.h:199

References ActiveSnapshotSet(), Assert, AtEOXact_GUC(), BuildIndexInfo(), 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_create_copy()

Oid index_concurrently_create_copy ( Relation  heapRelation,
Oid  oldIndexId,
Oid  tablespaceOid,
const char *  newName 
)

Definition at line 1297 of file index.c.

1299 {
1300  Relation indexRelation;
1301  IndexInfo *oldInfo,
1302  *newInfo;
1303  Oid newIndexId = InvalidOid;
1304  HeapTuple indexTuple,
1305  classTuple;
1306  Datum indclassDatum,
1307  colOptionDatum,
1308  reloptionsDatum;
1309  Datum *opclassOptions;
1310  oidvector *indclass;
1311  int2vector *indcoloptions;
1312  NullableDatum *stattargets;
1313  bool isnull;
1314  List *indexColNames = NIL;
1315  List *indexExprs = NIL;
1316  List *indexPreds = NIL;
1317 
1318  indexRelation = index_open(oldIndexId, RowExclusiveLock);
1319 
1320  /* The new index needs some information from the old index */
1321  oldInfo = BuildIndexInfo(indexRelation);
1322 
1323  /*
1324  * Concurrent build of an index with exclusion constraints is not
1325  * supported.
1326  */
1327  if (oldInfo->ii_ExclusionOps != NULL)
1328  ereport(ERROR,
1329  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1330  errmsg("concurrent index creation for exclusion constraints is not supported")));
1331 
1332  /* Get the array of class and column options IDs from index info */
1333  indexTuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(oldIndexId));
1334  if (!HeapTupleIsValid(indexTuple))
1335  elog(ERROR, "cache lookup failed for index %u", oldIndexId);
1336  indclassDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
1337  Anum_pg_index_indclass);
1338  indclass = (oidvector *) DatumGetPointer(indclassDatum);
1339 
1340  colOptionDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
1341  Anum_pg_index_indoption);
1342  indcoloptions = (int2vector *) DatumGetPointer(colOptionDatum);
1343 
1344  /* Fetch reloptions of index if any */
1345  classTuple = SearchSysCache1(RELOID, ObjectIdGetDatum(oldIndexId));
1346  if (!HeapTupleIsValid(classTuple))
1347  elog(ERROR, "cache lookup failed for relation %u", oldIndexId);
1348  reloptionsDatum = SysCacheGetAttr(RELOID, classTuple,
1349  Anum_pg_class_reloptions, &isnull);
1350 
1351  /*
1352  * Fetch the list of expressions and predicates directly from the
1353  * catalogs. This cannot rely on the information from IndexInfo of the
1354  * old index as these have been flattened for the planner.
1355  */
1356  if (oldInfo->ii_Expressions != NIL)
1357  {
1358  Datum exprDatum;
1359  char *exprString;
1360 
1361  exprDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
1362  Anum_pg_index_indexprs);
1363  exprString = TextDatumGetCString(exprDatum);
1364  indexExprs = (List *) stringToNode(exprString);
1365  pfree(exprString);
1366  }
1367  if (oldInfo->ii_Predicate != NIL)
1368  {
1369  Datum predDatum;
1370  char *predString;
1371 
1372  predDatum = SysCacheGetAttrNotNull(INDEXRELID, indexTuple,
1373  Anum_pg_index_indpred);
1374  predString = TextDatumGetCString(predDatum);
1375  indexPreds = (List *) stringToNode(predString);
1376 
1377  /* Also convert to implicit-AND format */
1378  indexPreds = make_ands_implicit((Expr *) indexPreds);
1379  pfree(predString);
1380  }
1381 
1382  /*
1383  * Build the index information for the new index. Note that rebuild of
1384  * indexes with exclusion constraints is not supported, hence there is no
1385  * need to fill all the ii_Exclusion* fields.
1386  */
1387  newInfo = makeIndexInfo(oldInfo->ii_NumIndexAttrs,
1388  oldInfo->ii_NumIndexKeyAttrs,
1389  oldInfo->ii_Am,
1390  indexExprs,
1391  indexPreds,
1392  oldInfo->ii_Unique,
1393  oldInfo->ii_NullsNotDistinct,
1394  false, /* not ready for inserts */
1395  true,
1396  indexRelation->rd_indam->amsummarizing);
1397 
1398  /*
1399  * Extract the list of column names and the column numbers for the new
1400  * index information. All this information will be used for the index
1401  * creation.
1402  */
1403  for (int i = 0; i < oldInfo->ii_NumIndexAttrs; i++)
1404  {
1405  TupleDesc indexTupDesc = RelationGetDescr(indexRelation);
1406  Form_pg_attribute att = TupleDescAttr(indexTupDesc, i);
1407 
1408  indexColNames = lappend(indexColNames, NameStr(att->attname));
1409  newInfo->ii_IndexAttrNumbers[i] = oldInfo->ii_IndexAttrNumbers[i];
1410  }
1411 
1412  /* Extract opclass options for each attribute */
1413  opclassOptions = palloc0(sizeof(Datum) * newInfo->ii_NumIndexAttrs);
1414  for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
1415  opclassOptions[i] = get_attoptions(oldIndexId, i + 1);
1416 
1417  /* Extract statistic targets for each attribute */
1418  stattargets = palloc0_array(NullableDatum, newInfo->ii_NumIndexAttrs);
1419  for (int i = 0; i < newInfo->ii_NumIndexAttrs; i++)
1420  {
1421  HeapTuple tp;
1422  Datum dat;
1423 
1424  tp = SearchSysCache2(ATTNUM, ObjectIdGetDatum(oldIndexId), Int16GetDatum(i + 1));
1425  if (!HeapTupleIsValid(tp))
1426  elog(ERROR, "cache lookup failed for attribute %d of relation %u",
1427  i + 1, oldIndexId);
1428  dat = SysCacheGetAttr(ATTNUM, tp, Anum_pg_attribute_attstattarget, &isnull);
1429  ReleaseSysCache(tp);
1430  stattargets[i].value = dat;
1431  stattargets[i].isnull = isnull;
1432  }
1433 
1434  /*
1435  * Now create the new index.
1436  *
1437  * For a partition index, we adjust the partition dependency later, to
1438  * ensure a consistent state at all times. That is why parentIndexRelid
1439  * is not set here.
1440  */
1441  newIndexId = index_create(heapRelation,
1442  newName,
1443  InvalidOid, /* indexRelationId */
1444  InvalidOid, /* parentIndexRelid */
1445  InvalidOid, /* parentConstraintId */
1446  InvalidRelFileNumber, /* relFileNumber */
1447  newInfo,
1448  indexColNames,
1449  indexRelation->rd_rel->relam,
1450  tablespaceOid,
1451  indexRelation->rd_indcollation,
1452  indclass->values,
1453  opclassOptions,
1454  indcoloptions->values,
1455  stattargets,
1456  reloptionsDatum,
1458  0,
1459  true, /* allow table to be a system catalog? */
1460  false, /* is_internal? */
1461  NULL);
1462 
1463  /* Close the relations used and clean up */
1464  index_close(indexRelation, NoLock);
1465  ReleaseSysCache(indexTuple);
1466  ReleaseSysCache(classTuple);
1467 
1468  return newIndexId;
1469 }
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define palloc0_array(type, count)
Definition: fe_memutils.h:65
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, bits16 flags, bits16 constr_flags, bool allow_system_table_mods, bool is_internal, Oid *constraintId)
Definition: index.c:724
#define INDEX_CREATE_SKIP_BUILD
Definition: index.h:63
#define INDEX_CREATE_CONCURRENT
Definition: index.h:64
List * lappend(List *list, void *datum)
Definition: list.c:339
Datum get_attoptions(Oid relid, int16 attnum)
Definition: lsyscache.c:970
List * make_ands_implicit(Expr *clause)
Definition: makefuncs.c:737
void pfree(void *pointer)
Definition: mcxt.c:1520
void * palloc0(Size size)
Definition: mcxt.c:1346
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
void * stringToNode(const char *str)
Definition: read.c:90
#define RelationGetDescr(relation)
Definition: rel.h:531
#define InvalidRelFileNumber
Definition: relpath.h:26
bool amsummarizing
Definition: amapi.h:254
Definition: pg_list.h:54
Datum value
Definition: postgres.h:75
bool isnull
Definition: postgres.h:77
Oid * rd_indcollation
Definition: rel.h:217
Definition: c.h:715
int16 values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:722
Definition: c.h:726
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:733
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:479
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:510
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92

References IndexAmRoutine::amsummarizing, BuildIndexInfo(), DatumGetPointer(), elog, ereport, errcode(), errmsg(), ERROR, get_attoptions(), HeapTupleIsValid, i, IndexInfo::ii_Am, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Expressions, IndexInfo::ii_IndexAttrNumbers, IndexInfo::ii_NullsNotDistinct, IndexInfo::ii_NumIndexAttrs, IndexInfo::ii_NumIndexKeyAttrs, IndexInfo::ii_Predicate, IndexInfo::ii_Unique, index_close(), index_create(), INDEX_CREATE_CONCURRENT, INDEX_CREATE_SKIP_BUILD, index_open(), Int16GetDatum(), InvalidOid, InvalidRelFileNumber, NullableDatum::isnull, lappend(), make_ands_implicit(), makeIndexInfo(), NameStr, NIL, NoLock, ObjectIdGetDatum(), palloc0(), palloc0_array, pfree(), RelationData::rd_indam, RelationData::rd_indcollation, RelationData::rd_rel, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, TupleDescAttr, NullableDatum::value, int2vector::values, and oidvector::values.

Referenced by ReindexRelationConcurrently().

◆ index_concurrently_set_dead()

void index_concurrently_set_dead ( Oid  heapId,
Oid  indexId 
)

Definition at line 1819 of file index.c.

1820 {
1821  Relation userHeapRelation;
1822  Relation userIndexRelation;
1823 
1824  /*
1825  * No more predicate locks will be acquired on this index, and we're about
1826  * to stop doing inserts into the index which could show conflicts with
1827  * existing predicate locks, so now is the time to move them to the heap
1828  * relation.
1829  */
1830  userHeapRelation = table_open(heapId, ShareUpdateExclusiveLock);
1831  userIndexRelation = index_open(indexId, ShareUpdateExclusiveLock);
1832  TransferPredicateLocksToHeapRelation(userIndexRelation);
1833 
1834  /*
1835  * Now we are sure that nobody uses the index for queries; they just might
1836  * have it open for updating it. So now we can unset indisready and
1837  * indislive, then wait till nobody could be using it at all anymore.
1838  */
1840 
1841  /*
1842  * Invalidate the relcache for the table, so that after this commit all
1843  * sessions will refresh the table's index list. Forgetting just the
1844  * index's relcache entry is not enough.
1845  */
1846  CacheInvalidateRelcache(userHeapRelation);
1847 
1848  /*
1849  * Close the relations again, though still holding session lock.
1850  */
1851  table_close(userHeapRelation, NoLock);
1852  index_close(userIndexRelation, NoLock);
1853 }
void CacheInvalidateRelcache(Relation relation)
Definition: inval.c:1360
void TransferPredicateLocksToHeapRelation(Relation relation)
Definition: predicate.c:3108

References CacheInvalidateRelcache(), 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 
)

Definition at line 1548 of file index.c.

1549 {
1550  Relation pg_class,
1551  pg_index,
1552  pg_constraint,
1553  pg_trigger;
1554  Relation oldClassRel,
1555  newClassRel;
1556  HeapTuple oldClassTuple,
1557  newClassTuple;
1558  Form_pg_class oldClassForm,
1559  newClassForm;
1560  HeapTuple oldIndexTuple,
1561  newIndexTuple;
1562  Form_pg_index oldIndexForm,
1563  newIndexForm;
1564  bool isPartition;
1565  Oid indexConstraintOid;
1566  List *constraintOids = NIL;
1567  ListCell *lc;
1568 
1569  /*
1570  * Take a necessary lock on the old and new index before swapping them.
1571  */
1572  oldClassRel = relation_open(oldIndexId, ShareUpdateExclusiveLock);
1573  newClassRel = relation_open(newIndexId, ShareUpdateExclusiveLock);
1574 
1575  /* Now swap names and dependencies of those indexes */
1576  pg_class = table_open(RelationRelationId, RowExclusiveLock);
1577 
1578  oldClassTuple = SearchSysCacheCopy1(RELOID,
1579  ObjectIdGetDatum(oldIndexId));
1580  if (!HeapTupleIsValid(oldClassTuple))
1581  elog(ERROR, "could not find tuple for relation %u", oldIndexId);
1582  newClassTuple = SearchSysCacheCopy1(RELOID,
1583  ObjectIdGetDatum(newIndexId));
1584  if (!HeapTupleIsValid(newClassTuple))
1585  elog(ERROR, "could not find tuple for relation %u", newIndexId);
1586 
1587  oldClassForm = (Form_pg_class) GETSTRUCT(oldClassTuple);
1588  newClassForm = (Form_pg_class) GETSTRUCT(newClassTuple);
1589 
1590  /* Swap the names */
1591  namestrcpy(&newClassForm->relname, NameStr(oldClassForm->relname));
1592  namestrcpy(&oldClassForm->relname, oldName);
1593 
1594  /* Swap the partition flags to track inheritance properly */
1595  isPartition = newClassForm->relispartition;
1596  newClassForm->relispartition = oldClassForm->relispartition;
1597  oldClassForm->relispartition = isPartition;
1598 
1599  CatalogTupleUpdate(pg_class, &oldClassTuple->t_self, oldClassTuple);
1600  CatalogTupleUpdate(pg_class, &newClassTuple->t_self, newClassTuple);
1601 
1602  heap_freetuple(oldClassTuple);
1603  heap_freetuple(newClassTuple);
1604 
1605  /* Now swap index info */
1606  pg_index = table_open(IndexRelationId, RowExclusiveLock);
1607 
1608  oldIndexTuple = SearchSysCacheCopy1(INDEXRELID,
1609  ObjectIdGetDatum(oldIndexId));
1610  if (!HeapTupleIsValid(oldIndexTuple))
1611  elog(ERROR, "could not find tuple for relation %u", oldIndexId);
1612  newIndexTuple = SearchSysCacheCopy1(INDEXRELID,
1613  ObjectIdGetDatum(newIndexId));
1614  if (!HeapTupleIsValid(newIndexTuple))
1615  elog(ERROR, "could not find tuple for relation %u", newIndexId);
1616 
1617  oldIndexForm = (Form_pg_index) GETSTRUCT(oldIndexTuple);
1618  newIndexForm = (Form_pg_index) GETSTRUCT(newIndexTuple);
1619 
1620  /*
1621  * Copy constraint flags from the old index. This is safe because the old
1622  * index guaranteed uniqueness.
1623  */
1624  newIndexForm->indisprimary = oldIndexForm->indisprimary;
1625  oldIndexForm->indisprimary = false;
1626  newIndexForm->indisexclusion = oldIndexForm->indisexclusion;
1627  oldIndexForm->indisexclusion = false;
1628  newIndexForm->indimmediate = oldIndexForm->indimmediate;
1629  oldIndexForm->indimmediate = true;
1630 
1631  /* Preserve indisreplident in the new index */
1632  newIndexForm->indisreplident = oldIndexForm->indisreplident;
1633 
1634  /* Preserve indisclustered in the new index */
1635  newIndexForm->indisclustered = oldIndexForm->indisclustered;
1636 
1637  /*
1638  * Mark the new index as valid, and the old index as invalid similarly to
1639  * what index_set_state_flags() does.
1640  */
1641  newIndexForm->indisvalid = true;
1642  oldIndexForm->indisvalid = false;
1643  oldIndexForm->indisclustered = false;
1644  oldIndexForm->indisreplident = false;
1645 
1646  CatalogTupleUpdate(pg_index, &oldIndexTuple->t_self, oldIndexTuple);
1647  CatalogTupleUpdate(pg_index, &newIndexTuple->t_self, newIndexTuple);
1648 
1649  heap_freetuple(oldIndexTuple);
1650  heap_freetuple(newIndexTuple);
1651 
1652  /*
1653  * Move constraints and triggers over to the new index
1654  */
1655 
1656  constraintOids = get_index_ref_constraints(oldIndexId);
1657 
1658  indexConstraintOid = get_index_constraint(oldIndexId);
1659 
1660  if (OidIsValid(indexConstraintOid))
1661  constraintOids = lappend_oid(constraintOids, indexConstraintOid);
1662 
1663  pg_constraint = table_open(ConstraintRelationId, RowExclusiveLock);
1664  pg_trigger = table_open(TriggerRelationId, RowExclusiveLock);
1665 
1666  foreach(lc, constraintOids)
1667  {
1668  HeapTuple constraintTuple,
1669  triggerTuple;
1670  Form_pg_constraint conForm;
1671  ScanKeyData key[1];
1672  SysScanDesc scan;
1673  Oid constraintOid = lfirst_oid(lc);
1674 
1675  /* Move the constraint from the old to the new index */
1676  constraintTuple = SearchSysCacheCopy1(CONSTROID,
1677  ObjectIdGetDatum(constraintOid));
1678  if (!HeapTupleIsValid(constraintTuple))
1679  elog(ERROR, "could not find tuple for constraint %u", constraintOid);
1680 
1681  conForm = ((Form_pg_constraint) GETSTRUCT(constraintTuple));
1682 
1683  if (conForm->conindid == oldIndexId)
1684  {
1685  conForm->conindid = newIndexId;
1686 
1687  CatalogTupleUpdate(pg_constraint, &constraintTuple->t_self, constraintTuple);
1688  }
1689 
1690  heap_freetuple(constraintTuple);
1691 
1692  /* Search for trigger records */
1693  ScanKeyInit(&key[0],
1694  Anum_pg_trigger_tgconstraint,
1695  BTEqualStrategyNumber, F_OIDEQ,
1696  ObjectIdGetDatum(constraintOid));
1697 
1698  scan = systable_beginscan(pg_trigger, TriggerConstraintIndexId, true,
1699  NULL, 1, key);
1700 
1701  while (HeapTupleIsValid((triggerTuple = systable_getnext(scan))))
1702  {
1703  Form_pg_trigger tgForm = (Form_pg_trigger) GETSTRUCT(triggerTuple);
1704 
1705  if (tgForm->tgconstrindid != oldIndexId)
1706  continue;
1707 
1708  /* Make a modifiable copy */
1709  triggerTuple = heap_copytuple(triggerTuple);
1710  tgForm = (Form_pg_trigger) GETSTRUCT(triggerTuple);
1711 
1712  tgForm->tgconstrindid = newIndexId;
1713 
1714  CatalogTupleUpdate(pg_trigger, &triggerTuple->t_self, triggerTuple);
1715 
1716  heap_freetuple(triggerTuple);
1717  }
1718 
1719  systable_endscan(scan);
1720  }
1721 
1722  /*
1723  * Move comment if any
1724  */
1725  {
1727  ScanKeyData skey[3];
1728  SysScanDesc sd;
1729  HeapTuple tuple;
1730  Datum values[Natts_pg_description] = {0};
1731  bool nulls[Natts_pg_description] = {0};
1732  bool replaces[Natts_pg_description] = {0};
1733 
1734  values[Anum_pg_description_objoid - 1] = ObjectIdGetDatum(newIndexId);
1735  replaces[Anum_pg_description_objoid - 1] = true;
1736 
1737  ScanKeyInit(&skey[0],
1738  Anum_pg_description_objoid,
1739  BTEqualStrategyNumber, F_OIDEQ,
1740  ObjectIdGetDatum(oldIndexId));
1741  ScanKeyInit(&skey[1],
1742  Anum_pg_description_classoid,
1743  BTEqualStrategyNumber, F_OIDEQ,
1744  ObjectIdGetDatum(RelationRelationId));
1745  ScanKeyInit(&skey[2],
1746  Anum_pg_description_objsubid,
1747  BTEqualStrategyNumber, F_INT4EQ,
1748  Int32GetDatum(0));
1749 
1750  description = table_open(DescriptionRelationId, RowExclusiveLock);
1751 
1752  sd = systable_beginscan(description, DescriptionObjIndexId, true,
1753  NULL, 3, skey);
1754 
1755  while ((tuple = systable_getnext(sd)) != NULL)
1756  {
1758  values, nulls, replaces);
1759  CatalogTupleUpdate(description, &tuple->t_self, tuple);
1760 
1761  break; /* Assume there can be only one match */
1762  }
1763 
1764  systable_endscan(sd);
1766  }
1767 
1768  /*
1769  * Swap inheritance relationship with parent index
1770  */
1771  if (get_rel_relispartition(oldIndexId))
1772  {
1773  List *ancestors = get_partition_ancestors(oldIndexId);
1774  Oid parentIndexRelid = linitial_oid(ancestors);
1775 
1776  DeleteInheritsTuple(oldIndexId, parentIndexRelid, false, NULL);
1777  StoreSingleInheritance(newIndexId, parentIndexRelid, 1);
1778 
1779  list_free(ancestors);
1780  }
1781 
1782  /*
1783  * Swap all dependencies of and on the old index to the new one, and
1784  * vice-versa. Note that a call to CommandCounterIncrement() would cause
1785  * duplicate entries in pg_depend, so this should not be done.
1786  */
1787  changeDependenciesOf(RelationRelationId, newIndexId, oldIndexId);
1788  changeDependenciesOn(RelationRelationId, newIndexId, oldIndexId);
1789 
1790  changeDependenciesOf(RelationRelationId, oldIndexId, newIndexId);
1791  changeDependenciesOn(RelationRelationId, oldIndexId, newIndexId);
1792 
1793  /* copy over statistics from old to new index */
1794  pgstat_copy_relation_stats(newClassRel, oldClassRel);
1795 
1796  /* Copy data of pg_statistic from the old index to the new one */
1797  CopyStatistics(oldIndexId, newIndexId);
1798 
1799  /* Close relations */
1800  table_close(pg_class, RowExclusiveLock);
1801  table_close(pg_index, RowExclusiveLock);
1802  table_close(pg_constraint, RowExclusiveLock);
1803  table_close(pg_trigger, RowExclusiveLock);
1804 
1805  /* The lock taken previously is not released until the end of transaction */
1806  relation_close(oldClassRel, NoLock);
1807  relation_close(newClassRel, NoLock);
1808 }
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:596
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:503
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:384
void CopyStatistics(Oid fromrelid, Oid torelid)
Definition: heap.c:2862
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
Definition: heaptuple.c:1209
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:776
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
void list_free(List *list)
Definition: list.c:1546
bool get_rel_relispartition(Oid relid)
Definition: lsyscache.c:2027
void namestrcpy(Name name, const char *str)
Definition: name.c:233
List * get_partition_ancestors(Oid relid)
Definition: partition.c:134
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
FormData_pg_constraint * Form_pg_constraint
long changeDependenciesOf(Oid classId, Oid oldObjectId, Oid newObjectId)
Definition: pg_depend.c:566
long changeDependenciesOn(Oid refClassId, Oid oldRefObjectId, Oid newRefObjectId)
Definition: pg_depend.c:622
Oid get_index_constraint(Oid indexId)
Definition: pg_depend.c:989
List * get_index_ref_constraints(Oid indexId)
Definition: pg_depend.c:1045
bool DeleteInheritsTuple(Oid inhrelid, Oid inhparent, bool expect_detach_pending, const char *childname)
Definition: pg_inherits.c:552
void StoreSingleInheritance(Oid relationId, Oid parentOid, int32 seqNumber)
Definition: pg_inherits.c:508
#define linitial_oid(l)
Definition: pg_list.h:180
#define lfirst_oid(lc)
Definition: pg_list.h:174
FormData_pg_trigger * Form_pg_trigger
Definition: pg_trigger.h:80
void pgstat_copy_relation_stats(Relation dst, Relation src)
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
void relation_close(Relation relation, LOCKMODE lockmode)
Definition: relation.c:205
Relation relation_open(Oid relationId, LOCKMODE lockmode)
Definition: relation.c:47
const char * description

References BTEqualStrategyNumber, CatalogTupleUpdate(), changeDependenciesOf(), changeDependenciesOn(), CopyStatistics(), DeleteInheritsTuple(), description, elog, ERROR, get_index_constraint(), get_index_ref_constraints(), get_partition_ancestors(), get_rel_relispartition(), GETSTRUCT, heap_copytuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, Int32GetDatum(), sort-test::key, 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,
bits16  constr_flags,
bool  allow_system_table_mods,
bool  is_internal 
)

Definition at line 1880 of file index.c.

1889 {
1890  Oid namespaceId = RelationGetNamespace(heapRelation);
1891  ObjectAddress myself,
1892  idxaddr;
1893  Oid conOid;
1894  bool deferrable;
1895  bool initdeferred;
1896  bool mark_as_primary;
1897  bool islocal;
1898  bool noinherit;
1899  int inhcount;
1900 
1901  deferrable = (constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) != 0;
1902  initdeferred = (constr_flags & INDEX_CONSTR_CREATE_INIT_DEFERRED) != 0;
1903  mark_as_primary = (constr_flags & INDEX_CONSTR_CREATE_MARK_AS_PRIMARY) != 0;
1904 
1905  /* constraint creation support doesn't work while bootstrapping */
1907 
1908  /* enforce system-table restriction */
1909  if (!allow_system_table_mods &&
1910  IsSystemRelation(heapRelation) &&
1912  ereport(ERROR,
1913  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1914  errmsg("user-defined indexes on system catalog tables are not supported")));
1915 
1916  /* primary/unique constraints shouldn't have any expressions */
1917  if (indexInfo->ii_Expressions &&
1918  constraintType != CONSTRAINT_EXCLUSION)
1919  elog(ERROR, "constraints cannot have index expressions");
1920 
1921  /*
1922  * If we're manufacturing a constraint for a pre-existing index, we need
1923  * to get rid of the existing auto dependencies for the index (the ones
1924  * that index_create() would have made instead of calling this function).
1925  *
1926  * Note: this code would not necessarily do the right thing if the index
1927  * has any expressions or predicate, but we'd never be turning such an
1928  * index into a UNIQUE or PRIMARY KEY constraint.
1929  */
1930  if (constr_flags & INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS)
1931  deleteDependencyRecordsForClass(RelationRelationId, indexRelationId,
1932  RelationRelationId, DEPENDENCY_AUTO);
1933 
1934  if (OidIsValid(parentConstraintId))
1935  {
1936  islocal = false;
1937  inhcount = 1;
1938  noinherit = false;
1939  }
1940  else
1941  {
1942  islocal = true;
1943  inhcount = 0;
1944  noinherit = true;
1945  }
1946 
1947  /*
1948  * Construct a pg_constraint entry.
1949  */
1950  conOid = CreateConstraintEntry(constraintName,
1951  namespaceId,
1952  constraintType,
1953  deferrable,
1954  initdeferred,
1955  true,
1956  parentConstraintId,
1957  RelationGetRelid(heapRelation),
1958  indexInfo->ii_IndexAttrNumbers,
1959  indexInfo->ii_NumIndexKeyAttrs,
1960  indexInfo->ii_NumIndexAttrs,
1961  InvalidOid, /* no domain */
1962  indexRelationId, /* index OID */
1963  InvalidOid, /* no foreign key */
1964  NULL,
1965  NULL,
1966  NULL,
1967  NULL,
1968  0,
1969  ' ',
1970  ' ',
1971  NULL,
1972  0,
1973  ' ',
1974  indexInfo->ii_ExclusionOps,
1975  NULL, /* no check constraint */
1976  NULL,
1977  islocal,
1978  inhcount,
1979  noinherit,
1980  is_internal);
1981 
1982  /*
1983  * Register the index as internally dependent on the constraint.
1984  *
1985  * Note that the constraint has a dependency on the table, so we don't
1986  * need (or want) any direct dependency from the index to the table.
1987  */
1988  ObjectAddressSet(myself, ConstraintRelationId, conOid);
1989  ObjectAddressSet(idxaddr, RelationRelationId, indexRelationId);
1990  recordDependencyOn(&idxaddr, &myself, DEPENDENCY_INTERNAL);
1991 
1992  /*
1993  * Also, if this is a constraint on a partition, give it partition-type
1994  * dependencies on the parent constraint as well as the table.
1995  */
1996  if (OidIsValid(parentConstraintId))
1997  {
1998  ObjectAddress referenced;
1999 
2000  ObjectAddressSet(referenced, ConstraintRelationId, parentConstraintId);
2001  recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
2002  ObjectAddressSet(referenced, RelationRelationId,
2003  RelationGetRelid(heapRelation));
2004  recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
2005  }
2006 
2007  /*
2008  * If the constraint is deferrable, create the deferred uniqueness
2009  * checking trigger. (The trigger will be given an internal dependency on
2010  * the constraint by CreateTrigger.)
2011  */
2012  if (deferrable)
2013  {
2015 
2016  trigger->replace = false;
2017  trigger->isconstraint = true;
2018  trigger->trigname = (constraintType == CONSTRAINT_PRIMARY) ?
2019  "PK_ConstraintTrigger" :
2020  "Unique_ConstraintTrigger";
2021  trigger->relation = NULL;
2022  trigger->funcname = SystemFuncName("unique_key_recheck");
2023  trigger->args = NIL;
2024  trigger->row = true;
2025  trigger->timing = TRIGGER_TYPE_AFTER;
2026  trigger->events = TRIGGER_TYPE_INSERT | TRIGGER_TYPE_UPDATE;
2027  trigger->columns = NIL;
2028  trigger->whenClause = NULL;
2029  trigger->transitionRels = NIL;
2030  trigger->deferrable = true;
2031  trigger->initdeferred = initdeferred;
2032  trigger->constrrel = NULL;
2033 
2034  (void) CreateTrigger(trigger, NULL, RelationGetRelid(heapRelation),
2035  InvalidOid, conOid, indexRelationId, InvalidOid,
2036  InvalidOid, NULL, true, false);
2037  }
2038 
2039  /*
2040  * If needed, mark the index as primary and/or deferred in pg_index.
2041  *
2042  * Note: When making an existing index into a constraint, caller must have
2043  * a table lock that prevents concurrent table updates; otherwise, there
2044  * is a risk that concurrent readers of the table will miss seeing this
2045  * index at all.
2046  */
2047  if ((constr_flags & INDEX_CONSTR_CREATE_UPDATE_INDEX) &&
2048  (mark_as_primary || deferrable))
2049  {
2050  Relation pg_index;
2051  HeapTuple indexTuple;
2052  Form_pg_index indexForm;
2053  bool dirty = false;
2054  bool marked_as_primary = false;
2055 
2056  pg_index = table_open(IndexRelationId, RowExclusiveLock);
2057 
2058  indexTuple = SearchSysCacheCopy1(INDEXRELID,
2059  ObjectIdGetDatum(indexRelationId));
2060  if (!HeapTupleIsValid(indexTuple))
2061  elog(ERROR, "cache lookup failed for index %u", indexRelationId);
2062  indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
2063 
2064  if (mark_as_primary && !indexForm->indisprimary)
2065  {
2066  indexForm->indisprimary = true;
2067  dirty = true;
2068  marked_as_primary = true;
2069  }
2070 
2071  if (deferrable && indexForm->indimmediate)
2072  {
2073  indexForm->indimmediate = false;
2074  dirty = true;
2075  }
2076 
2077  if (dirty)
2078  {
2079  CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
2080 
2081  /*
2082  * When we mark an existing index as primary, force a relcache
2083  * flush on its parent table, so that all sessions will become
2084  * aware that the table now has a primary key. This is important
2085  * because it affects some replication behaviors.
2086  */
2087  if (marked_as_primary)
2088  CacheInvalidateRelcache(heapRelation);
2089 
2090  InvokeObjectPostAlterHookArg(IndexRelationId, indexRelationId, 0,
2091  InvalidOid, is_internal);
2092  }
2093 
2094  heap_freetuple(indexTuple);
2095  table_close(pg_index, RowExclusiveLock);
2096  }
2097 
2098  return myself;
2099 }
bool IsSystemRelation(Relation relation)
Definition: catalog.c:73
@ DEPENDENCY_AUTO
Definition: dependency.h:34
@ DEPENDENCY_INTERNAL
Definition: dependency.h:35
@ DEPENDENCY_PARTITION_PRI
Definition: dependency.h:36
@ DEPENDENCY_PARTITION_SEC
Definition: dependency.h:37
#define INDEX_CONSTR_CREATE_UPDATE_INDEX
Definition: index.h:94
#define INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS
Definition: index.h:95
#define INDEX_CONSTR_CREATE_DEFERRABLE
Definition: index.h:92
#define INDEX_CONSTR_CREATE_MARK_AS_PRIMARY
Definition: index.h:91
#define INDEX_CONSTR_CREATE_INIT_DEFERRED
Definition: index.h:93
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:454
#define makeNode(_type_)
Definition: nodes.h:155
#define InvokeObjectPostAlterHookArg(classId, objectId, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:200
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
List * SystemFuncName(char *name)
Oid CreateConstraintEntry(const char *constraintName, Oid constraintNamespace, char constraintType, bool isDeferrable, bool isDeferred, bool isValidated, Oid parentConstrId, Oid relId, const int16 *constraintKey, int constraintNKeys, int constraintNTotalKeys, Oid domainId, Oid indexRelId, Oid foreignRelId, const int16 *foreignKey, const Oid *pfEqOp, const Oid *ppEqOp, const Oid *ffEqOp, int foreignNKeys, char foreignUpdateType, char foreignDeleteType, const int16 *fkDeleteSetCols, int numFkDeleteSetCols, char foreignMatchType, const Oid *exclOp, Node *conExpr, const char *conBin, bool conIsLocal, int conInhCount, bool conNoInherit, bool is_internal)
Definition: pg_constraint.c:48
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
Definition: pg_depend.c:46
long deleteDependencyRecordsForClass(Oid classId, Oid objectId, Oid refclassId, char deptype)
Definition: pg_depend.c:352
#define RelationGetNamespace(relation)
Definition: rel.h:546
Node * whenClause
Definition: parsenodes.h:3021
List * transitionRels
Definition: parsenodes.h:3023
RangeVar * constrrel
Definition: parsenodes.h:3027
RangeVar * relation
Definition: parsenodes.h:3012
ObjectAddress CreateTrigger(CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition)
Definition: trigger.c:158

References CreateTrigStmt::args, Assert, CacheInvalidateRelcache(), CatalogTupleUpdate(), CreateTrigStmt::columns, CreateTrigStmt::constrrel, CreateConstraintEntry(), CreateTrigger(), CreateTrigStmt::deferrable, deleteDependencyRecordsForClass(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ereport, errcode(), errmsg(), ERROR, CreateTrigStmt::events, CreateTrigStmt::funcname, 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, CreateTrigStmt::initdeferred, InvalidOid, InvokeObjectPostAlterHookArg, IsBootstrapProcessingMode, CreateTrigStmt::isconstraint, IsNormalProcessingMode, IsSystemRelation(), makeNode, NIL, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, recordDependencyOn(), CreateTrigStmt::relation, RelationGetNamespace, RelationGetRelid, CreateTrigStmt::replace, CreateTrigStmt::row, RowExclusiveLock, SearchSysCacheCopy1, SystemFuncName(), HeapTupleData::t_self, table_close(), table_open(), CreateTrigStmt::timing, CreateTrigStmt::transitionRels, CreateTrigStmt::trigname, and CreateTrigStmt::whenClause.

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,
bits16  flags,
bits16  constr_flags,
bool  allow_system_table_mods,
bool  is_internal,
Oid constraintId 
)

Definition at line 724 of file index.c.

745 {
746  Oid heapRelationId = RelationGetRelid(heapRelation);
747  Relation pg_class;
748  Relation indexRelation;
749  TupleDesc indexTupDesc;
750  bool shared_relation;
751  bool mapped_relation;
752  bool is_exclusion;
753  Oid namespaceId;
754  int i;
755  char relpersistence;
756  bool isprimary = (flags & INDEX_CREATE_IS_PRIMARY) != 0;
757  bool invalid = (flags & INDEX_CREATE_INVALID) != 0;
758  bool concurrent = (flags & INDEX_CREATE_CONCURRENT) != 0;
759  bool partitioned = (flags & INDEX_CREATE_PARTITIONED) != 0;
760  char relkind;
761  TransactionId relfrozenxid;
762  MultiXactId relminmxid;
763  bool create_storage = !RelFileNumberIsValid(relFileNumber);
764 
765  /* constraint flags can only be set when a constraint is requested */
766  Assert((constr_flags == 0) ||
767  ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0));
768  /* partitioned indexes must never be "built" by themselves */
769  Assert(!partitioned || (flags & INDEX_CREATE_SKIP_BUILD));
770 
771  relkind = partitioned ? RELKIND_PARTITIONED_INDEX : RELKIND_INDEX;
772  is_exclusion = (indexInfo->ii_ExclusionOps != NULL);
773 
774  pg_class = table_open(RelationRelationId, RowExclusiveLock);
775 
776  /*
777  * The index will be in the same namespace as its parent table, and is
778  * shared across databases if and only if the parent is. Likewise, it
779  * will use the relfilenumber map if and only if the parent does; and it
780  * inherits the parent's relpersistence.
781  */
782  namespaceId = RelationGetNamespace(heapRelation);
783  shared_relation = heapRelation->rd_rel->relisshared;
784  mapped_relation = RelationIsMapped(heapRelation);
785  relpersistence = heapRelation->rd_rel->relpersistence;
786 
787  /*
788  * check parameters
789  */
790  if (indexInfo->ii_NumIndexAttrs < 1)
791  elog(ERROR, "must index at least one column");
792 
793  if (!allow_system_table_mods &&
794  IsSystemRelation(heapRelation) &&
796  ereport(ERROR,
797  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
798  errmsg("user-defined indexes on system catalog tables are not supported")));
799 
800  /*
801  * Btree text_pattern_ops uses text_eq as the equality operator, which is
802  * fine as long as the collation is deterministic; text_eq then reduces to
803  * bitwise equality and so it is semantically compatible with the other
804  * operators and functions in that opclass. But with a nondeterministic
805  * collation, text_eq could yield results that are incompatible with the
806  * actual behavior of the index (which is determined by the opclass's
807  * comparison function). We prevent such problems by refusing creation of
808  * an index with that opclass and a nondeterministic collation.
809  *
810  * The same applies to varchar_pattern_ops and bpchar_pattern_ops. If we
811  * find more cases, we might decide to create a real mechanism for marking
812  * opclasses as incompatible with nondeterminism; but for now, this small
813  * hack suffices.
814  *
815  * Another solution is to use a special operator, not text_eq, as the
816  * equality opclass member; but that is undesirable because it would
817  * prevent index usage in many queries that work fine today.
818  */
819  for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
820  {
821  Oid collation = collationIds[i];
822  Oid opclass = opclassIds[i];
823 
824  if (collation)
825  {
826  if ((opclass == TEXT_BTREE_PATTERN_OPS_OID ||
827  opclass == VARCHAR_BTREE_PATTERN_OPS_OID ||
828  opclass == BPCHAR_BTREE_PATTERN_OPS_OID) &&
829  !get_collation_isdeterministic(collation))
830  {
831  HeapTuple classtup;
832 
833  classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
834  if (!HeapTupleIsValid(classtup))
835  elog(ERROR, "cache lookup failed for operator class %u", opclass);
836  ereport(ERROR,
837  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
838  errmsg("nondeterministic collations are not supported for operator class \"%s\"",
839  NameStr(((Form_pg_opclass) GETSTRUCT(classtup))->opcname))));
840  ReleaseSysCache(classtup);
841  }
842  }
843  }
844 
845  /*
846  * Concurrent index build on a system catalog is unsafe because we tend to
847  * release locks before committing in catalogs.
848  */
849  if (concurrent &&
850  IsCatalogRelation(heapRelation))
851  ereport(ERROR,
852  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
853  errmsg("concurrent index creation on system catalog tables is not supported")));
854 
855  /*
856  * This case is currently not supported. There's no way to ask for it in
857  * the grammar with CREATE INDEX, but it can happen with REINDEX.
858  */
859  if (concurrent && is_exclusion)
860  ereport(ERROR,
861  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
862  errmsg("concurrent index creation for exclusion constraints is not supported")));
863 
864  /*
865  * We cannot allow indexing a shared relation after initdb (because
866  * there's no way to make the entry in other databases' pg_class).
867  */
868  if (shared_relation && !IsBootstrapProcessingMode())
869  ereport(ERROR,
870  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
871  errmsg("shared indexes cannot be created after initdb")));
872 
873  /*
874  * Shared relations must be in pg_global, too (last-ditch check)
875  */
876  if (shared_relation && tableSpaceId != GLOBALTABLESPACE_OID)
877  elog(ERROR, "shared relations must be placed in pg_global tablespace");
878 
879  /*
880  * Check for duplicate name (both as to the index, and as to the
881  * associated constraint if any). Such cases would fail on the relevant
882  * catalogs' unique indexes anyway, but we prefer to give a friendlier
883  * error message.
884  */
885  if (get_relname_relid(indexRelationName, namespaceId))
886  {
887  if ((flags & INDEX_CREATE_IF_NOT_EXISTS) != 0)
888  {
889  ereport(NOTICE,
890  (errcode(ERRCODE_DUPLICATE_TABLE),
891  errmsg("relation \"%s\" already exists, skipping",
892  indexRelationName)));
893  table_close(pg_class, RowExclusiveLock);
894  return InvalidOid;
895  }
896 
897  ereport(ERROR,
898  (errcode(ERRCODE_DUPLICATE_TABLE),
899  errmsg("relation \"%s\" already exists",
900  indexRelationName)));
901  }
902 
903  if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0 &&
905  indexRelationName))
906  {
907  /*
908  * INDEX_CREATE_IF_NOT_EXISTS does not apply here, since the
909  * conflicting constraint is not an index.
910  */
911  ereport(ERROR,
913  errmsg("constraint \"%s\" for relation \"%s\" already exists",
914  indexRelationName, RelationGetRelationName(heapRelation))));
915  }
916 
917  /*
918  * construct tuple descriptor for index tuples
919  */
920  indexTupDesc = ConstructTupleDescriptor(heapRelation,
921  indexInfo,
922  indexColNames,
923  accessMethodId,
924  collationIds,
925  opclassIds);
926 
927  /*
928  * Allocate an OID for the index, unless we were told what to use.
929  *
930  * The OID will be the relfilenumber as well, so make sure it doesn't
931  * collide with either pg_class OIDs or existing physical files.
932  */
933  if (!OidIsValid(indexRelationId))
934  {
935  /* Use binary-upgrade override for pg_class.oid and relfilenumber */
936  if (IsBinaryUpgrade)
937  {
939  ereport(ERROR,
940  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
941  errmsg("pg_class index OID value not set when in binary upgrade mode")));
942 
943  indexRelationId = binary_upgrade_next_index_pg_class_oid;
945 
946  /* Override the index relfilenumber */
947  if ((relkind == RELKIND_INDEX) &&
949  ereport(ERROR,
950  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
951  errmsg("index relfilenumber value not set when in binary upgrade mode")));
954 
955  /*
956  * Note that we want create_storage = true for binary upgrade. The
957  * storage we create here will be replaced later, but we need to
958  * have something on disk in the meanwhile.
959  */
960  Assert(create_storage);
961  }
962  else
963  {
964  indexRelationId =
965  GetNewRelFileNumber(tableSpaceId, pg_class, relpersistence);
966  }
967  }
968 
969  /*
970  * create the index relation's relcache entry and, if necessary, the
971  * physical disk file. (If we fail further down, it's the smgr's
972  * responsibility to remove the disk file again, if any.)
973  */
974  indexRelation = heap_create(indexRelationName,
975  namespaceId,
976  tableSpaceId,
977  indexRelationId,
978  relFileNumber,
979  accessMethodId,
980  indexTupDesc,
981  relkind,
982  relpersistence,
983  shared_relation,
984  mapped_relation,
985  allow_system_table_mods,
986  &relfrozenxid,
987  &relminmxid,
988  create_storage);
989 
990  Assert(relfrozenxid == InvalidTransactionId);
991  Assert(relminmxid == InvalidMultiXactId);
992  Assert(indexRelationId == RelationGetRelid(indexRelation));
993 
994  /*
995  * Obtain exclusive lock on it. Although no other transactions can see it
996  * until we commit, this prevents deadlock-risk complaints from lock
997  * manager in cases such as CLUSTER.
998  */
999  LockRelation(indexRelation, AccessExclusiveLock);
1000 
1001  /*
1002  * Fill in fields of the index's pg_class entry that are not set correctly
1003  * by heap_create.
1004  *
1005  * XXX should have a cleaner way to create cataloged indexes
1006  */
1007  indexRelation->rd_rel->relowner = heapRelation->rd_rel->relowner;
1008  indexRelation->rd_rel->relam = accessMethodId;
1009  indexRelation->rd_rel->relispartition = OidIsValid(parentIndexRelid);
1010 
1011  /*
1012  * store index's pg_class entry
1013  */
1014  InsertPgClassTuple(pg_class, indexRelation,
1015  RelationGetRelid(indexRelation),
1016  (Datum) 0,
1017  reloptions);
1018 
1019  /* done with pg_class */
1020  table_close(pg_class, RowExclusiveLock);
1021 
1022  /*
1023  * now update the object id's of all the attribute tuple forms in the
1024  * index relation's tuple descriptor
1025  */
1026  InitializeAttributeOids(indexRelation,
1027  indexInfo->ii_NumIndexAttrs,
1028  indexRelationId);
1029 
1030  /*
1031  * append ATTRIBUTE tuples for the index
1032  */
1033  AppendAttributeTuples(indexRelation, opclassOptions, stattargets);
1034 
1035  /* ----------------
1036  * update pg_index
1037  * (append INDEX tuple)
1038  *
1039  * Note that this stows away a representation of "predicate".
1040  * (Or, could define a rule to maintain the predicate) --Nels, Feb '92
1041  * ----------------
1042  */
1043  UpdateIndexRelation(indexRelationId, heapRelationId, parentIndexRelid,
1044  indexInfo,
1045  collationIds, opclassIds, coloptions,
1046  isprimary, is_exclusion,
1047  (constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
1048  !concurrent && !invalid,
1049  !concurrent);
1050 
1051  /*
1052  * Register relcache invalidation on the indexes' heap relation, to
1053  * maintain consistency of its index list
1054  */
1055  CacheInvalidateRelcache(heapRelation);
1056 
1057  /* update pg_inherits and the parent's relhassubclass, if needed */
1058  if (OidIsValid(parentIndexRelid))
1059  {
1060  StoreSingleInheritance(indexRelationId, parentIndexRelid, 1);
1061  SetRelationHasSubclass(parentIndexRelid, true);
1062  }
1063 
1064  /*
1065  * Register constraint and dependencies for the index.
1066  *
1067  * If the index is from a CONSTRAINT clause, construct a pg_constraint
1068  * entry. The index will be linked to the constraint, which in turn is
1069  * linked to the table. If it's not a CONSTRAINT, we need to make a
1070  * dependency directly on the table.
1071  *
1072  * We don't need a dependency on the namespace, because there'll be an
1073  * indirect dependency via our parent table.
1074  *
1075  * During bootstrap we can't register any dependencies, and we don't try
1076  * to make a constraint either.
1077  */
1079  {
1080  ObjectAddress myself,
1081  referenced;
1082  ObjectAddresses *addrs;
1083 
1084  ObjectAddressSet(myself, RelationRelationId, indexRelationId);
1085 
1086  if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0)
1087  {
1088  char constraintType;
1089  ObjectAddress localaddr;
1090 
1091  if (isprimary)
1092  constraintType = CONSTRAINT_PRIMARY;
1093  else if (indexInfo->ii_Unique)
1094  constraintType = CONSTRAINT_UNIQUE;
1095  else if (is_exclusion)
1096  constraintType = CONSTRAINT_EXCLUSION;
1097  else
1098  {
1099  elog(ERROR, "constraint must be PRIMARY, UNIQUE or EXCLUDE");
1100  constraintType = 0; /* keep compiler quiet */
1101  }
1102 
1103  localaddr = index_constraint_create(heapRelation,
1104  indexRelationId,
1105  parentConstraintId,
1106  indexInfo,
1107  indexRelationName,
1108  constraintType,
1109  constr_flags,
1110  allow_system_table_mods,
1111  is_internal);
1112  if (constraintId)
1113  *constraintId = localaddr.objectId;
1114  }
1115  else
1116  {
1117  bool have_simple_col = false;
1118 
1119  addrs = new_object_addresses();
1120 
1121  /* Create auto dependencies on simply-referenced columns */
1122  for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
1123  {
1124  if (indexInfo->ii_IndexAttrNumbers[i] != 0)
1125  {
1126  ObjectAddressSubSet(referenced, RelationRelationId,
1127  heapRelationId,
1128  indexInfo->ii_IndexAttrNumbers[i]);
1129  add_exact_object_address(&referenced, addrs);
1130  have_simple_col = true;
1131  }
1132  }
1133 
1134  /*
1135  * If there are no simply-referenced columns, give the index an
1136  * auto dependency on the whole table. In most cases, this will
1137  * be redundant, but it might not be if the index expressions and
1138  * predicate contain no Vars or only whole-row Vars.
1139  */
1140  if (!have_simple_col)
1141  {
1142  ObjectAddressSet(referenced, RelationRelationId,
1143  heapRelationId);
1144  add_exact_object_address(&referenced, addrs);
1145  }
1146 
1148  free_object_addresses(addrs);
1149  }
1150 
1151  /*
1152  * If this is an index partition, create partition dependencies on
1153  * both the parent index and the table. (Note: these must be *in
1154  * addition to*, not instead of, all other dependencies. Otherwise
1155  * we'll be short some dependencies after DETACH PARTITION.)
1156  */
1157  if (OidIsValid(parentIndexRelid))
1158  {
1159  ObjectAddressSet(referenced, RelationRelationId, parentIndexRelid);
1160  recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_PRI);
1161 
1162  ObjectAddressSet(referenced, RelationRelationId, heapRelationId);
1163  recordDependencyOn(&myself, &referenced, DEPENDENCY_PARTITION_SEC);
1164  }
1165 
1166  /* placeholder for normal dependencies */
1167  addrs = new_object_addresses();
1168 
1169  /* Store dependency on collations */
1170 
1171  /* The default collation is pinned, so don't bother recording it */
1172  for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
1173  {
1174  if (OidIsValid(collationIds[i]) && collationIds[i] != DEFAULT_COLLATION_OID)
1175  {
1176  ObjectAddressSet(referenced, CollationRelationId, collationIds[i]);
1177  add_exact_object_address(&referenced, addrs);
1178  }
1179  }
1180 
1181  /* Store dependency on operator classes */
1182  for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
1183  {
1184  ObjectAddressSet(referenced, OperatorClassRelationId, opclassIds[i]);
1185  add_exact_object_address(&referenced, addrs);
1186  }
1187 
1189  free_object_addresses(addrs);
1190 
1191  /* Store dependencies on anything mentioned in index expressions */
1192  if (indexInfo->ii_Expressions)
1193  {
1195  (Node *) indexInfo->ii_Expressions,
1196  heapRelationId,
1198  DEPENDENCY_AUTO, false);
1199  }
1200 
1201  /* Store dependencies on anything mentioned in predicate */
1202  if (indexInfo->ii_Predicate)
1203  {
1205  (Node *) indexInfo->ii_Predicate,
1206  heapRelationId,
1208  DEPENDENCY_AUTO, false);
1209  }
1210  }
1211  else
1212  {
1213  /* Bootstrap mode - assert we weren't asked for constraint support */
1214  Assert((flags & INDEX_CREATE_ADD_CONSTRAINT) == 0);
1215  }
1216 
1217  /* Post creation hook for new index */
1218  InvokeObjectPostCreateHookArg(RelationRelationId,
1219  indexRelationId, 0, is_internal);
1220 
1221  /*
1222  * Advance the command counter so that we can see the newly-entered
1223  * catalog tuples for the index.
1224  */
1226 
1227  /*
1228  * In bootstrap mode, we have to fill in the index strategy structure with
1229  * information from the catalogs. If we aren't bootstrapping, then the
1230  * relcache entry has already been rebuilt thanks to sinval update during
1231  * CommandCounterIncrement.
1232  */
1234  RelationInitIndexAccessInfo(indexRelation);
1235  else
1236  Assert(indexRelation->rd_indexcxt != NULL);
1237 
1238  indexRelation->rd_index->indnkeyatts = indexInfo->ii_NumIndexKeyAttrs;
1239 
1240  /* Validate opclass-specific options */
1241  if (opclassOptions)
1242  for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
1243  (void) index_opclass_options(indexRelation, i + 1,
1244  opclassOptions[i],
1245  true);
1246 
1247  /*
1248  * If this is bootstrap (initdb) time, then we don't actually fill in the
1249  * index yet. We'll be creating more indexes and classes later, so we
1250  * delay filling them in until just before we're done with bootstrapping.
1251  * Similarly, if the caller specified to skip the build then filling the
1252  * index is delayed till later (ALTER TABLE can save work in some cases
1253  * with this). Otherwise, we call the AM routine that constructs the
1254  * index.
1255  */
1257  {
1258  index_register(heapRelationId, indexRelationId, indexInfo);
1259  }
1260  else if ((flags & INDEX_CREATE_SKIP_BUILD) != 0)
1261  {
1262  /*
1263  * Caller is responsible for filling the index later on. However,
1264  * we'd better make sure that the heap relation is correctly marked as
1265  * having an index.
1266  */
1267  index_update_stats(heapRelation,
1268  true,
1269  -1.0);
1270  /* Make the above update visible */
1272  }
1273  else
1274  {
1275  index_build(heapRelation, indexRelation, indexInfo, false, true);
1276  }
1277 
1278  /*
1279  * Close the index; but we keep the lock that we acquired above until end
1280  * of transaction. Closing the heap is caller's responsibility.
1281  */
1282  index_close(indexRelation, NoLock);
1283 
1284  return indexRelationId;
1285 }
void index_register(Oid heap, Oid ind, const IndexInfo *indexInfo)
Definition: bootstrap.c:901
TransactionId MultiXactId
Definition: c.h:662
uint32 TransactionId
Definition: c.h:652
RelFileNumber GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
Definition: catalog.c:500
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:103
void record_object_address_dependencies(const ObjectAddress *depender, ObjectAddresses *referenced, DependencyType behavior)
Definition: dependency.c:2740
void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, DependencyType self_behavior, bool reverse_self)
Definition: dependency.c:1594
ObjectAddresses * new_object_addresses(void)
Definition: dependency.c:2485
void add_exact_object_address(const ObjectAddress *object, ObjectAddresses *addrs)
Definition: dependency.c:2531
void free_object_addresses(ObjectAddresses *addrs)
Definition: dependency.c:2771
@ DEPENDENCY_NORMAL
Definition: dependency.h:33
#define NOTICE
Definition: elog.h:35
bool IsBinaryUpgrade
Definition: globals.c:118
void InsertPgClassTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Datum relacl, Datum reloptions)
Definition: heap.c:895
Relation heap_create(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, RelFileNumber relfilenumber, Oid accessmtd, TupleDesc tupDesc, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, bool allow_system_table_mods, TransactionId *relfrozenxid, MultiXactId *relminmxid, bool create_storage)
Definition: heap.c:289
RelFileNumber binary_upgrade_next_index_pg_class_relfilenumber
Definition: index.c:85
static void InitializeAttributeOids(Relation indexRelation, int numatts, Oid indexoid)
Definition: index.c:492
Oid binary_upgrade_next_index_pg_class_oid
Definition: index.c:84
static void AppendAttributeTuples(Relation indexRelation, const Datum *attopts, const NullableDatum *stattargets)
Definition: index.c:510
static TupleDesc ConstructTupleDescriptor(Relation heapRelation, const IndexInfo *indexInfo, const List *indexColNames, Oid accessMethodId, const Oid *collationIds, const Oid *opclassIds)
Definition: index.c:280
ObjectAddress index_constraint_create(Relation heapRelation, Oid indexRelationId, Oid parentConstraintId, const IndexInfo *indexInfo, const char *constraintName, char constraintType, bits16 constr_flags, bool allow_system_table_mods, bool is_internal)
Definition: index.c:1880
static void UpdateIndexRelation(Oid indexoid, Oid heapoid, Oid parentIndexId, const IndexInfo *indexInfo, const Oid *collationOids, const Oid *opclassOids, const int16 *coloptions, bool primary, bool isexclusion, bool immediate, bool isvalid, bool isready)
Definition: index.c:561
#define INDEX_CREATE_IS_PRIMARY
Definition: index.h:61
#define INDEX_CREATE_IF_NOT_EXISTS
Definition: index.h:65
#define INDEX_CREATE_PARTITIONED
Definition: index.h:66
#define INDEX_CREATE_INVALID
Definition: index.h:67
#define INDEX_CREATE_ADD_CONSTRAINT
Definition: index.h:62
bytea * index_opclass_options(Relation indrel, AttrNumber attnum, Datum attoptions, bool validate)
Definition: indexam.c:996
invalidindex index d is invalid
Definition: isn.c:134
void LockRelation(Relation relation, LOCKMODE lockmode)
Definition: lmgr.c:244
#define AccessExclusiveLock
Definition: lockdefs.h:43
bool get_collation_isdeterministic(Oid colloid)
Definition: lsyscache.c:1054
Oid get_relname_relid(const char *relname, Oid relnamespace)
Definition: lsyscache.c:1885
#define InvalidMultiXactId
Definition: multixact.h:24
#define InvokeObjectPostCreateHookArg(classId, objectId, subId, is_internal)
Definition: objectaccess.h:175
#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id)
Definition: objectaddress.h:33
bool ConstraintNameIsUsed(ConstraintCategory conCat, Oid objId, const char *conname)
@ CONSTRAINT_RELATION
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
#define RelationIsMapped(relation)
Definition: rel.h:554
void RelationInitIndexAccessInfo(Relation relation)
Definition: relcache.c:1426
#define RelFileNumberIsValid(relnumber)
Definition: relpath.h:27
#define ERRCODE_DUPLICATE_OBJECT
Definition: streamutil.c:32
Form_pg_index rd_index
Definition: rel.h:192
MemoryContext rd_indexcxt
Definition: rel.h:204
void SetRelationHasSubclass(Oid relationId, bool relhassubclass)
Definition: tablecmds.c:3496
#define InvalidTransactionId
Definition: transam.h:31

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, 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_opclass_options(), index_register(), index_update_stats(), InitializeAttributeOids(), InsertPgClassTuple(), invalid, InvalidMultiXactId, InvalidOid, InvalidRelFileNumber, InvalidTransactionId, InvokeObjectPostCreateHookArg, IsBinaryUpgrade, IsBootstrapProcessingMode, IsCatalogRelation(), IsNormalProcessingMode, IsSystemRelation(), LockRelation(), NameStr, new_object_addresses(), NoLock, NOTICE, ObjectAddressSet, ObjectAddressSubSet, ObjectAddress::objectId, ObjectIdGetDatum(), OidIsValid, 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(), StoreSingleInheritance(), table_close(), table_open(), and UpdateIndexRelation().

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

◆ index_drop()

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

Definition at line 2113 of file index.c.

2114 {
2115  Oid heapId;
2116  Relation userHeapRelation;
2117  Relation userIndexRelation;
2118  Relation indexRelation;
2119  HeapTuple tuple;
2120  bool hasexprs;
2121  LockRelId heaprelid,
2122  indexrelid;
2123  LOCKTAG heaplocktag;
2124  LOCKMODE lockmode;
2125 
2126  /*
2127  * A temporary relation uses a non-concurrent DROP. Other backends can't
2128  * access a temporary relation, so there's no harm in grabbing a stronger
2129  * lock (see comments in RemoveRelations), and a non-concurrent DROP is
2130  * more efficient.
2131  */
2132  Assert(get_rel_persistence(indexId) != RELPERSISTENCE_TEMP ||
2133  (!concurrent && !concurrent_lock_mode));
2134 
2135  /*
2136  * To drop an index safely, we must grab exclusive lock on its parent
2137  * table. Exclusive lock on the index alone is insufficient because
2138  * another backend might be about to execute a query on the parent table.
2139  * If it relies on a previously cached list of index OIDs, then it could
2140  * attempt to access the just-dropped index. We must therefore take a
2141  * table lock strong enough to prevent all queries on the table from
2142  * proceeding until we commit and send out a shared-cache-inval notice
2143  * that will make them update their index lists.
2144  *
2145  * In the concurrent case we avoid this requirement by disabling index use
2146  * in multiple steps and waiting out any transactions that might be using
2147  * the index, so we don't need exclusive lock on the parent table. Instead
2148  * we take ShareUpdateExclusiveLock, to ensure that two sessions aren't
2149  * doing CREATE/DROP INDEX CONCURRENTLY on the same index. (We will get
2150  * AccessExclusiveLock on the index below, once we're sure nobody else is
2151  * using it.)
2152  */
2153  heapId = IndexGetRelation(indexId, false);
2154  lockmode = (concurrent || concurrent_lock_mode) ? ShareUpdateExclusiveLock : AccessExclusiveLock;
2155  userHeapRelation = table_open(heapId, lockmode);
2156  userIndexRelation = index_open(indexId, lockmode);
2157 
2158  /*
2159  * We might still have open queries using it in our own session, which the
2160  * above locking won't prevent, so test explicitly.
2161  */
2162  CheckTableNotInUse(userIndexRelation, "DROP INDEX");
2163 
2164  /*
2165  * Drop Index Concurrently is more or less the reverse process of Create
2166  * Index Concurrently.
2167  *
2168  * First we unset indisvalid so queries starting afterwards don't use the
2169  * index to answer queries anymore. We have to keep indisready = true so
2170  * transactions that are still scanning the index can continue to see
2171  * valid index contents. For instance, if they are using READ COMMITTED
2172  * mode, and another transaction makes changes and commits, they need to
2173  * see those new tuples in the index.
2174  *
2175  * After all transactions that could possibly have used the index for
2176  * queries end, we can unset indisready and indislive, then wait till
2177  * nobody could be touching it anymore. (Note: we need indislive because
2178  * this state must be distinct from the initial state during CREATE INDEX
2179  * CONCURRENTLY, which has indislive true while indisready and indisvalid
2180  * are false. That's because in that state, transactions must examine the
2181  * index for HOT-safety decisions, while in this state we don't want them
2182  * to open it at all.)
2183  *
2184  * Since all predicate locks on the index are about to be made invalid, we
2185  * must promote them to predicate locks on the heap. In the
2186  * non-concurrent case we can just do that now. In the concurrent case
2187  * it's a bit trickier. The predicate locks must be moved when there are
2188  * no index scans in progress on the index and no more can subsequently
2189  * start, so that no new predicate locks can be made on the index. Also,
2190  * they must be moved before heap inserts stop maintaining the index, else
2191  * the conflict with the predicate lock on the index gap could be missed
2192  * before the lock on the heap relation is in place to detect a conflict
2193  * based on the heap tuple insert.
2194  */
2195  if (concurrent)
2196  {
2197  /*
2198  * We must commit our transaction in order to make the first pg_index
2199  * state update visible to other sessions. If the DROP machinery has
2200  * already performed any other actions (removal of other objects,
2201  * pg_depend entries, etc), the commit would make those actions
2202  * permanent, which would leave us with inconsistent catalog state if
2203  * we fail partway through the following sequence. Since DROP INDEX
2204  * CONCURRENTLY is restricted to dropping just one index that has no
2205  * dependencies, we should get here before anything's been done ---
2206  * but let's check that to be sure. We can verify that the current
2207  * transaction has not executed any transactional updates by checking
2208  * that no XID has been assigned.
2209  */
2211  ereport(ERROR,
2212  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2213  errmsg("DROP INDEX CONCURRENTLY must be first action in transaction")));
2214 
2215  /*
2216  * Mark index invalid by updating its pg_index entry
2217  */
2219 
2220  /*
2221  * Invalidate the relcache for the table, so that after this commit
2222  * all sessions will refresh any cached plans that might reference the
2223  * index.
2224  */
2225  CacheInvalidateRelcache(userHeapRelation);
2226 
2227  /* save lockrelid and locktag for below, then close but keep locks */
2228  heaprelid = userHeapRelation->rd_lockInfo.lockRelId;
2229  SET_LOCKTAG_RELATION(heaplocktag, heaprelid.dbId, heaprelid.relId);
2230  indexrelid = userIndexRelation->rd_lockInfo.lockRelId;
2231 
2232  table_close(userHeapRelation, NoLock);
2233  index_close(userIndexRelation, NoLock);
2234 
2235  /*
2236  * We must commit our current transaction so that the indisvalid
2237  * update becomes visible to other transactions; then start another.
2238  * Note that any previously-built data structures are lost in the
2239  * commit. The only data we keep past here are the relation IDs.
2240  *
2241  * Before committing, get a session-level lock on the table, to ensure
2242  * that neither it nor the index can be dropped before we finish. This
2243  * cannot block, even if someone else is waiting for access, because
2244  * we already have the same lock within our transaction.
2245  */
2248 
2252 
2253  /*
2254  * Now we must wait until no running transaction could be using the
2255  * index for a query. Use AccessExclusiveLock here to check for
2256  * running transactions that hold locks of any kind on the table. Note
2257  * we do not need to worry about xacts that open the table for reading
2258  * after this point; they will see the index as invalid when they open
2259  * the relation.
2260  *
2261  * Note: the reason we use actual lock acquisition here, rather than
2262  * just checking the ProcArray and sleeping, is that deadlock is
2263  * possible if one of the transactions in question is blocked trying
2264  * to acquire an exclusive lock on our table. The lock code will
2265  * detect deadlock and error out properly.
2266  *
2267  * Note: we report progress through WaitForLockers() unconditionally
2268  * here, even though it will only be used when we're called by REINDEX
2269  * CONCURRENTLY and not when called by DROP INDEX CONCURRENTLY.
2270  */
2271  WaitForLockers(heaplocktag, AccessExclusiveLock, true);
2272 
2273  /* Finish invalidation of index and mark it as dead */
2274  index_concurrently_set_dead(heapId, indexId);
2275 
2276  /*
2277  * Again, commit the transaction to make the pg_index update visible
2278  * to other sessions.
2279  */
2282 
2283  /*
2284  * Wait till every transaction that saw the old index state has
2285  * finished. See above about progress reporting.
2286  */
2287  WaitForLockers(heaplocktag, AccessExclusiveLock, true);
2288 
2289  /*
2290  * Re-open relations to allow us to complete our actions.
2291  *
2292  * At this point, nothing should be accessing the index, but lets
2293  * leave nothing to chance and grab AccessExclusiveLock on the index
2294  * before the physical deletion.
2295  */
2296  userHeapRelation = table_open(heapId, ShareUpdateExclusiveLock);
2297  userIndexRelation = index_open(indexId, AccessExclusiveLock);
2298  }
2299  else
2300  {
2301  /* Not concurrent, so just transfer predicate locks and we're good */
2302  TransferPredicateLocksToHeapRelation(userIndexRelation);
2303  }
2304 
2305  /*
2306  * Schedule physical removal of the files (if any)
2307  */
2308  if (RELKIND_HAS_STORAGE(userIndexRelation->rd_rel->relkind))
2309  RelationDropStorage(userIndexRelation);
2310 
2311  /* ensure that stats are dropped if transaction commits */
2312  pgstat_drop_relation(userIndexRelation);
2313 
2314  /*
2315  * Close and flush the index's relcache entry, to ensure relcache doesn't
2316  * try to rebuild it while we're deleting catalog entries. We keep the
2317  * lock though.
2318  */
2319  index_close(userIndexRelation, NoLock);
2320 
2321  RelationForgetRelation(indexId);
2322 
2323  /*
2324  * fix INDEX relation, and check for expressional index
2325  */
2326  indexRelation = table_open(IndexRelationId, RowExclusiveLock);
2327 
2328  tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
2329  if (!HeapTupleIsValid(tuple))
2330  elog(ERROR, "cache lookup failed for index %u", indexId);
2331 
2332  hasexprs = !heap_attisnull(tuple, Anum_pg_index_indexprs,
2333  RelationGetDescr(indexRelation));
2334 
2335  CatalogTupleDelete(indexRelation, &tuple->t_self);
2336 
2337  ReleaseSysCache(tuple);
2338  table_close(indexRelation, RowExclusiveLock);
2339 
2340  /*
2341  * if it has any expression columns, we might have stored statistics about
2342  * them.
2343  */
2344  if (hasexprs)
2345  RemoveStatistics(indexId, 0);
2346 
2347  /*
2348  * fix ATTRIBUTE relation
2349  */
2350  DeleteAttributeTuples(indexId);
2351 
2352  /*
2353  * fix RELATION relation
2354  */
2355  DeleteRelationTuple(indexId);
2356 
2357  /*
2358  * fix INHERITS relation
2359  */
2360  DeleteInheritsTuple(indexId, InvalidOid, false, NULL);
2361 
2362  /*
2363  * We are presently too lazy to attempt to compute the new correct value
2364  * of relhasindex (the next VACUUM will fix it if necessary). So there is
2365  * no need to update the pg_class tuple for the owning relation. But we
2366  * must send out a shared-cache-inval notice on the owning relation to
2367  * ensure other backends update their relcache lists of indexes. (In the
2368  * concurrent case, this is redundant but harmless.)
2369  */
2370  CacheInvalidateRelcache(userHeapRelation);
2371 
2372  /*
2373  * Close owning rel, but keep lock
2374  */
2375  table_close(userHeapRelation, NoLock);
2376 
2377  /*
2378  * Release the session locks before we go.
2379  */
2380  if (concurrent)
2381  {
2384  }
2385 }
void DeleteRelationTuple(Oid relid)
Definition: heap.c:1549
void DeleteAttributeTuples(Oid relid)
Definition: heap.c:1578
void RemoveStatistics(Oid relid, AttrNumber attnum)
Definition: heap.c:2915
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition: heaptuple.c:455
Oid IndexGetRelation(Oid indexId, bool missing_ok)
Definition: index.c:3523
void index_concurrently_set_dead(Oid heapId, Oid indexId)
Definition: index.c:1819
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
Definition: indexing.c:365
void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:397
void WaitForLockers(LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress)
Definition: lmgr.c:985
void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)
Definition: lmgr.c:410
#define SET_LOCKTAG_RELATION(locktag, dboid, reloid)
Definition: lock.h:181
int LOCKMODE
Definition: lockdefs.h:26
char get_rel_persistence(Oid relid)
Definition: lsyscache.c:2078
void pgstat_drop_relation(Relation rel)
void RelationForgetRelation(Oid rid)
Definition: relcache.c:2913
void PopActiveSnapshot(void)
Definition: snapmgr.c:743
void RelationDropStorage(Relation rel)
Definition: storage.c:206
Definition: lock.h:165
LockRelId lockRelId
Definition: rel.h:46
Definition: rel.h:39
Oid relId
Definition: rel.h:40
Oid dbId
Definition: rel.h:41
LockInfoData rd_lockInfo
Definition: rel.h:114
void CheckTableNotInUse(Relation rel, const char *stmt)
Definition: tablecmds.c:4251
TransactionId GetTopTransactionIdIfAny(void)
Definition: xact.c:438
void StartTransactionCommand(void)
Definition: xact.c:2995
void CommitTransactionCommand(void)
Definition: xact.c:3093

References AccessExclusiveLock, Assert, CacheInvalidateRelcache(), CatalogTupleDelete(), CheckTableNotInUse(), CommitTransactionCommand(), LockRelId::dbId, DeleteAttributeTuples(), DeleteInheritsTuple(), DeleteRelationTuple(), elog, ereport, errcode(), errmsg(), ERROR, get_rel_persistence(), GetTopTransactionIdIfAny(), heap_attisnull(), HeapTupleIsValid, index_close(), index_concurrently_set_dead(), INDEX_DROP_CLEAR_VALID, index_open(), index_set_state_flags(), IndexGetRelation(), InvalidOid, InvalidTransactionId, LockRelationIdForSession(), LockInfoData::lockRelId, NoLock, ObjectIdGetDatum(), pgstat_drop_relation(), PopActiveSnapshot(), RelationData::rd_lockInfo, RelationData::rd_rel, 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 
)

Definition at line 3443 of file index.c.

3444 {
3445  Relation pg_index;
3446  HeapTuple indexTuple;
3447  Form_pg_index indexForm;
3448 
3449  /* Open pg_index and fetch a writable copy of the index's tuple */
3450  pg_index = table_open(IndexRelationId, RowExclusiveLock);
3451 
3452  indexTuple = SearchSysCacheCopy1(INDEXRELID,
3453  ObjectIdGetDatum(indexId));
3454  if (!HeapTupleIsValid(indexTuple))
3455  elog(ERROR, "cache lookup failed for index %u", indexId);
3456  indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
3457 
3458  /* Perform the requested state change on the copy */
3459  switch (action)
3460  {
3462  /* Set indisready during a CREATE INDEX CONCURRENTLY sequence */
3463  Assert(indexForm->indislive);
3464  Assert(!indexForm->indisready);
3465  Assert(!indexForm->indisvalid);
3466  indexForm->indisready = true;
3467  break;
3469  /* Set indisvalid during a CREATE INDEX CONCURRENTLY sequence */
3470  Assert(indexForm->indislive);
3471  Assert(indexForm->indisready);
3472  Assert(!indexForm->indisvalid);
3473  indexForm->indisvalid = true;
3474  break;
3476 
3477  /*
3478  * Clear indisvalid during a DROP INDEX CONCURRENTLY sequence
3479  *
3480  * If indisready == true we leave it set so the index still gets
3481  * maintained by active transactions. We only need to ensure that
3482  * indisvalid is false. (We don't assert that either is initially
3483  * true, though, since we want to be able to retry a DROP INDEX
3484  * CONCURRENTLY that failed partway through.)
3485  *
3486  * Note: the CLUSTER logic assumes that indisclustered cannot be
3487  * set on any invalid index, so clear that flag too. For
3488  * cleanliness, also clear indisreplident.
3489  */
3490  indexForm->indisvalid = false;
3491  indexForm->indisclustered = false;
3492  indexForm->indisreplident = false;
3493  break;
3494  case INDEX_DROP_SET_DEAD:
3495 
3496  /*
3497  * Clear indisready/indislive during DROP INDEX CONCURRENTLY
3498  *
3499  * We clear both indisready and indislive, because we not only
3500  * want to stop updates, we want to prevent sessions from touching
3501  * the index at all.
3502  */
3503  Assert(!indexForm->indisvalid);
3504  Assert(!indexForm->indisclustered);
3505  Assert(!indexForm->indisreplident);
3506  indexForm->indisready = false;
3507  indexForm->indislive = false;
3508  break;
3509  }
3510 
3511  /* ... and update it */
3512  CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
3513 
3514  table_close(pg_index, RowExclusiveLock);
3515 }

References generate_unaccent_rules::action, Assert, CatalogTupleUpdate(), elog, ERROR, GETSTRUCT, HeapTupleIsValid, INDEX_CREATE_SET_READY, INDEX_CREATE_SET_VALID, INDEX_DROP_CLEAR_VALID, INDEX_DROP_SET_DEAD, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, 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 
)

Definition at line 3523 of file index.c.

3524 {
3525  HeapTuple tuple;
3527  Oid result;
3528 
3529  tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexId));
3530  if (!HeapTupleIsValid(tuple))
3531  {
3532  if (missing_ok)
3533  return InvalidOid;
3534  elog(ERROR, "cache lookup failed for index %u", indexId);
3535  }
3536  index = (Form_pg_index) GETSTRUCT(tuple);
3537  Assert(index->indexrelid == indexId);
3538 
3539  result = index->indrelid;
3540  ReleaseSysCache(tuple);
3541  return result;
3542 }

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

Referenced by brin_desummarize_range(), brin_summarize_range(), bringetbitmap(), brinvacuumcleanup(), bt_index_check_internal(), CheckIndexCompatible(), DetachPartitionFinalize(), get_tables_to_cluster_partitioned(), index_drop(), RangeVarCallbackForAttachIndex(), RangeVarCallbackForDropRelation(), RangeVarCallbackForReindexIndex(), reindex_index(), and ReindexRelationConcurrently().

◆ IndexSetParentIndex()

void IndexSetParentIndex ( Relation  partitionIdx,
Oid  parentOid 
)

Definition at line 4276 of file indexcmds.c.

4277 {
4278  Relation pg_inherits;
4279  ScanKeyData key[2];
4280  SysScanDesc scan;
4281  Oid partRelid = RelationGetRelid(partitionIdx);
4282  HeapTuple tuple;
4283  bool fix_dependencies;
4284 
4285  /* Make sure this is an index */
4286  Assert(partitionIdx->rd_rel->relkind == RELKIND_INDEX ||
4287  partitionIdx->rd_rel->relkind == RELKIND_PARTITIONED_INDEX);
4288 
4289  /*
4290  * Scan pg_inherits for rows linking our index to some parent.
4291  */
4292  pg_inherits = relation_open(InheritsRelationId, RowExclusiveLock);
4293  ScanKeyInit(&key[0],
4294  Anum_pg_inherits_inhrelid,
4295  BTEqualStrategyNumber, F_OIDEQ,
4296  ObjectIdGetDatum(partRelid));
4297  ScanKeyInit(&key[1],
4298  Anum_pg_inherits_inhseqno,
4299  BTEqualStrategyNumber, F_INT4EQ,
4300  Int32GetDatum(1));
4301  scan = systable_beginscan(pg_inherits, InheritsRelidSeqnoIndexId, true,
4302  NULL, 2, key);
4303  tuple = systable_getnext(scan);
4304 
4305  if (!HeapTupleIsValid(tuple))
4306  {
4307  if (parentOid == InvalidOid)
4308  {
4309  /*
4310  * No pg_inherits row, and no parent wanted: nothing to do in this
4311  * case.
4312  */
4313  fix_dependencies = false;
4314  }
4315  else
4316  {
4317  StoreSingleInheritance(partRelid, parentOid, 1);
4318  fix_dependencies = true;
4319  }
4320  }
4321  else
4322  {
4323  Form_pg_inherits inhForm = (Form_pg_inherits) GETSTRUCT(tuple);
4324 
4325  if (parentOid == InvalidOid)
4326  {
4327  /*
4328  * There exists a pg_inherits row, which we want to clear; do so.
4329  */
4330  CatalogTupleDelete(pg_inherits, &tuple->t_self);
4331  fix_dependencies = true;
4332  }
4333  else
4334  {
4335  /*
4336  * A pg_inherits row exists. If it's the same we want, then we're
4337  * good; if it differs, that amounts to a corrupt catalog and
4338  * should not happen.
4339  */
4340  if (inhForm->inhparent != parentOid)
4341  {
4342  /* unexpected: we should not get called in this case */
4343  elog(ERROR, "bogus pg_inherit row: inhrelid %u inhparent %u",
4344  inhForm->inhrelid, inhForm->inhparent);
4345  }
4346 
4347  /* already in the right state */
4348  fix_dependencies = false;
4349  }
4350  }
4351 
4352  /* done with pg_inherits */
4353  systable_endscan(scan);
4354  relation_close(pg_inherits, RowExclusiveLock);
4355 
4356  /* set relhassubclass if an index partition has been added to the parent */
4357  if (OidIsValid(parentOid))
4358  SetRelationHasSubclass(parentOid, true);
4359 
4360  /* set relispartition correctly on the partition */
4361  update_relispartition(partRelid, OidIsValid(parentOid));
4362 
4363  if (fix_dependencies)
4364  {
4365  /*
4366  * Insert/delete pg_depend rows. If setting a parent, add PARTITION
4367  * dependencies on the parent index and the table; if removing a
4368  * parent, delete PARTITION dependencies.
4369  */
4370  if (OidIsValid(parentOid))
4371  {
4372  ObjectAddress partIdx;
4373  ObjectAddress parentIdx;
4374  ObjectAddress partitionTbl;
4375 
4376  ObjectAddressSet(partIdx, RelationRelationId, partRelid);
4377  ObjectAddressSet(parentIdx, RelationRelationId, parentOid);
4378  ObjectAddressSet(partitionTbl, RelationRelationId,
4379  partitionIdx->rd_index->indrelid);
4380  recordDependencyOn(&partIdx, &parentIdx,
4382  recordDependencyOn(&partIdx, &partitionTbl,
4384  }
4385  else
4386  {
4387  deleteDependencyRecordsForClass(RelationRelationId, partRelid,
4388  RelationRelationId,
4390  deleteDependencyRecordsForClass(RelationRelationId, partRelid,
4391  RelationRelationId,
4393  }
4394 
4395  /* make our updates visible */
4397  }
4398 }
static void update_relispartition(Oid relationId, bool newval)
Definition: indexcmds.c:4405
static void fix_dependencies(ArchiveHandle *AH)
FormData_pg_inherits * Form_pg_inherits
Definition: pg_inherits.h:45

References Assert, BTEqualStrategyNumber, CatalogTupleDelete(), CommandCounterIncrement(), deleteDependencyRecordsForClass(), DEPENDENCY_PARTITION_PRI, DEPENDENCY_PARTITION_SEC, elog, ERROR, fix_dependencies(), GETSTRUCT, HeapTupleIsValid, Int32GetDatum(), InvalidOid, sort-test::key, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, RelationData::rd_index, RelationData::rd_rel, recordDependencyOn(), relation_close(), relation_open(), RelationGetRelid, RowExclusiveLock, ScanKeyInit(), SetRelationHasSubclass(), 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 210 of file index.h.

211 {
212  BlockNumber block = (BlockNumber) (encoded >> 16);
213  OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
214 
215  ItemPointerSet(itemptr, block, offset);
216 }
uint32 BlockNumber
Definition: block.h:31
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
uint16 OffsetNumber
Definition: off.h:24

References ItemPointerSet().

Referenced by heapam_index_validate_scan().

◆ itemptr_encode()

static int64 itemptr_encode ( ItemPointer  itemptr)
inlinestatic

Definition at line 189 of file index.h.

190 {
191  BlockNumber block = ItemPointerGetBlockNumber(itemptr);
192  OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
193  int64 encoded;
194 
195  /*
196  * Use the 16 least significant bits for the offset. 32 adjacent bits are
197  * used for the block number. Since remaining bits are unused, there
198  * cannot be negative encoded values (We assume a two's complement
199  * representation).
200  */
201  encoded = ((uint64) block << 16) | (uint16) offset;
202 
203  return encoded;
204 }
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103

References 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 
)

Definition at line 3548 of file index.c.

3551 {
3552  Relation iRel,
3553  heapRelation;
3554  Oid heapId;
3555  Oid save_userid;
3556  int save_sec_context;
3557  int save_nestlevel;
3558  IndexInfo *indexInfo;
3559  volatile bool skipped_constraint = false;
3560  PGRUsage ru0;
3561  bool progress = ((params->options & REINDEXOPT_REPORT_PROGRESS) != 0);
3562  bool set_tablespace = false;
3563 
3564  pg_rusage_init(&ru0);
3565 
3566  /*
3567  * Open and lock the parent heap relation. ShareLock is sufficient since
3568  * we only need to be sure no schema or data changes are going on.
3569  */
3570  heapId = IndexGetRelation(indexId,
3571  (params->options & REINDEXOPT_MISSING_OK) != 0);
3572  /* if relation is missing, leave */
3573  if (!OidIsValid(heapId))
3574  return;
3575 
3576  if ((params->options & REINDEXOPT_MISSING_OK) != 0)
3577  heapRelation = try_table_open(heapId, ShareLock);
3578  else
3579  heapRelation = table_open(heapId, ShareLock);
3580 
3581  /* if relation is gone, leave */
3582  if (!heapRelation)
3583  return;
3584 
3585  /*
3586  * Switch to the table owner's userid, so that any index functions are run
3587  * as that user. Also lock down security-restricted operations and
3588  * arrange to make GUC variable changes local to this command.
3589  */
3590  GetUserIdAndSecContext(&save_userid, &save_sec_context);
3591  SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
3592  save_sec_context | SECURITY_RESTRICTED_OPERATION);
3593  save_nestlevel = NewGUCNestLevel();
3595 
3596  if (progress)
3597  {
3598  const int progress_cols[] = {
3601  };
3602  const int64 progress_vals[] = {
3604  indexId
3605  };
3606 
3608  heapId);
3609  pgstat_progress_update_multi_param(2, progress_cols, progress_vals);
3610  }
3611 
3612  /*
3613  * Open the target index relation and get an exclusive lock on it, to
3614  * ensure that no one else is touching this particular index.
3615  */
3616  if ((params->options & REINDEXOPT_MISSING_OK) != 0)
3617  iRel = try_index_open(indexId, AccessExclusiveLock);
3618  else
3619  iRel = index_open(indexId, AccessExclusiveLock);
3620 
3621  /* if index relation is gone, leave */
3622  if (!iRel)
3623  {
3624  /* Roll back any GUC changes */
3625  AtEOXact_GUC(false, save_nestlevel);
3626 
3627  /* Restore userid and security context */
3628  SetUserIdAndSecContext(save_userid, save_sec_context);
3629 
3630  /* Close parent heap relation, but keep locks */
3631  table_close(heapRelation, NoLock);
3632  return;
3633  }
3634 
3635  if (progress)
3637  iRel->rd_rel->relam);
3638 
3639  /*
3640  * If a statement is available, telling that this comes from a REINDEX
3641  * command, collect the index for event triggers.
3642  */
3643  if (stmt)
3644  {
3645  ObjectAddress address;
3646 
3647  ObjectAddressSet(address, RelationRelationId, indexId);
3650  (Node *) stmt);
3651  }
3652 
3653  /*
3654  * Partitioned indexes should never get processed here, as they have no
3655  * physical storage.
3656  */
3657  if (iRel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
3658  elog(ERROR, "cannot reindex partitioned index \"%s.%s\"",
3660  RelationGetRelationName(iRel));
3661 
3662  /*
3663  * Don't allow reindex on temp tables of other backends ... their local
3664  * buffer manager is not going to cope.
3665  */
3666  if (RELATION_IS_OTHER_TEMP(iRel))
3667  ereport(ERROR,
3668  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3669  errmsg("cannot reindex temporary tables of other sessions")));
3670 
3671  /*
3672  * Don't allow reindex of an invalid index on TOAST table. This is a
3673  * leftover from a failed REINDEX CONCURRENTLY, and if rebuilt it would
3674  * not be possible to drop it anymore.
3675  */
3677  !get_index_isvalid(indexId))
3678  ereport(ERROR,
3679  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3680  errmsg("cannot reindex invalid index on TOAST table")));
3681 
3682  /*
3683  * System relations cannot be moved even if allow_system_table_mods is
3684  * enabled to keep things consistent with the concurrent case where all
3685  * the indexes of a relation are processed in series, including indexes of
3686  * toast relations.
3687  *
3688  * Note that this check is not part of CheckRelationTableSpaceMove() as it
3689  * gets used for ALTER TABLE SET TABLESPACE that could cascade across
3690  * toast relations.
3691  */
3692  if (OidIsValid(params->tablespaceOid) &&
3693  IsSystemRelation(iRel))
3694  ereport(ERROR,
3695  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3696  errmsg("cannot move system relation \"%s\"",
3697  RelationGetRelationName(iRel))));
3698 
3699  /* Check if the tablespace of this index needs to be changed */
3700  if (OidIsValid(params->tablespaceOid) &&
3702  set_tablespace = true;
3703 
3704  /*
3705  * Also check for active uses of the index in the current transaction; we
3706  * don't want to reindex underneath an open indexscan.
3707  */
3708  CheckTableNotInUse(iRel, "REINDEX INDEX");
3709 
3710  /* Set new tablespace, if requested */
3711  if (set_tablespace)
3712  {
3713  /* Update its pg_class row */
3715 
3716  /*
3717  * Schedule unlinking of the old index storage at transaction commit.
3718  */
3719  RelationDropStorage(iRel);
3721 
3722  /* Make sure the reltablespace change is visible */
3724  }
3725 
3726  /*
3727  * All predicate locks on the index are about to be made invalid. Promote
3728  * them to relation locks on the heap.
3729  */
3731 
3732  /* Fetch info needed for index_build */
3733  indexInfo = BuildIndexInfo(iRel);
3734 
3735  /* If requested, skip checking uniqueness/exclusion constraints */
3736  if (skip_constraint_checks)
3737  {
3738  if (indexInfo->ii_Unique || indexInfo->ii_ExclusionOps != NULL)
3739  skipped_constraint = true;
3740  indexInfo->ii_Unique = false;
3741  indexInfo->ii_ExclusionOps = NULL;
3742  indexInfo->ii_ExclusionProcs = NULL;
3743  indexInfo->ii_ExclusionStrats = NULL;
3744  }
3745 
3746  /* Suppress use of the target index while rebuilding it */
3747  SetReindexProcessing(heapId, indexId);
3748 
3749  /* Create a new physical relation for the index */
3750  RelationSetNewRelfilenumber(iRel, persistence);
3751 
3752  /* Initialize the index and rebuild */
3753  /* Note: we do not need to re-establish pkey setting */
3754  index_build(heapRelation, iRel, indexInfo, true, true);
3755 
3756  /* Re-allow use of target index */
3758 
3759  /*
3760  * If the index is marked invalid/not-ready/dead (ie, it's from a failed
3761  * CREATE INDEX CONCURRENTLY, or a DROP INDEX CONCURRENTLY failed midway),
3762  * and we didn't skip a uniqueness check, we can now mark it valid. This
3763  * allows REINDEX to be used to clean up in such cases.
3764  *
3765  * We can also reset indcheckxmin, because we have now done a
3766  * non-concurrent index build, *except* in the case where index_build
3767  * found some still-broken HOT chains. If it did, and we don't have to
3768  * change any of the other flags, we just leave indcheckxmin alone (note
3769  * that index_build won't have changed it, because this is a reindex).
3770  * This is okay and desirable because not updating the tuple leaves the
3771  * index's usability horizon (recorded as the tuple's xmin value) the same
3772  * as it was.
3773  *
3774  * But, if the index was invalid/not-ready/dead and there were broken HOT
3775  * chains, we had better force indcheckxmin true, because the normal
3776  * argument that the HOT chains couldn't conflict with the index is
3777  * suspect for an invalid index. (A conflict is definitely possible if
3778  * the index was dead. It probably shouldn't happen otherwise, but let's
3779  * be conservative.) In this case advancing the usability horizon is
3780  * appropriate.
3781  *
3782  * Another reason for avoiding unnecessary updates here is that while
3783  * reindexing pg_index itself, we must not try to update tuples in it.
3784  * pg_index's indexes should always have these flags in their clean state,
3785  * so that won't happen.
3786  */
3787  if (!skipped_constraint)
3788  {
3789  Relation pg_index;
3790  HeapTuple indexTuple;
3791  Form_pg_index indexForm;
3792  bool index_bad;
3793 
3794  pg_index = table_open(IndexRelationId, RowExclusiveLock);
3795 
3796  indexTuple = SearchSysCacheCopy1(INDEXRELID,
3797  ObjectIdGetDatum(indexId));
3798  if (!HeapTupleIsValid(indexTuple))
3799  elog(ERROR, "cache lookup failed for index %u", indexId);
3800  indexForm = (Form_pg_index) GETSTRUCT(indexTuple);
3801 
3802  index_bad = (!indexForm->indisvalid ||
3803  !indexForm->indisready ||
3804  !indexForm->indislive);
3805  if (index_bad ||
3806  (indexForm->indcheckxmin && !indexInfo->ii_BrokenHotChain))
3807  {
3808  if (!indexInfo->ii_BrokenHotChain)
3809  indexForm->indcheckxmin = false;
3810  else if (index_bad)
3811  indexForm->indcheckxmin = true;
3812  indexForm->indisvalid = true;
3813  indexForm->indisready = true;
3814  indexForm->indislive = true;
3815  CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
3816 
3817  /*
3818  * Invalidate the relcache for the table, so that after we commit
3819  * all sessions will refresh the table's index list. This ensures
3820  * that if anyone misses seeing the pg_index row during this
3821  * update, they'll refresh their list before attempting any update
3822  * on the table.
3823  */
3824  CacheInvalidateRelcache(heapRelation);
3825  }
3826 
3827  table_close(pg_index, RowExclusiveLock);
3828  }
3829 
3830  /* Log what we did */
3831  if ((params->options & REINDEXOPT_VERBOSE) != 0)
3832  ereport(INFO,
3833  (errmsg("index \"%s\" was reindexed",
3834  get_rel_name(indexId)),
3835  errdetail_internal("%s",
3836  pg_rusage_show(&ru0))));
3837 
3838  /* Roll back any GUC changes executed by index functions */
3839  AtEOXact_GUC(false, save_nestlevel);
3840 
3841  /* Restore userid and security context */
3842  SetUserIdAndSecContext(save_userid, save_sec_context);
3843 
3844  /* Close rels, but keep locks */
3845  index_close(iRel, NoLock);
3846  table_close(heapRelation, NoLock);
3847 
3848  if (progress)
3850 }
void pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
void pgstat_progress_update_param(int index, int64 val)
void pgstat_progress_end_command(void)
@ PROGRESS_COMMAND_CREATE_INDEX
bool IsToastNamespace(Oid namespaceId)
Definition: catalog.c:200
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1230
#define INFO
Definition: elog.h:34
void EventTriggerCollectSimpleCommand(ObjectAddress address, ObjectAddress secondaryObject, Node *parsetree)
#define stmt
Definition: indent_codes.h:59
static void ResetReindexProcessing(void)
Definition: index.c:4102
static void SetReindexProcessing(Oid heapOid, Oid indexOid)
Definition: index.c:4083
#define REINDEXOPT_MISSING_OK
Definition: index.h:43
#define REINDEXOPT_REPORT_PROGRESS
Definition: index.h:42
#define REINDEXOPT_VERBOSE
Definition: index.h:41
Relation try_index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:152
#define ShareLock
Definition: lockdefs.h:40
bool get_index_isvalid(Oid index_oid)
Definition: lsyscache.c:3578
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3366
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1928
const ObjectAddress InvalidObjectAddress
const char * pg_rusage_show(const PGRUsage *ru0)
Definition: pg_rusage.c:40
void pg_rusage_init(PGRUsage *ru0)
Definition: pg_rusage.c:27
int progress
Definition: pgbench.c:261
#define PROGRESS_CREATEIDX_ACCESS_METHOD_OID
Definition: progress.h:83
#define PROGRESS_CREATEIDX_COMMAND_REINDEX
Definition: progress.h:112
#define PROGRESS_CREATEIDX_INDEX_OID
Definition: progress.h:82
#define PROGRESS_CREATEIDX_COMMAND
Definition: progress.h:81
#define RELATION_IS_OTHER_TEMP(relation)
Definition: rel.h:658
void RelationSetNewRelfilenumber(Relation relation, char persistence)
Definition: relcache.c:3766
void RelationAssumeNewRelfilelocator(Relation relation)
Definition: relcache.c:3965
Oid tablespaceOid
Definition: index.h:36
bits32 options
Definition: index.h:35
Relation try_table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:60
bool CheckRelationTableSpaceMove(Relation rel, Oid newTableSpaceId)
Definition: tablecmds.c:3537
void SetRelationTableSpace(Relation rel, Oid newTableSpaceId, RelFileNumber newRelFilenumber)
Definition: tablecmds.c:3594

References AccessExclusiveLock, AtEOXact_GUC(), BuildIndexInfo(), CacheInvalidateRelcache(), CatalogTupleUpdate(), CheckRelationTableSpaceMove(), CheckTableNotInUse(), CommandCounterIncrement(), elog, ereport, errcode(), errdetail_internal(), errmsg(), ERROR, EventTriggerCollectSimpleCommand(), 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, HeapTupleData::t_self, 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 
)

Definition at line 3888 of file index.c.

3890 {
3891  Relation rel;
3892  Oid toast_relid;
3893  List *indexIds;
3894  char persistence;
3895  bool result = false;
3896  ListCell *indexId;
3897  int i;
3898 
3899  /*
3900  * Open and lock the relation. ShareLock is sufficient since we only need
3901  * to prevent schema and data changes in it. The lock level used here
3902  * should match ReindexTable().
3903  */
3904  if ((params->options & REINDEXOPT_MISSING_OK) != 0)
3905  rel = try_table_open(relid, ShareLock);
3906  else
3907  rel = table_open(relid, ShareLock);
3908 
3909  /* if relation is gone, leave */
3910  if (!rel)
3911  return false;
3912 
3913  /*
3914  * Partitioned tables should never get processed here, as they have no
3915  * physical storage.
3916  */
3917  if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
3918  elog(ERROR, "cannot reindex partitioned table \"%s.%s\"",
3921 
3922  toast_relid = rel->rd_rel->reltoastrelid;
3923 
3924  /*
3925  * Get the list of index OIDs for this relation. (We trust the relcache
3926  * to get this with a sequential scan if ignoring system indexes.)
3927  */
3928  indexIds = RelationGetIndexList(rel);
3929 
3930  if (flags & REINDEX_REL_SUPPRESS_INDEX_USE)
3931  {
3932  /* Suppress use of all the indexes until they are rebuilt */
3933  SetReindexPending(indexIds);
3934 
3935  /*
3936  * Make the new heap contents visible --- now things might be
3937  * inconsistent!
3938  */
3940  }
3941 
3942  /*
3943  * Reindex the toast table, if any, before the main table.
3944  *
3945  * This helps in cases where a corruption in the toast table's index would
3946  * otherwise error and stop REINDEX TABLE command when it tries to fetch a
3947  * toasted datum. This way. the toast table's index is rebuilt and fixed
3948  * before it is used for reindexing the main table.
3949  *
3950  * It is critical to call reindex_relation() *after* the call to
3951  * RelationGetIndexList() returning the list of indexes on the relation,
3952  * because reindex_relation() will call CommandCounterIncrement() after
3953  * every reindex_index(). See REINDEX_REL_SUPPRESS_INDEX_USE for more
3954  * details.
3955  */
3956  if ((flags & REINDEX_REL_PROCESS_TOAST) && OidIsValid(toast_relid))
3957  {
3958  /*
3959  * Note that this should fail if the toast relation is missing, so
3960  * reset REINDEXOPT_MISSING_OK. Even if a new tablespace is set for
3961  * the parent relation, the indexes on its toast table are not moved.
3962  * This rule is enforced by setting tablespaceOid to InvalidOid.
3963  */
3964  ReindexParams newparams = *params;
3965 
3966  newparams.options &= ~(REINDEXOPT_MISSING_OK);
3967  newparams.tablespaceOid = InvalidOid;
3968  result |= reindex_relation(stmt, toast_relid, flags, &newparams);
3969  }
3970 
3971  /*
3972  * Compute persistence of indexes: same as that of owning rel, unless
3973  * caller specified otherwise.
3974  */
3976  persistence = RELPERSISTENCE_UNLOGGED;
3977  else if (flags & REINDEX_REL_FORCE_INDEXES_PERMANENT)
3978  persistence = RELPERSISTENCE_PERMANENT;
3979  else
3980  persistence = rel->rd_rel->relpersistence;
3981 
3982  /* Reindex all the indexes. */
3983  i = 1;
3984  foreach(indexId, indexIds)
3985  {
3986  Oid indexOid = lfirst_oid(indexId);
3987  Oid indexNamespaceId = get_rel_namespace(indexOid);
3988 
3989  /*
3990  * Skip any invalid indexes on a TOAST table. These can only be
3991  * duplicate leftovers from a failed REINDEX CONCURRENTLY, and if
3992  * rebuilt it would not be possible to drop them anymore.
3993  */
3994  if (IsToastNamespace(indexNamespaceId) &&
3995  !get_index_isvalid(indexOid))
3996  {
3997  ereport(WARNING,
3998  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3999  errmsg("cannot reindex invalid index \"%s.%s\" on TOAST table, skipping",
4000  get_namespace_name(indexNamespaceId),
4001  get_rel_name(indexOid))));
4002  continue;
4003  }
4004 
4005  reindex_index(stmt, indexOid, !(flags & REINDEX_REL_CHECK_CONSTRAINTS),
4006  persistence, params);
4007 
4009 
4010  /* Index should no longer be in the pending list */
4011  Assert(!ReindexIsProcessingIndex(indexOid));
4012 
4013  /* Set index rebuild count */
4015  i);
4016  i++;
4017  }
4018 
4019  /*
4020  * Close rel, but continue to hold the lock.
4021  */
4022  table_close(rel, NoLock);
4023 
4024  result |= (indexIds != NIL);
4025 
4026  return result;
4027 }
#define WARNING
Definition: elog.h:36
bool ReindexIsProcessingIndex(Oid indexOid)
Definition: index.c:4072
bool reindex_relation(const ReindexStmt *stmt, Oid relid, int flags, const ReindexParams *params)
Definition: index.c:3888
static void SetReindexPending(List *indexes)
Definition: index.c:4116
void reindex_index(const ReindexStmt *stmt, Oid indexId, bool skip_constraint_checks, char persistence, const ReindexParams *params)
Definition: index.c:3548
#define REINDEX_REL_PROCESS_TOAST
Definition: index.h:158
#define REINDEX_REL_FORCE_INDEXES_UNLOGGED
Definition: index.h:161
#define REINDEX_REL_SUPPRESS_INDEX_USE
Definition: index.h:159
#define REINDEX_REL_FORCE_INDEXES_PERMANENT
Definition: index.h:162
#define REINDEX_REL_CHECK_CONSTRAINTS
Definition: index.h:160
Oid get_rel_namespace(Oid relid)
Definition: lsyscache.c:1952
#define PROGRESS_CLUSTER_INDEX_REBUILD_COUNT
Definition: progress.h:64
List * RelationGetIndexList(Relation relation)
Definition: relcache.c:4800

References Assert, CommandCounterIncrement(), elog, ereport, errcode(), errmsg(), ERROR, 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_CLUSTER_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, ReindexIsProcessingIndex(), REINDEXOPT_MISSING_OK, RelationGetIndexList(), RelationGetNamespace, RelationGetRelationName, SetReindexPending(), ShareLock, stmt, table_close(), table_open(), ReindexParams::tablespaceOid, try_table_open(), and WARNING.

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

◆ ReindexIsProcessingHeap()

bool ReindexIsProcessingHeap ( Oid  heapOid)

Definition at line 4051 of file index.c.

4052 {
4053  return heapOid == currentlyReindexedHeap;
4054 }
static Oid currentlyReindexedHeap
Definition: index.c:4041

References currentlyReindexedHeap.

Referenced by index_update_stats().

◆ ReindexIsProcessingIndex()

bool ReindexIsProcessingIndex ( Oid  indexOid)

Definition at line 4072 of file index.c.

4073 {
4074  return indexOid == currentlyReindexedIndex ||
4076 }
static Oid currentlyReindexedIndex
Definition: index.c:4042
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:722

References currentlyReindexedIndex, list_member_oid(), and pendingReindexedIndexes.

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

◆ ResetReindexState()

void ResetReindexState ( int  nestLevel)

Definition at line 4145 of file index.c.

4146 {
4147  /*
4148  * Because reindexing is not re-entrant, we don't need to cope with nested
4149  * reindexing states. We just need to avoid messing up the outer-level
4150  * state in case a subtransaction fails within a REINDEX. So checking the
4151  * current nest level against that of the reindex operation is sufficient.
4152  */
4153  if (reindexingNestLevel >= nestLevel)
4154  {
4157 
4158  /*
4159  * We needn't try to release the contents of pendingReindexedIndexes;
4160  * that list should be in a transaction-lifespan context, so it will
4161  * go away automatically.
4162  */
4164 
4165  reindexingNestLevel = 0;
4166  }
4167 }
static int reindexingNestLevel
Definition: index.c:4044

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

Referenced by AbortSubTransaction(), and AbortTransaction().

◆ RestoreReindexState()

void RestoreReindexState ( const void *  reindexstate)

Definition at line 4203 of file index.c.

4204 {
4205  const SerializedReindexState *sistate = (const SerializedReindexState *) reindexstate;
4206  int c = 0;
4207  MemoryContext oldcontext;
4208 
4211 
4214  for (c = 0; c < sistate->numPendingReindexedIndexes; ++c)
4217  sistate->pendingReindexedIndexes[c]);
4218  MemoryContextSwitchTo(oldcontext);
4219 
4220  /* Note the worker has its own transaction nesting level */
4222 }
MemoryContext TopMemoryContext
Definition: mcxt.c:149
char * c
MemoryContextSwitchTo(old_ctx)
Oid currentlyReindexedHeap
Definition: index.c:94
Oid currentlyReindexedIndex
Definition: index.c:95
int numPendingReindexedIndexes
Definition: index.c:96
Oid pendingReindexedIndexes[FLEXIBLE_ARRAY_MEMBER]
Definition: index.c:97
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:926

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

Referenced by ParallelWorkerMain().

◆ SerializeReindexState()

◆ validate_index()

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

Definition at line 3290 of file index.c.

3291 {
3292  Relation heapRelation,
3293  indexRelation;
3294  IndexInfo *indexInfo;
3295  IndexVacuumInfo ivinfo;
3297  Oid save_userid;
3298  int save_sec_context;
3299  int save_nestlevel;
3300 
3301  {
3302  const int progress_index[] = {
3308  };
3309  const int64 progress_vals[] = {
3311  0, 0, 0, 0
3312  };
3313 
3314  pgstat_progress_update_multi_param(5, progress_index, progress_vals);
3315  }
3316 
3317  /* Open and lock the parent heap relation */
3318  heapRelation = table_open(heapId, ShareUpdateExclusiveLock);
3319 
3320  /*
3321  * Switch to the table owner's userid, so that any index functions are run
3322  * as that user. Also lock down security-restricted operations and
3323  * arrange to make GUC variable changes local to this command.
3324  */
3325  GetUserIdAndSecContext(&save_userid, &save_sec_context);
3326  SetUserIdAndSecContext(heapRelation->rd_rel->relowner,
3327  save_sec_context | SECURITY_RESTRICTED_OPERATION);
3328  save_nestlevel = NewGUCNestLevel();
3330 
3331  indexRelation = index_open(indexId, RowExclusiveLock);
3332 
3333  /*
3334  * Fetch info needed for index_insert. (You might think this should be
3335  * passed in from DefineIndex, but its copy is long gone due to having
3336  * been built in a previous transaction.)
3337  */
3338  indexInfo = BuildIndexInfo(indexRelation);
3339 
3340  /* mark build is concurrent just for consistency */
3341  indexInfo->ii_Concurrent = true;
3342 
3343  /*
3344  * Scan the index and gather up all the TIDs into a tuplesort object.
3345  */
3346  ivinfo.index = indexRelation;
3347  ivinfo.heaprel = heapRelation;
3348  ivinfo.analyze_only = false;
3349  ivinfo.report_progress = true;
3350  ivinfo.estimated_count = true;
3351  ivinfo.message_level = DEBUG2;
3352  ivinfo.num_heap_tuples = heapRelation->rd_rel->reltuples;
3353  ivinfo.strategy = NULL;
3354 
3355  /*
3356  * Encode TIDs as int8 values for the sort, rather than directly sorting
3357  * item pointers. This can be significantly faster, primarily because TID
3358  * is a pass-by-reference type on all platforms, whereas int8 is
3359  * pass-by-value on most platforms.
3360  */
3361  state.tuplesort = tuplesort_begin_datum(INT8OID, Int8LessOperator,
3362  InvalidOid, false,
3364  NULL, TUPLESORT_NONE);
3365  state.htups = state.itups = state.tups_inserted = 0;
3366 
3367  /* ambulkdelete updates progress metrics */
3368  (void) index_bulk_delete(&ivinfo, NULL,
3369  validate_index_callback, (void *) &state);
3370 
3371  /* Execute the sort */
3372  {
3373  const int progress_index[] = {
3377  };
3378  const int64 progress_vals[] = {
3380  0, 0
3381  };
3382 
3383  pgstat_progress_update_multi_param(3, progress_index, progress_vals);
3384  }
3385  tuplesort_performsort(state.tuplesort);
3386 
3387  /*
3388  * Now scan the heap and "merge" it with the index
3389  */
3392  table_index_validate_scan(heapRelation,
3393  indexRelation,
3394  indexInfo,
3395  snapshot,
3396  &state);
3397 
3398  /* Done with tuplesort object */
3399  tuplesort_end(state.tuplesort);
3400 
3401  /* Make sure to release resources cached in indexInfo (if needed). */
3402  index_insert_cleanup(indexRelation, indexInfo);
3403 
3404  elog(DEBUG2,
3405  "validate_index found %.0f heap tuples, %.0f index tuples; inserted %.0f missing tuples",
3406  state.htups, state.itups, state.tups_inserted);
3407 
3408  /* Roll back any GUC changes executed by index functions */
3409  AtEOXact_GUC(false, save_nestlevel);
3410 
3411  /* Restore userid and security context */
3412  SetUserIdAndSecContext(save_userid, save_sec_context);
3413 
3414  /* Close rels, but keep locks */
3415  index_close(indexRelation, NoLock);
3416  table_close(heapRelation, NoLock);
3417 }
#define DEBUG2
Definition: elog.h:29
int maintenance_work_mem
Definition: globals.c:130
static bool validate_index_callback(ItemPointer itemptr, void *opaque)
Definition: index.c:3423
void index_insert_cleanup(Relation indexRelation, IndexInfo *indexInfo)
Definition: indexam.c:241
IndexBulkDeleteResult * index_bulk_delete(IndexVacuumInfo *info, IndexBulkDeleteResult *istat, IndexBulkDeleteCallback callback, void *callback_state)
Definition: indexam.c:748
#define PROGRESS_CREATEIDX_PHASE_VALIDATE_TABLESCAN
Definition: progress.h:98
#define PROGRESS_CREATEIDX_PHASE_VALIDATE_SORT
Definition: progress.h:97
#define PROGRESS_CREATEIDX_PHASE_VALIDATE_IDXSCAN
Definition: progress.h:96
Relation index
Definition: genam.h:46
double num_heap_tuples
Definition: genam.h:52
bool analyze_only
Definition: genam.h:48
BufferAccessStrategy strategy
Definition: genam.h:53
Relation heaprel
Definition: genam.h:47
bool report_progress
Definition: genam.h:49
int message_level
Definition: genam.h:51
bool estimated_count
Definition: genam.h:50
Definition: regguts.h:323
static void table_index_validate_scan(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, Snapshot snapshot, struct ValidateIndexState *state)
Definition: tableam.h:1849
void tuplesort_performsort(Tuplesortstate *state)
Definition: tuplesort.c:1385
void tuplesort_end(Tuplesortstate *state)
Definition: tuplesort.c:971
#define TUPLESORT_NONE
Definition: tuplesort.h:93
Tuplesortstate * tuplesort_begin_datum(Oid datumType, Oid sortOperator, Oid sortCollation, bool nullsFirstFlag, int workMem, SortCoordinate coordinate, int sortopt)

References IndexVacuumInfo::analyze_only, AtEOXact_GUC(), BuildIndexInfo(), DEBUG2, elog, IndexVacuumInfo::estimated_count, GetUserIdAndSecContext(), IndexVacuumInfo::heaprel, IndexInfo::ii_Concurrent, IndexVacuumInfo::index, index_bulk_delete(), index_close(), index_insert_cleanup(), index_open(), InvalidOid, maintenance_work_mem, IndexVacuumInfo::message_level, NewGUCNestLevel(), NoLock, IndexVacuumInfo::num_heap_tuples, 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, IndexVacuumInfo::report_progress, RestrictSearchPath(), RowExclusiveLock, SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), ShareUpdateExclusiveLock, IndexVacuumInfo::strategy, 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().