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