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