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