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