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