| blob | 1c3a9e06d37b9bfce737c3259c95d6dec14dc25a |
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 */
24 #include <unistd.h>
83 /* Potentially set by pg_upgrade_support functions */
85 RelFileNumber binary_upgrade_next_index_pg_class_relfilenumber =
86 InvalidRelFileNumber;
88 /*
89 * Pointer-free representation of variables used when reindexing system
90 * catalogs; we use this to propagate those values to parallel workers.
91 */
93 {
94 Oid currentlyReindexedHeap;
95 Oid currentlyReindexedIndex;
100 /* non-export function prototypes */
105 Oid accessMethodId,
110 static void AppendAttributeTuples(Relation indexRelation, const Datum *attopts, const NullableDatum *stattargets);
112 Oid parentIndexId,
126 Relation indexRelation,
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
148 {
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 */
161 {
163 HeapTuple indexTuple;
172 }
177 }
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
205 {
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 */
216 {
221 }
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 */
230 {
234 }
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 */
242 {
244 HeapTuple atttuple;
245 Form_pg_attribute attform;
252 /* System attributes are never null, so no need to check */
271 }
272 }
274 /*
275 * ConstructTupleDescriptor
276 *
277 * Build an index tuple descriptor for a new index
278 */
279 static TupleDesc
283 Oid accessMethodId,
286 {
292 TupleDesc heapTupDesc;
293 TupleDesc indexTupDesc;
297 /* We need access to the index AM's API struct */
300 /* ... and to the table's tuple descriptor */
304 /*
305 * allocate the new tuple descriptor
306 */
309 /*
310 * Fill in the pg_attribute row.
311 */
313 {
316 HeapTuple tuple;
317 Form_pg_type typeTup;
318 Form_pg_opclass opclassTup;
319 Oid keyType;
327 /*
328 * Set the attribute name as specified by caller.
329 */
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 */
341 {
342 /* Simple index column */
360 }
361 else
362 {
363 /* Expressional index */
371 /*
372 * Lookup the expression type in pg_type for the type length etc.
373 */
380 /*
381 * Assign some of the attributes values. Leave the rest.
382 */
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 */
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 */
413 }
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 */
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 */
430 {
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 */
448 {
453 }
456 }
458 /*
459 * If a key type different from the heap value is specified, update
460 * the type-related fields in the index tupdesc.
461 */
463 {
475 /* As above, use the default compression method in this case */
479 }
480 }
485 }
487 /* ----------------------------------------------------------------
488 * InitializeAttributeOids
489 * ----------------------------------------------------------------
490 */
491 static void
494 Oid indexoid)
495 {
496 TupleDesc tupleDescriptor;
503 }
505 /* ----------------------------------------------------------------
506 * AppendAttributeTuples
507 * ----------------------------------------------------------------
508 */
509 static void
510 AppendAttributeTuples(Relation indexRelation, const Datum *attopts, const NullableDatum *stattargets)
511 {
512 Relation pg_attribute;
513 CatalogIndexState indstate;
514 TupleDesc indexTupDesc;
518 {
522 {
525 else
530 else
532 }
533 }
535 /*
536 * open the attribute relation and its indexes
537 */
542 /*
543 * insert data from new index's tupdesc into pg_attribute
544 */
552 }
554 /* ----------------------------------------------------------------
555 * UpdateIndexRelation
556 *
557 * Construct and insert a new entry in the pg_index catalog
558 * ----------------------------------------------------------------
559 */
560 static void
562 Oid heapoid,
563 Oid parentIndexId,
573 {
578 Datum exprsDatum;
579 Datum predDatum;
582 Relation pg_index;
583 HeapTuple tuple;
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 */
597 /*
598 * Convert the index expressions (if any) to a text datum
599 */
601 {
607 }
608 else
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 */
616 {
622 }
623 else
627 /*
628 * open the system catalog index relation
629 */
632 /*
633 * Build a pg_index tuple
634 */
663 /*
664 * insert the tuple into the pg_index catalog
665 */
668 /*
669 * close the relation and free the tuple
670 */
673 }
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
726 Oid indexRelationId,
727 Oid parentIndexRelid,
728 Oid parentConstraintId,
729 RelFileNumber relFileNumber,
732 Oid accessMethodId,
733 Oid tableSpaceId,
739 Datum reloptions,
740 bits16 flags,
741 bits16 constr_flags,
745 {
747 Relation pg_class;
748 Relation indexRelation;
749 TupleDesc indexTupDesc;
753 Oid namespaceId;
761 TransactionId relfrozenxid;
762 MultiXactId relminmxid;
765 /* constraint flags can only be set when a constraint is requested */
768 /* partitioned indexes must never be "built" by themselves */
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 */
787 /*
788 * check parameters
789 */
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 */
820 {
825 {
830 {
831 HeapTuple classtup;
841 }
842 }
843 }
845 /*
846 * Concurrent index build on a system catalog is unsafe because we tend to
847 * release locks before committing in catalogs.
848 */
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 */
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 */
873 /*
874 * Shared relations must be in pg_global, too (last-ditch check)
875 */
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 */
886 {
888 {
892 indexRelationName)));
895 }
900 indexRelationName)));
901 }
905 indexRelationName))
906 {
907 /*
908 * INDEX_CREATE_IF_NOT_EXISTS does not apply here, since the
909 * conflicting constraint is not an index.
910 */
915 }
917 /*
918 * construct tuple descriptor for index tuples
919 */
921 indexInfo,
922 indexColNames,
923 accessMethodId,
924 collationIds,
925 opclassIds);
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 */
934 {
935 /* Use binary-upgrade override for pg_class.oid and relfilenumber */
937 {
946 /* Override the index relfilenumber */
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 */
961 }
962 else
963 {
964 indexRelationId =
966 }
967 }
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 */
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,
988 create_storage);
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 */
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 */
1011 /*
1012 * store index's pg_class entry
1013 */
1017 reloptions);
1019 /* done with pg_class */
1022 /*
1023 * now update the object id's of all the attribute tuple forms in the
1024 * index relation's tuple descriptor
1025 */
1028 indexRelationId);
1030 /*
1031 * append ATTRIBUTE tuples for the index
1032 */
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 */
1044 indexInfo,
1051 /*
1052 * Register relcache invalidation on the indexes' heap relation, to
1053 * maintain consistency of its index list
1054 */
1057 /* update pg_inherits and the parent's relhassubclass, if needed */
1059 {
1063 }
1065 /*
1066 * Register constraint and dependencies for the index.
1067 *
1068 * If the index is from a CONSTRAINT clause, construct a pg_constraint
1069 * entry. The index will be linked to the constraint, which in turn is
1070 * linked to the table. If it's not a CONSTRAINT, we need to make a
1071 * dependency directly on the table.
1072 *
1073 * We don't need a dependency on the namespace, because there'll be an
1074 * indirect dependency via our parent table.
1075 *
1076 * During bootstrap we can't register any dependencies, and we don't try
1077 * to make a constraint either.
1078 */
1080 {
1081 ObjectAddress myself,
1082 referenced;
1088 {
1090 ObjectAddress localaddr;
1098 else
1099 {
1102 }
1105 indexRelationId,
1106 parentConstraintId,
1107 indexInfo,
1108 indexRelationName,
1109 constraintType,
1110 constr_flags,
1111 allow_system_table_mods,
1112 is_internal);
1115 }
1116 else
1117 {
1122 /* Create auto dependencies on simply-referenced columns */
1124 {
1126 {
1128 heapRelationId,
1132 }
1133 }
1135 /*
1136 * If there are no simply-referenced columns, give the index an
1137 * auto dependency on the whole table. In most cases, this will
1138 * be redundant, but it might not be if the index expressions and
1139 * predicate contain no Vars or only whole-row Vars.
1140 */
1142 {
1144 heapRelationId);
1146 }
1150 }
1152 /*
1153 * If this is an index partition, create partition dependencies on
1154 * both the parent index and the table. (Note: these must be *in
1155 * addition to*, not instead of, all other dependencies. Otherwise
1156 * we'll be short some dependencies after DETACH PARTITION.)
1157 */
1159 {
1165 }
1167 /* placeholder for normal dependencies */
1170 /* Store dependency on collations */
1172 /* The default collation is pinned, so don't bother recording it */
1174 {
1176 {
1179 }
1180 }
1182 /* Store dependency on operator classes */
1184 {
1187 }
1192 /* Store dependencies on anything mentioned in index expressions */
1194 {
1197 heapRelationId,
1198 DEPENDENCY_NORMAL,
1200 }
1202 /* Store dependencies on anything mentioned in predicate */
1204 {
1207 heapRelationId,
1208 DEPENDENCY_NORMAL,
1210 }
1211 }
1212 else
1213 {
1214 /* Bootstrap mode - assert we weren't asked for constraint support */
1216 }
1218 /* Post creation hook for new index */
1222 /*
1223 * Advance the command counter so that we can see the newly-entered
1224 * catalog tuples for the index.
1225 */
1228 /*
1229 * In bootstrap mode, we have to fill in the index strategy structure with
1230 * information from the catalogs. If we aren't bootstrapping, then the
1231 * relcache entry has already been rebuilt thanks to sinval update during
1232 * CommandCounterIncrement.
1233 */
1236 else
1241 /* Validate opclass-specific options */
1248 /*
1249 * If this is bootstrap (initdb) time, then we don't actually fill in the
1250 * index yet. We'll be creating more indexes and classes later, so we
1251 * delay filling them in until just before we're done with bootstrapping.
1252 * Similarly, if the caller specified to skip the build then filling the
1253 * index is delayed till later (ALTER TABLE can save work in some cases
1254 * with this). Otherwise, we call the AM routine that constructs the
1255 * index.
1256 */
1258 {
1260 }
1262 {
1263 /*
1264 * Caller is responsible for filling the index later on. However,
1265 * we'd better make sure that the heap relation is correctly marked as
1266 * having an index.
1267 */
1271 /* Make the above update visible */
1273 }
1274 else
1275 {
1277 }
1279 /*
1280 * Close the index; but we keep the lock that we acquired above until end
1281 * of transaction. Closing the heap is caller's responsibility.
1282 */
1286 }
1288 /*
1289 * index_concurrently_create_copy
1290 *
1291 * Create concurrently an index based on the definition of the one provided by
1292 * caller. The index is inserted into catalogs and needs to be built later
1293 * on. This is called during concurrent reindex processing.
1294 *
1295 * "tablespaceOid" is the tablespace to use for this index.
1296 */
1297 Oid
1300 {
1301 Relation indexRelation;
1305 HeapTuple indexTuple,
1306 classTuple;
1307 Datum indclassDatum,
1308 colOptionDatum,
1309 reloptionsDatum;
1321 /* The new index needs some information from the old index */
1324 /*
1325 * Concurrent build of an index with exclusion constraints is not
1326 * supported.
1327 */
1333 /* Get the array of class and column options IDs from index info */
1338 Anum_pg_index_indclass);
1342 Anum_pg_index_indoption);
1345 /* Fetch reloptions of index if any */
1352 /*
1353 * Fetch the list of expressions and predicates directly from the
1354 * catalogs. This cannot rely on the information from IndexInfo of the
1355 * old index as these have been flattened for the planner.
1356 */
1358 {
1359 Datum exprDatum;
1363 Anum_pg_index_indexprs);
1367 }
1369 {
1370 Datum predDatum;
1374 Anum_pg_index_indpred);
1378 /* Also convert to implicit-AND format */
1381 }
1383 /*
1384 * Build the index information for the new index. Note that rebuild of
1385 * indexes with exclusion constraints is not supported, hence there is no
1386 * need to fill all the ii_Exclusion* fields.
1387 */
1391 indexExprs,
1392 indexPreds,
1400 /*
1401 * Extract the list of column names and the column numbers for the new
1402 * index information. All this information will be used for the index
1403 * creation.
1404 */
1406 {
1412 }
1414 /* Extract opclass options for each attribute */
1419 /* Extract statistic targets for each attribute */
1422 {
1423 HeapTuple tp;
1424 Datum dat;
1434 }
1436 /*
1437 * Now create the new index.
1438 *
1439 * For a partition index, we adjust the partition dependency later, to
1440 * ensure a consistent state at all times. That is why parentIndexRelid
1441 * is not set here.
1442 */
1444 newName,
1449 newInfo,
1450 indexColNames,
1452 tablespaceOid,
1455 opclassOptions,
1457 stattargets,
1458 reloptionsDatum,
1463 NULL);
1465 /* Close the relations used and clean up */
1471 }
1473 /*
1474 * index_concurrently_build
1475 *
1476 * Build index for a concurrent operation. Low-level locks are taken when
1477 * this operation is performed to prevent only schema changes, but they need
1478 * to be kept until the end of the transaction performing this operation.
1479 * 'indexOid' refers to an index relation OID already created as part of
1480 * previous processing, and 'heapOid' refers to its parent heap relation.
1481 */
1482 void
1484 Oid indexRelationId)
1485 {
1486 Relation heapRel;
1487 Oid save_userid;
1490 Relation indexRelation;
1493 /* This had better make sure that a snapshot is active */
1496 /* Open and lock the parent heap relation */
1499 /*
1500 * Switch to the table owner's userid, so that any index functions are run
1501 * as that user. Also lock down security-restricted operations and
1502 * arrange to make GUC variable changes local to this command.
1503 */
1512 /*
1513 * We have to re-build the IndexInfo struct, since it was lost in the
1514 * commit of the transaction where this concurrent index was created at
1515 * the catalog level.
1516 */
1522 /* Now build the index */
1525 /* Roll back any GUC changes executed by index functions */
1528 /* Restore userid and security context */
1531 /* Close both the relations, but keep the locks */
1535 /*
1536 * Update the pg_index row to mark the index as ready for inserts. Once we
1537 * commit this transaction, any new transactions that open the table must
1538 * insert new entries into the index for insertions and non-HOT updates.
1539 */
1541 }
1543 /*
1544 * index_concurrently_swap
1545 *
1546 * Swap name, dependencies, and constraints of the old index over to the new
1547 * index, while marking the old index as invalid and the new as valid.
1548 */
1549 void
1551 {
1552 Relation pg_class,
1553 pg_index,
1554 pg_constraint,
1555 pg_trigger;
1556 Relation oldClassRel,
1557 newClassRel;
1558 HeapTuple oldClassTuple,
1559 newClassTuple;
1560 Form_pg_class oldClassForm,
1561 newClassForm;
1562 HeapTuple oldIndexTuple,
1563 newIndexTuple;
1564 Form_pg_index oldIndexForm,
1565 newIndexForm;
1567 Oid indexConstraintOid;
1571 /*
1572 * Take a necessary lock on the old and new index before swapping them.
1573 */
1577 /* Now swap names and dependencies of those indexes */
1592 /* Swap the names */
1596 /* Swap the partition flags to track inheritance properly */
1607 /* Now swap index info */
1622 /*
1623 * Copy constraint flags from the old index. This is safe because the old
1624 * index guaranteed uniqueness.
1625 */
1633 /* Preserve indisreplident in the new index */
1636 /* Preserve indisclustered in the new index */
1639 /*
1640 * Mark the new index as valid, and the old index as invalid similarly to
1641 * what index_set_state_flags() does.
1642 */
1654 /*
1655 * Move constraints and triggers over to the new index
1656 */
1669 {
1670 HeapTuple constraintTuple,
1671 triggerTuple;
1672 Form_pg_constraint conForm;
1674 SysScanDesc scan;
1677 /* Move the constraint from the old to the new index */
1686 {
1690 }
1694 /* Search for trigger records */
1696 Anum_pg_trigger_tgconstraint,
1704 {
1710 /* Make a modifiable copy */
1719 }
1722 }
1724 /*
1725 * Move comment if any
1726 */
1727 {
1728 Relation description;
1730 SysScanDesc sd;
1731 HeapTuple tuple;
1740 Anum_pg_description_objoid,
1744 Anum_pg_description_classoid,
1748 Anum_pg_description_objsubid,
1758 {
1764 }
1768 }
1770 /*
1771 * Swap inheritance relationship with parent index
1772 */
1774 {
1782 }
1784 /*
1785 * Swap all dependencies of and on the old index to the new one, and
1786 * vice-versa. Note that a call to CommandCounterIncrement() would cause
1787 * duplicate entries in pg_depend, so this should not be done.
1788 */
1795 /* copy over statistics from old to new index */
1798 /* Copy data of pg_statistic from the old index to the new one */
1801 /* Close relations */
1807 /* The lock taken previously is not released until the end of transaction */
1810 }
1812 /*
1813 * index_concurrently_set_dead
1814 *
1815 * Perform the last invalidation stage of DROP INDEX CONCURRENTLY or REINDEX
1816 * CONCURRENTLY before actually dropping the index. After calling this
1817 * function, the index is seen by all the backends as dead. Low-level locks
1818 * taken here are kept until the end of the transaction calling this function.
1819 */
1820 void
1822 {
1823 Relation userHeapRelation;
1824 Relation userIndexRelation;
1826 /*
1827 * No more predicate locks will be acquired on this index, and we're about
1828 * to stop doing inserts into the index which could show conflicts with
1829 * existing predicate locks, so now is the time to move them to the heap
1830 * relation.
1831 */
1836 /*
1837 * Now we are sure that nobody uses the index for queries; they just might
1838 * have it open for updating it. So now we can unset indisready and
1839 * indislive, then wait till nobody could be using it at all anymore.
1840 */
1843 /*
1844 * Invalidate the relcache for the table, so that after this commit all
1845 * sessions will refresh the table's index list. Forgetting just the
1846 * index's relcache entry is not enough.
1847 */
1850 /*
1851 * Close the relations again, though still holding session lock.
1852 */
1855 }
1857 /*
1858 * index_constraint_create
1859 *
1860 * Set up a constraint associated with an index. Return the new constraint's
1861 * address.
1862 *
1863 * heapRelation: table owning the index (must be suitably locked by caller)
1864 * indexRelationId: OID of the index
1865 * parentConstraintId: if constraint is on a partition, the OID of the
1866 * constraint in the parent.
1867 * indexInfo: same info executor uses to insert into the index
1868 * constraintName: what it say (generally, should match name of index)
1869 * constraintType: one of CONSTRAINT_PRIMARY, CONSTRAINT_UNIQUE, or
1870 * CONSTRAINT_EXCLUSION
1871 * flags: bitmask that can include any combination of these bits:
1872 * INDEX_CONSTR_CREATE_MARK_AS_PRIMARY: index is a PRIMARY KEY
1873 * INDEX_CONSTR_CREATE_DEFERRABLE: constraint is DEFERRABLE
1874 * INDEX_CONSTR_CREATE_INIT_DEFERRED: constraint is INITIALLY DEFERRED
1875 * INDEX_CONSTR_CREATE_UPDATE_INDEX: update the pg_index row
1876 * INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS: remove existing dependencies
1877 * of index on table's columns
1878 * INDEX_CONSTR_CREATE_WITHOUT_OVERLAPS: constraint uses WITHOUT OVERLAPS
1879 * allow_system_table_mods: allow table to be a system catalog
1880 * is_internal: index is constructed due to internal process
1881 */
1882 ObjectAddress
1884 Oid indexRelationId,
1885 Oid parentConstraintId,
1889 bits16 constr_flags,
1892 {
1894 ObjectAddress myself,
1895 idxaddr;
1896 Oid conOid;
1903 int16 inhcount;
1910 /* constraint creation support doesn't work while bootstrapping */
1913 /* enforce system-table restriction */
1921 /* primary/unique constraints shouldn't have any expressions */
1926 /*
1927 * If we're manufacturing a constraint for a pre-existing index, we need
1928 * to get rid of the existing auto dependencies for the index (the ones
1929 * that index_create() would have made instead of calling this function).
1930 *
1931 * Note: this code would not necessarily do the right thing if the index
1932 * has any expressions or predicate, but we'd never be turning such an
1933 * index into a UNIQUE or PRIMARY KEY constraint.
1934 */
1940 {
1944 }
1945 else
1946 {
1950 }
1952 /*
1953 * Construct a pg_constraint entry.
1954 */
1956 namespaceId,
1957 constraintType,
1958 deferrable,
1959 initdeferred,
1961 parentConstraintId,
1969 NULL,
1970 NULL,
1971 NULL,
1972 NULL,
1976 NULL,
1981 NULL,
1982 islocal,
1983 inhcount,
1984 noinherit,
1985 is_without_overlaps,
1986 is_internal);
1988 /*
1989 * Register the index as internally dependent on the constraint.
1990 *
1991 * Note that the constraint has a dependency on the table, so we don't
1992 * need (or want) any direct dependency from the index to the table.
1993 */
1998 /*
1999 * Also, if this is a constraint on a partition, give it partition-type
2000 * dependencies on the parent constraint as well as the table.
2001 */
2003 {
2004 ObjectAddress referenced;
2011 }
2013 /*
2014 * If the constraint is deferrable, create the deferred uniqueness
2015 * checking trigger. (The trigger will be given an internal dependency on
2016 * the constraint by CreateTrigger.)
2017 */
2019 {
2043 }
2045 /*
2046 * If needed, mark the index as primary and/or deferred in pg_index.
2047 *
2048 * Note: When making an existing index into a constraint, caller must have
2049 * a table lock that prevents concurrent table updates; otherwise, there
2050 * is a risk that concurrent readers of the table will miss seeing this
2051 * index at all.
2052 */
2055 {
2056 Relation pg_index;
2057 HeapTuple indexTuple;
2058 Form_pg_index indexForm;
2071 {
2075 }
2078 {
2081 }
2084 {
2087 /*
2088 * When we mark an existing index as primary, force a relcache
2089 * flush on its parent table, so that all sessions will become
2090 * aware that the table now has a primary key. This is important
2091 * because it affects some replication behaviors.
2092 */
2098 }
2102 }
2105 }
2107 /*
2108 * index_drop
2109 *
2110 * NOTE: this routine should now only be called through performDeletion(),
2111 * else associated dependencies won't be cleaned up.
2112 *
2113 * If concurrent is true, do a DROP INDEX CONCURRENTLY. If concurrent is
2114 * false but concurrent_lock_mode is true, then do a normal DROP INDEX but
2115 * take a lock for CONCURRENTLY processing. That is used as part of REINDEX
2116 * CONCURRENTLY.
2117 */
2118 void
2120 {
2121 Oid heapId;
2122 Relation userHeapRelation;
2123 Relation userIndexRelation;
2124 Relation indexRelation;
2125 HeapTuple tuple;
2127 LockRelId heaprelid,
2128 indexrelid;
2129 LOCKTAG heaplocktag;
2130 LOCKMODE lockmode;
2132 /*
2133 * A temporary relation uses a non-concurrent DROP. Other backends can't
2134 * access a temporary relation, so there's no harm in grabbing a stronger
2135 * lock (see comments in RemoveRelations), and a non-concurrent DROP is
2136 * more efficient.
2137 */
2141 /*
2142 * To drop an index safely, we must grab exclusive lock on its parent
2143 * table. Exclusive lock on the index alone is insufficient because
2144 * another backend might be about to execute a query on the parent table.
2145 * If it relies on a previously cached list of index OIDs, then it could
2146 * attempt to access the just-dropped index. We must therefore take a
2147 * table lock strong enough to prevent all queries on the table from
2148 * proceeding until we commit and send out a shared-cache-inval notice
2149 * that will make them update their index lists.
2150 *
2151 * In the concurrent case we avoid this requirement by disabling index use
2152 * in multiple steps and waiting out any transactions that might be using
2153 * the index, so we don't need exclusive lock on the parent table. Instead
2154 * we take ShareUpdateExclusiveLock, to ensure that two sessions aren't
2155 * doing CREATE/DROP INDEX CONCURRENTLY on the same index. (We will get
2156 * AccessExclusiveLock on the index below, once we're sure nobody else is
2157 * using it.)
2158 */
2160 lockmode = (concurrent || concurrent_lock_mode) ? ShareUpdateExclusiveLock : AccessExclusiveLock;
2164 /*
2165 * We might still have open queries using it in our own session, which the
2166 * above locking won't prevent, so test explicitly.
2167 */
2170 /*
2171 * Drop Index Concurrently is more or less the reverse process of Create
2172 * Index Concurrently.
2173 *
2174 * First we unset indisvalid so queries starting afterwards don't use the
2175 * index to answer queries anymore. We have to keep indisready = true so
2176 * transactions that are still scanning the index can continue to see
2177 * valid index contents. For instance, if they are using READ COMMITTED
2178 * mode, and another transaction makes changes and commits, they need to
2179 * see those new tuples in the index.
2180 *
2181 * After all transactions that could possibly have used the index for
2182 * queries end, we can unset indisready and indislive, then wait till
2183 * nobody could be touching it anymore. (Note: we need indislive because
2184 * this state must be distinct from the initial state during CREATE INDEX
2185 * CONCURRENTLY, which has indislive true while indisready and indisvalid
2186 * are false. That's because in that state, transactions must examine the
2187 * index for HOT-safety decisions, while in this state we don't want them
2188 * to open it at all.)
2189 *
2190 * Since all predicate locks on the index are about to be made invalid, we
2191 * must promote them to predicate locks on the heap. In the
2192 * non-concurrent case we can just do that now. In the concurrent case
2193 * it's a bit trickier. The predicate locks must be moved when there are
2194 * no index scans in progress on the index and no more can subsequently
2195 * start, so that no new predicate locks can be made on the index. Also,
2196 * they must be moved before heap inserts stop maintaining the index, else
2197 * the conflict with the predicate lock on the index gap could be missed
2198 * before the lock on the heap relation is in place to detect a conflict
2199 * based on the heap tuple insert.
2200 */
2202 {
2203 /*
2204 * We must commit our transaction in order to make the first pg_index
2205 * state update visible to other sessions. If the DROP machinery has
2206 * already performed any other actions (removal of other objects,
2207 * pg_depend entries, etc), the commit would make those actions
2208 * permanent, which would leave us with inconsistent catalog state if
2209 * we fail partway through the following sequence. Since DROP INDEX
2210 * CONCURRENTLY is restricted to dropping just one index that has no
2211 * dependencies, we should get here before anything's been done ---
2212 * but let's check that to be sure. We can verify that the current
2213 * transaction has not executed any transactional updates by checking
2214 * that no XID has been assigned.
2215 */
2221 /*
2222 * Mark index invalid by updating its pg_index entry
2223 */
2226 /*
2227 * Invalidate the relcache for the table, so that after this commit
2228 * all sessions will refresh any cached plans that might reference the
2229 * index.
2230 */
2233 /* save lockrelid and locktag for below, then close but keep locks */
2241 /*
2242 * We must commit our current transaction so that the indisvalid
2243 * update becomes visible to other transactions; then start another.
2244 * Note that any previously-built data structures are lost in the
2245 * commit. The only data we keep past here are the relation IDs.
2246 *
2247 * Before committing, get a session-level lock on the table, to ensure
2248 * that neither it nor the index can be dropped before we finish. This
2249 * cannot block, even if someone else is waiting for access, because
2250 * we already have the same lock within our transaction.
2251 */
2259 /*
2260 * Now we must wait until no running transaction could be using the
2261 * index for a query. Use AccessExclusiveLock here to check for
2262 * running transactions that hold locks of any kind on the table. Note
2263 * we do not need to worry about xacts that open the table for reading
2264 * after this point; they will see the index as invalid when they open
2265 * the relation.
2266 *
2267 * Note: the reason we use actual lock acquisition here, rather than
2268 * just checking the ProcArray and sleeping, is that deadlock is
2269 * possible if one of the transactions in question is blocked trying
2270 * to acquire an exclusive lock on our table. The lock code will
2271 * detect deadlock and error out properly.
2272 *
2273 * Note: we report progress through WaitForLockers() unconditionally
2274 * here, even though it will only be used when we're called by REINDEX
2275 * CONCURRENTLY and not when called by DROP INDEX CONCURRENTLY.
2276 */
2279 /*
2280 * Updating pg_index might involve TOAST table access, so ensure we
2281 * have a valid snapshot.
2282 */
2285 /* Finish invalidation of index and mark it as dead */
2290 /*
2291 * Again, commit the transaction to make the pg_index update visible
2292 * to other sessions.
2293 */
2297 /*
2298 * Wait till every transaction that saw the old index state has
2299 * finished. See above about progress reporting.
2300 */
2303 /*
2304 * Re-open relations to allow us to complete our actions.
2305 *
2306 * At this point, nothing should be accessing the index, but lets
2307 * leave nothing to chance and grab AccessExclusiveLock on the index
2308 * before the physical deletion.
2309 */
2312 }
2313 else
2314 {
2315 /* Not concurrent, so just transfer predicate locks and we're good */
2317 }
2319 /*
2320 * Schedule physical removal of the files (if any)
2321 */
2325 /* ensure that stats are dropped if transaction commits */
2328 /*
2329 * Close and flush the index's relcache entry, to ensure relcache doesn't
2330 * try to rebuild it while we're deleting catalog entries. We keep the
2331 * lock though.
2332 */
2337 /*
2338 * Updating pg_index might involve TOAST table access, so ensure we have a
2339 * valid snapshot.
2340 */
2343 /*
2344 * fix INDEX relation, and check for expressional index
2345 */
2362 /*
2363 * if it has any expression columns, we might have stored statistics about
2364 * them.
2365 */
2369 /*
2370 * fix ATTRIBUTE relation
2371 */
2374 /*
2375 * fix RELATION relation
2376 */
2379 /*
2380 * fix INHERITS relation
2381 */
2384 /*
2385 * We are presently too lazy to attempt to compute the new correct value
2386 * of relhasindex (the next VACUUM will fix it if necessary). So there is
2387 * no need to update the pg_class tuple for the owning relation. But we
2388 * must send out a shared-cache-inval notice on the owning relation to
2389 * ensure other backends update their relcache lists of indexes. (In the
2390 * concurrent case, this is redundant but harmless.)
2391 */
2394 /*
2395 * Close owning rel, but keep lock
2396 */
2399 /*
2400 * Release the session locks before we go.
2401 */
2403 {
2406 }
2407 }
2409 /* ----------------------------------------------------------------
2410 * index_build support
2411 * ----------------------------------------------------------------
2412 */
2414 /* ----------------
2415 * BuildIndexInfo
2416 * Construct an IndexInfo record for an open index
2417 *
2418 * IndexInfo stores the information about the index that's needed by
2419 * FormIndexDatum, which is used for both index_build() and later insertion
2420 * of individual index tuples. Normally we build an IndexInfo for an index
2421 * just once per command, and then use it for (potentially) many tuples.
2422 * ----------------
2423 */
2424 IndexInfo *
2426 {
2432 /* check the number of keys, and copy attr numbers into the IndexInfo */
2438 /*
2439 * Create the node, fetching any expressions needed for expressional
2440 * indexes and index predicate if any.
2441 */
2454 /* fill in attribute numbers */
2458 /* fetch exclusion constraint info if any */
2460 {
2465 }
2468 }
2470 /* ----------------
2471 * BuildDummyIndexInfo
2472 * Construct a dummy IndexInfo record for an open index
2473 *
2474 * This differs from the real BuildIndexInfo in that it will never run any
2475 * user-defined code that might exist in index expressions or predicates.
2476 * Instead of the real index expressions, we return null constants that have
2477 * the right types/typmods/collations. Predicates and exclusion clauses are
2478 * just ignored. This is sufficient for the purpose of truncating an index,
2479 * since we will not need to actually evaluate the expressions or predicates;
2480 * the only thing that's likely to be done with the data is construction of
2481 * a tupdesc describing the index's rowtype.
2482 * ----------------
2483 */
2484 IndexInfo *
2486 {
2492 /* check the number of keys, and copy attr numbers into the IndexInfo */
2498 /*
2499 * Create the node, using dummy index expressions, and pretending there is
2500 * no predicate.
2501 */
2506 NIL,
2514 /* fill in attribute numbers */
2518 /* We ignore the exclusion constraint if any */
2521 }
2523 /*
2524 * CompareIndexInfo
2525 * Return whether the properties of two indexes (in different tables)
2526 * indicate that they have the "same" definitions.
2527 *
2528 * Note: passing collations and opfamilies separately is a kludge. Adding
2529 * them to IndexInfo may result in better coding here and elsewhere.
2530 *
2531 * Use build_attrmap_by_name(index2, index1) to build the attmap.
2532 */
2533 bool
2538 {
2547 /* indexes are only equivalent if they have the same access method */
2551 /* and same number of attributes */
2555 /* and same number of key attributes */
2559 /*
2560 * and columns match through the attribute map (actual attribute numbers
2561 * might differ!) Note that this checks that index columns that are
2562 * expressions appear in the same positions. We will next compare the
2563 * expressions themselves.
2564 */
2566 {
2570 /* ignore expressions for now (but check their collation/opfamily) */
2573 {
2574 /* fail if just one index has an expression in this column */
2579 /* both are columns, so check for match after mapping */
2583 }
2585 /* collation and opfamily are not valid for included columns */
2593 }
2595 /*
2596 * For expression indexes: either both are expression indexes, or neither
2597 * is; if they are, make sure the expressions match.
2598 */
2602 {
2610 {
2611 /*
2612 * we could throw an error here, but seems out of scope for this
2613 * routine.
2614 */
2616 }
2620 }
2622 /* Partial index predicates must be identical, if they exist */
2626 {
2634 {
2635 /*
2636 * we could throw an error here, but seems out of scope for this
2637 * routine.
2638 */
2640 }
2643 }
2645 /* No support currently for comparing exclusion indexes. */
2650 }
2652 /* ----------------
2653 * BuildSpeculativeIndexInfo
2654 * Add extra state to IndexInfo record
2655 *
2656 * For unique indexes, we usually don't want to add info to the IndexInfo for
2657 * checking uniqueness, since the B-Tree AM handles that directly. However, in
2658 * the case of speculative insertion and conflict detection in logical
2659 * replication, additional support is required.
2660 *
2661 * Do this processing here rather than in BuildIndexInfo() to not incur the
2662 * overhead in the common non-speculative cases.
2663 * ----------------
2664 */
2665 void
2667 {
2673 /*
2674 * fetch info for checking unique indexes
2675 */
2685 /*
2686 * We have to look up the operator's strategy number. This provides a
2687 * cross-check that the operator does match the index.
2688 */
2689 /* We need the func OIDs and strategy numbers too */
2691 {
2703 }
2704 }
2706 /* ----------------
2707 * FormIndexDatum
2708 * Construct values[] and isnull[] arrays for a new index tuple.
2709 *
2710 * indexInfo Info about the index
2711 * slot Heap tuple for which we must prepare an index entry
2712 * estate executor state for evaluating any index expressions
2713 * values Array of index Datums (output area)
2714 * isnull Array of is-null indicators (output area)
2715 *
2716 * When there are no index expressions, estate may be NULL. Otherwise it
2717 * must be supplied, *and* the ecxt_scantuple slot of its per-tuple expr
2718 * context must point to the heap tuple passed in.
2719 *
2720 * Notice we don't actually call index_form_tuple() here; we just prepare
2721 * its input arrays values[] and isnull[]. This is because the index AM
2722 * may wish to alter the data before storage.
2723 * ----------------
2724 */
2725 void
2731 {
2737 {
2738 /* First time through, set up expression evaluation state */
2741 /* Check caller has set up context correctly */
2743 }
2747 {
2749 Datum iDatum;
2755 {
2756 /*
2757 * Plain index column; get the value we need directly from the
2758 * heap tuple.
2759 */
2761 }
2762 else
2763 {
2764 /*
2765 * Index expression --- need to evaluate it.
2766 */
2773 }
2776 }
2780 }
2783 /*
2784 * index_update_stats --- update pg_class entry after CREATE INDEX or REINDEX
2785 *
2786 * This routine updates the pg_class row of either an index or its parent
2787 * relation after CREATE INDEX or REINDEX. Its rather bizarre API is designed
2788 * to ensure we can do all the necessary work in just one update.
2789 *
2790 * hasindex: set relhasindex to this value
2791 * reltuples: if >= 0, set reltuples to this value; else no change
2792 *
2793 * If reltuples >= 0, relpages and relallvisible are also updated (using
2794 * RelationGetNumberOfBlocks() and visibilitymap_count()).
2795 *
2796 * NOTE: an important side-effect of this operation is that an SI invalidation
2797 * message is sent out to all backends --- including me --- causing relcache
2798 * entries to be flushed or updated with the new data. This must happen even
2799 * if we find that no change is needed in the pg_class row. When updating
2800 * a heap entry, this ensures that other backends find out about the new
2801 * index. When updating an index, it's important because some index AMs
2802 * expect a relcache flush to occur after REINDEX.
2803 */
2804 static void
2808 {
2813 Relation pg_class;
2815 HeapTuple tuple;
2817 Form_pg_class rd_rel;
2820 /*
2821 * As a special hack, if we are dealing with an empty table and the
2822 * existing reltuples is -1, we leave that alone. This ensures that
2823 * creating an index as part of CREATE TABLE doesn't cause the table to
2824 * prematurely look like it's been vacuumed. The rd_rel we modify may
2825 * differ from rel->rd_rel due to e.g. commit of concurrent GRANT, but the
2826 * commands that change reltuples take locks conflicting with ours. (Even
2827 * if a command changed reltuples under a weaker lock, this affects only
2828 * statistics for an empty table.)
2829 */
2833 /*
2834 * Don't update statistics during binary upgrade, because the indexes are
2835 * created before the data is moved into place.
2836 */
2839 /*
2840 * Finish I/O and visibility map buffer locks before
2841 * systable_inplace_update_begin() locks the pg_class buffer. The rd_rel
2842 * we modify may differ from rel->rd_rel due to e.g. commit of concurrent
2843 * GRANT, but no command changes a relkind from non-index to index. (Even
2844 * if one did, relallvisible doesn't break functionality.)
2845 */
2847 {
2852 }
2854 /*
2855 * We always update the pg_class row using a non-transactional,
2856 * overwrite-in-place update. There are several reasons for this:
2857 *
2858 * 1. In bootstrap mode, we have no choice --- UPDATE wouldn't work.
2859 *
2860 * 2. We could be reindexing pg_class itself, in which case we can't move
2861 * its pg_class row because CatalogTupleInsert/CatalogTupleUpdate might
2862 * not know about all the indexes yet (see reindex_relation).
2863 *
2864 * 3. Because we execute CREATE INDEX with just share lock on the parent
2865 * rel (to allow concurrent index creations), an ordinary update could
2866 * suffer a tuple-concurrently-updated failure against another CREATE
2867 * INDEX committing at about the same time. We can avoid that by having
2868 * them both do nontransactional updates (we assume they will both be
2869 * trying to change the pg_class row to the same thing, so it doesn't
2870 * matter which goes first).
2871 *
2872 * It is safe to use a non-transactional update even though our
2873 * transaction could still fail before committing. Setting relhasindex
2874 * true is safe even if there are no indexes (VACUUM will eventually fix
2875 * it). And of course the new relpages and reltuples counts are correct
2876 * regardless. However, we don't want to change relpages (or
2877 * relallvisible) if the caller isn't providing an updated reltuples
2878 * count, because that would bollix the reltuples/relpages ratio which is
2879 * what's really important.
2880 */
2885 Anum_pg_class_oid,
2895 /* Should this be a more comprehensive test? */
2898 /* Apply required updates, if any, to copied tuple */
2902 {
2905 }
2908 {
2910 {
2913 }
2915 {
2918 }
2920 {
2923 }
2924 }
2926 /*
2927 * If anything changed, write out the tuple
2928 */
2930 {
2932 /* the above sends transactional and immediate cache inval messages */
2933 }
2934 else
2935 {
2938 /*
2939 * While we didn't change relhasindex, CREATE INDEX needs a
2940 * transactional inval for when the new index's catalog rows become
2941 * visible. Other CREATE INDEX and REINDEX code happens to also queue
2942 * this inval, but keep this in case rare callers rely on this part of
2943 * our API contract.
2944 */
2946 }
2951 }
2954 /*
2955 * index_build - invoke access-method-specific index build procedure
2956 *
2957 * On entry, the index's catalog entries are valid, and its physical disk
2958 * file has been created but is empty. We call the AM-specific build
2959 * procedure to fill in the index contents. We then update the pg_class
2960 * entries of the index and heap relation as needed, using statistics
2961 * returned by ambuild as well as data passed by the caller.
2962 *
2963 * isreindex indicates we are recreating a previously-existing index.
2964 * parallel indicates if parallelism may be useful.
2965 *
2966 * Note: before Postgres 8.2, the passed-in heap and index Relations
2967 * were automatically closed by this routine. This is no longer the case.
2968 * The caller opened 'em, and the caller should close 'em.
2969 */
2970 void
2972 Relation indexRelation,
2976 {
2978 Oid save_userid;
2982 /*
2983 * sanity checks
2984 */
2990 /*
2991 * Determine worker process details for parallel CREATE INDEX. Currently,
2992 * only btree has support for parallel builds.
2993 *
2994 * Note that planner considers parallel safety for us.
2995 */
3007 else
3014 /*
3015 * Switch to the table owner's userid, so that any index functions are run
3016 * as that user. Also lock down security-restricted operations and
3017 * arrange to make GUC variable changes local to this command.
3018 */
3025 /* Set up initial progress report status */
3026 {
3028 PROGRESS_CREATEIDX_PHASE,
3029 PROGRESS_CREATEIDX_SUBPHASE,
3030 PROGRESS_CREATEIDX_TUPLES_DONE,
3031 PROGRESS_CREATEIDX_TUPLES_TOTAL,
3032 PROGRESS_SCAN_BLOCKS_DONE,
3033 PROGRESS_SCAN_BLOCKS_TOTAL
3034 };
3036 PROGRESS_CREATEIDX_PHASE_BUILD,
3037 PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE,
3039 };
3042 }
3044 /*
3045 * Call the access method's build procedure
3046 */
3048 indexInfo);
3051 /*
3052 * If this is an unlogged index, we may need to write out an init fork for
3053 * it -- but we must first check whether one already exists. If, for
3054 * example, an unlogged relation is truncated in the transaction that
3055 * created it, or truncated twice in a subsequent transaction, the
3056 * relfilenumber won't change, and nothing needs to be done here.
3057 */
3060 {
3064 }
3066 /*
3067 * If we found any potentially broken HOT chains, mark the index as not
3068 * being usable until the current transaction is below the event horizon.
3069 * See src/backend/access/heap/README.HOT for discussion. While it might
3070 * become safe to use the index earlier based on actual cleanup activity
3071 * and other active transactions, the test for that would be much more
3072 * complex and would require some form of blocking, so keep it simple and
3073 * fast by just using the current transaction.
3074 *
3075 * However, when reindexing an existing index, we should do nothing here.
3076 * Any HOT chains that are broken with respect to the index must predate
3077 * the index's original creation, so there is no need to change the
3078 * index's usability horizon. Moreover, we *must not* try to change the
3079 * index's pg_index entry while reindexing pg_index itself, and this
3080 * optimization nicely prevents that. The more complex rules needed for a
3081 * reindex are handled separately after this function returns.
3082 *
3083 * We also need not set indcheckxmin during a concurrent index build,
3084 * because we won't set indisvalid true until all transactions that care
3085 * about the broken HOT chains are gone.
3086 *
3087 * Therefore, this code path can only be taken during non-concurrent
3088 * CREATE INDEX. Thus the fact that heap_update will set the pg_index
3089 * tuple's xmin doesn't matter, because that tuple was created in the
3090 * current transaction anyway. That also means we don't need to worry
3091 * about any concurrent readers of the tuple; no other transaction can see
3092 * it yet.
3093 */
3097 {
3099 Relation pg_index;
3100 HeapTuple indexTuple;
3101 Form_pg_index indexForm;
3111 /* If it's a new index, indcheckxmin shouldn't be set ... */
3119 }
3121 /*
3122 * Update heap and index pg_class rows
3123 */
3132 /* Make the updated catalog row versions visible */
3135 /*
3136 * If it's for an exclusion constraint, make a second pass over the heap
3137 * to verify that the constraint is satisfied. We must not do this until
3138 * the index is fully valid. (Broken HOT chains shouldn't matter, though;
3139 * see comments for IndexCheckExclusion.)
3140 */
3144 /* Roll back any GUC changes executed by index functions */
3147 /* Restore userid and security context */
3149 }
3151 /*
3152 * IndexCheckExclusion - verify that a new exclusion constraint is satisfied
3153 *
3154 * When creating an exclusion constraint, we first build the index normally
3155 * and then rescan the heap to check for conflicts. We assume that we only
3156 * need to validate tuples that are live according to an up-to-date snapshot,
3157 * and that these were correctly indexed even in the presence of broken HOT
3158 * chains. This should be OK since we are holding at least ShareLock on the
3159 * table, meaning there can be no uncommitted updates from other transactions.
3160 * (Note: that wouldn't necessarily work for system catalogs, since many
3161 * operations release write lock early on the system catalogs.)
3162 */
3163 static void
3165 Relation indexRelation,
3167 {
3168 TableScanDesc scan;
3175 Snapshot snapshot;
3177 /*
3178 * If we are reindexing the target index, mark it as no longer being
3179 * reindexed, to forestall an Assert in index_beginscan when we try to use
3180 * the index for probes. This is OK because the index is now fully valid.
3181 */
3185 /*
3186 * Need an EState for evaluation of index expressions and partial-index
3187 * predicates. Also a slot to hold the current tuple.
3188 */
3193 /* Arrange for econtext's scan tuple to be the tuple under test */
3196 /* Set up execution state for predicate, if any. */
3199 /*
3200 * Scan all live tuples in the base relation.
3201 */
3211 {
3214 /*
3215 * In a partial index, ignore tuples that don't satisfy the predicate.
3216 */
3218 {
3221 }
3223 /*
3224 * Extract index column values, including computing expressions.
3225 */
3227 slot,
3228 estate,
3229 values,
3230 isnull);
3232 /*
3233 * Check that this tuple has no conflicts.
3234 */
3241 }
3250 /* These may have been pointing to the now-gone estate */
3253 }
3255 /*
3256 * validate_index - support code for concurrent index builds
3257 *
3258 * We do a concurrent index build by first inserting the catalog entry for the
3259 * index via index_create(), marking it not indisready and not indisvalid.
3260 * Then we commit our transaction and start a new one, then we wait for all
3261 * transactions that could have been modifying the table to terminate. Now
3262 * we know that any subsequently-started transactions will see the index and
3263 * honor its constraints on HOT updates; so while existing HOT-chains might
3264 * be broken with respect to the index, no currently live tuple will have an
3265 * incompatible HOT update done to it. We now build the index normally via
3266 * index_build(), while holding a weak lock that allows concurrent
3267 * insert/update/delete. Also, we index only tuples that are valid
3268 * as of the start of the scan (see table_index_build_scan), whereas a normal
3269 * build takes care to include recently-dead tuples. This is OK because
3270 * we won't mark the index valid until all transactions that might be able
3271 * to see those tuples are gone. The reason for doing that is to avoid
3272 * bogus unique-index failures due to concurrent UPDATEs (we might see
3273 * different versions of the same row as being valid when we pass over them,
3274 * if we used HeapTupleSatisfiesVacuum). This leaves us with an index that
3275 * does not contain any tuples added to the table while we built the index.
3276 *
3277 * Next, we mark the index "indisready" (but still not "indisvalid") and
3278 * commit the second transaction and start a third. Again we wait for all
3279 * transactions that could have been modifying the table to terminate. Now
3280 * we know that any subsequently-started transactions will see the index and
3281 * insert their new tuples into it. We then take a new reference snapshot
3282 * which is passed to validate_index(). Any tuples that are valid according
3283 * to this snap, but are not in the index, must be added to the index.
3284 * (Any tuples committed live after the snap will be inserted into the
3285 * index by their originating transaction. Any tuples committed dead before
3286 * the snap need not be indexed, because we will wait out all transactions
3287 * that might care about them before we mark the index valid.)
3288 *
3289 * validate_index() works by first gathering all the TIDs currently in the
3290 * index, using a bulkdelete callback that just stores the TIDs and doesn't
3291 * ever say "delete it". (This should be faster than a plain indexscan;
3292 * also, not all index AMs support full-index indexscan.) Then we sort the
3293 * TIDs, and finally scan the table doing a "merge join" against the TID list
3294 * to see which tuples are missing from the index. Thus we will ensure that
3295 * all tuples valid according to the reference snapshot are in the index.
3296 *
3297 * Building a unique index this way is tricky: we might try to insert a
3298 * tuple that is already dead or is in process of being deleted, and we
3299 * mustn't have a uniqueness failure against an updated version of the same
3300 * row. We could try to check the tuple to see if it's already dead and tell
3301 * index_insert() not to do the uniqueness check, but that still leaves us
3302 * with a race condition against an in-progress update. To handle that,
3303 * we expect the index AM to recheck liveness of the to-be-inserted tuple
3304 * before it declares a uniqueness error.
3305 *
3306 * After completing validate_index(), we wait until all transactions that
3307 * were alive at the time of the reference snapshot are gone; this is
3308 * necessary to be sure there are none left with a transaction snapshot
3309 * older than the reference (and hence possibly able to see tuples we did
3310 * not index). Then we mark the index "indisvalid" and commit. Subsequent
3311 * transactions will be able to use it for queries.
3312 *
3313 * Doing two full table scans is a brute-force strategy. We could try to be
3314 * cleverer, eg storing new tuples in a special area of the table (perhaps
3315 * making the table append-only by setting use_fsm). However that would
3316 * add yet more locking issues.
3317 */
3318 void
3320 {
3321 Relation heapRelation,
3322 indexRelation;
3324 IndexVacuumInfo ivinfo;
3325 ValidateIndexState state;
3326 Oid save_userid;
3330 {
3332 PROGRESS_CREATEIDX_PHASE,
3333 PROGRESS_CREATEIDX_TUPLES_DONE,
3334 PROGRESS_CREATEIDX_TUPLES_TOTAL,
3335 PROGRESS_SCAN_BLOCKS_DONE,
3336 PROGRESS_SCAN_BLOCKS_TOTAL
3337 };
3339 PROGRESS_CREATEIDX_PHASE_VALIDATE_IDXSCAN,
3341 };
3344 }
3346 /* Open and lock the parent heap relation */
3349 /*
3350 * Switch to the table owner's userid, so that any index functions are run
3351 * as that user. Also lock down security-restricted operations and
3352 * arrange to make GUC variable changes local to this command.
3353 */
3362 /*
3363 * Fetch info needed for index_insert. (You might think this should be
3364 * passed in from DefineIndex, but its copy is long gone due to having
3365 * been built in a previous transaction.)
3366 */
3369 /* mark build is concurrent just for consistency */
3372 /*
3373 * Scan the index and gather up all the TIDs into a tuplesort object.
3374 */
3384 /*
3385 * Encode TIDs as int8 values for the sort, rather than directly sorting
3386 * item pointers. This can be significantly faster, primarily because TID
3387 * is a pass-by-reference type on all platforms, whereas int8 is
3388 * pass-by-value on most platforms.
3389 */
3392 maintenance_work_mem,
3396 /* ambulkdelete updates progress metrics */
3400 /* Execute the sort */
3401 {
3403 PROGRESS_CREATEIDX_PHASE,
3404 PROGRESS_SCAN_BLOCKS_DONE,
3405 PROGRESS_SCAN_BLOCKS_TOTAL
3406 };
3408 PROGRESS_CREATEIDX_PHASE_VALIDATE_SORT,
3410 };
3413 }
3416 /*
3417 * Now scan the heap and "merge" it with the index
3418 */
3420 PROGRESS_CREATEIDX_PHASE_VALIDATE_TABLESCAN);
3422 indexRelation,
3423 indexInfo,
3424 snapshot,
3427 /* Done with tuplesort object */
3430 /* Make sure to release resources cached in indexInfo (if needed). */
3437 /* Roll back any GUC changes executed by index functions */
3440 /* Restore userid and security context */
3443 /* Close rels, but keep locks */
3446 }
3448 /*
3449 * validate_index_callback - bulkdelete callback to collect the index TIDs
3450 */
3451 static bool
3453 {
3460 }
3462 /*
3463 * index_set_state_flags - adjust pg_index state flags
3464 *
3465 * This is used during CREATE/DROP INDEX CONCURRENTLY to adjust the pg_index
3466 * flags that denote the index's state.
3467 *
3468 * Note that CatalogTupleUpdate() sends a cache invalidation message for the
3469 * tuple, so other sessions will hear about the update as soon as we commit.
3470 */
3471 void
3473 {
3474 Relation pg_index;
3475 HeapTuple indexTuple;
3476 Form_pg_index indexForm;
3478 /* Open pg_index and fetch a writable copy of the index's tuple */
3487 /* Perform the requested state change on the copy */
3489 {
3491 /* Set indisready during a CREATE INDEX CONCURRENTLY sequence */
3498 /* Set indisvalid during a CREATE INDEX CONCURRENTLY sequence */
3506 /*
3507 * Clear indisvalid during a DROP INDEX CONCURRENTLY sequence
3508 *
3509 * If indisready == true we leave it set so the index still gets
3510 * maintained by active transactions. We only need to ensure that
3511 * indisvalid is false. (We don't assert that either is initially
3512 * true, though, since we want to be able to retry a DROP INDEX
3513 * CONCURRENTLY that failed partway through.)
3514 *
3515 * Note: the CLUSTER logic assumes that indisclustered cannot be
3516 * set on any invalid index, so clear that flag too. For
3517 * cleanliness, also clear indisreplident.
3518 */
3525 /*
3526 * Clear indisready/indislive during DROP INDEX CONCURRENTLY
3527 *
3528 * We clear both indisready and indislive, because we not only
3529 * want to stop updates, we want to prevent sessions from touching
3530 * the index at all.
3531 */
3538 }
3540 /* ... and update it */
3544 }
3547 /*
3548 * IndexGetRelation: given an index's relation OID, get the OID of the
3549 * relation it is an index on. Uses the system cache.
3550 */
3551 Oid
3553 {
3554 HeapTuple tuple;
3555 Form_pg_index index;
3556 Oid result;
3560 {
3564 }
3571 }
3573 /*
3574 * reindex_index - This routine is used to recreate a single index
3575 */
3576 void
3580 {
3581 Relation iRel,
3582 heapRelation;
3583 Oid heapId;
3584 Oid save_userid;
3589 PGRUsage ru0;
3595 /*
3596 * Open and lock the parent heap relation. ShareLock is sufficient since
3597 * we only need to be sure no schema or data changes are going on.
3598 */
3601 /* if relation is missing, leave */
3607 else
3610 /* if relation is gone, leave */
3614 /*
3615 * Switch to the table owner's userid, so that any index functions are run
3616 * as that user. Also lock down security-restricted operations and
3617 * arrange to make GUC variable changes local to this command.
3618 */
3626 {
3628 PROGRESS_CREATEIDX_COMMAND,
3629 PROGRESS_CREATEIDX_INDEX_OID
3630 };
3632 PROGRESS_CREATEIDX_COMMAND_REINDEX,
3633 indexId
3634 };
3637 heapId);
3639 }
3641 /*
3642 * Open the target index relation and get an exclusive lock on it, to
3643 * ensure that no one else is touching this particular index.
3644 */
3647 else
3650 /* if index relation is gone, leave */
3652 {
3653 /* Roll back any GUC changes */
3656 /* Restore userid and security context */
3659 /* Close parent heap relation, but keep locks */
3662 }
3668 /*
3669 * If a statement is available, telling that this comes from a REINDEX
3670 * command, collect the index for event triggers.
3671 */
3673 {
3674 ObjectAddress address;
3678 InvalidObjectAddress,
3680 }
3682 /*
3683 * Partitioned indexes should never get processed here, as they have no
3684 * physical storage.
3685 */
3691 /*
3692 * Don't allow reindex on temp tables of other backends ... their local
3693 * buffer manager is not going to cope.
3694 */
3700 /*
3701 * Don't allow reindex of an invalid index on TOAST table. This is a
3702 * leftover from a failed REINDEX CONCURRENTLY, and if rebuilt it would
3703 * not be possible to drop it anymore.
3704 */
3711 /*
3712 * System relations cannot be moved even if allow_system_table_mods is
3713 * enabled to keep things consistent with the concurrent case where all
3714 * the indexes of a relation are processed in series, including indexes of
3715 * toast relations.
3716 *
3717 * Note that this check is not part of CheckRelationTableSpaceMove() as it
3718 * gets used for ALTER TABLE SET TABLESPACE that could cascade across
3719 * toast relations.
3720 */
3728 /* Check if the tablespace of this index needs to be changed */
3733 /*
3734 * Also check for active uses of the index in the current transaction; we
3735 * don't want to reindex underneath an open indexscan.
3736 */
3739 /* Set new tablespace, if requested */
3741 {
3742 /* Update its pg_class row */
3745 /*
3746 * Schedule unlinking of the old index storage at transaction commit.
3747 */
3751 /* Make sure the reltablespace change is visible */
3753 }
3755 /*
3756 * All predicate locks on the index are about to be made invalid. Promote
3757 * them to relation locks on the heap.
3758 */
3761 /* Fetch info needed for index_build */
3764 /* If requested, skip checking uniqueness/exclusion constraints */
3766 {
3773 }
3775 /* Suppress use of the target index while rebuilding it */
3778 /* Create a new physical relation for the index */
3781 /* Initialize the index and rebuild */
3782 /* Note: we do not need to re-establish pkey setting */
3785 /* Re-allow use of target index */
3788 /*
3789 * If the index is marked invalid/not-ready/dead (ie, it's from a failed
3790 * CREATE INDEX CONCURRENTLY, or a DROP INDEX CONCURRENTLY failed midway),
3791 * and we didn't skip a uniqueness check, we can now mark it valid. This
3792 * allows REINDEX to be used to clean up in such cases.
3793 *
3794 * We can also reset indcheckxmin, because we have now done a
3795 * non-concurrent index build, *except* in the case where index_build
3796 * found some still-broken HOT chains. If it did, and we don't have to
3797 * change any of the other flags, we just leave indcheckxmin alone (note
3798 * that index_build won't have changed it, because this is a reindex).
3799 * This is okay and desirable because not updating the tuple leaves the
3800 * index's usability horizon (recorded as the tuple's xmin value) the same
3801 * as it was.
3802 *
3803 * But, if the index was invalid/not-ready/dead and there were broken HOT
3804 * chains, we had better force indcheckxmin true, because the normal
3805 * argument that the HOT chains couldn't conflict with the index is
3806 * suspect for an invalid index. (A conflict is definitely possible if
3807 * the index was dead. It probably shouldn't happen otherwise, but let's
3808 * be conservative.) In this case advancing the usability horizon is
3809 * appropriate.
3810 *
3811 * Another reason for avoiding unnecessary updates here is that while
3812 * reindexing pg_index itself, we must not try to update tuples in it.
3813 * pg_index's indexes should always have these flags in their clean state,
3814 * so that won't happen.
3815 */
3817 {
3818 Relation pg_index;
3819 HeapTuple indexTuple;
3820 Form_pg_index indexForm;
3836 {
3846 /*
3847 * Invalidate the relcache for the table, so that after we commit
3848 * all sessions will refresh the table's index list. This ensures
3849 * that if anyone misses seeing the pg_index row during this
3850 * update, they'll refresh their list before attempting any update
3851 * on the table.
3852 */
3854 }
3857 }
3859 /* Log what we did */
3867 /* Roll back any GUC changes executed by index functions */
3870 /* Restore userid and security context */
3873 /* Close rels, but keep locks */
3879 }
3881 /*
3882 * reindex_relation - This routine is used to recreate all indexes
3883 * of a relation (and optionally its toast relation too, if any).
3884 *
3885 * "flags" is a bitmask that can include any combination of these bits:
3886 *
3887 * REINDEX_REL_PROCESS_TOAST: if true, process the toast table too (if any).
3888 *
3889 * REINDEX_REL_SUPPRESS_INDEX_USE: if true, the relation was just completely
3890 * rebuilt by an operation such as VACUUM FULL or CLUSTER, and therefore its
3891 * indexes are inconsistent with it. This makes things tricky if the relation
3892 * is a system catalog that we might consult during the reindexing. To deal
3893 * with that case, we mark all of the indexes as pending rebuild so that they
3894 * won't be trusted until rebuilt. The caller is required to call us *without*
3895 * having made the rebuilt table visible by doing CommandCounterIncrement;
3896 * we'll do CCI after having collected the index list. (This way we can still
3897 * use catalog indexes while collecting the list.)
3898 *
3899 * REINDEX_REL_CHECK_CONSTRAINTS: if true, recheck unique and exclusion
3900 * constraint conditions, else don't. To avoid deadlocks, VACUUM FULL or
3901 * CLUSTER on a system catalog must omit this flag. REINDEX should be used to
3902 * rebuild an index if constraint inconsistency is suspected. For optimal
3903 * performance, other callers should include the flag only after transforming
3904 * the data in a manner that risks a change in constraint validity.
3905 *
3906 * REINDEX_REL_FORCE_INDEXES_UNLOGGED: if true, set the persistence of the
3907 * rebuilt indexes to unlogged.
3908 *
3909 * REINDEX_REL_FORCE_INDEXES_PERMANENT: if true, set the persistence of the
3910 * rebuilt indexes to permanent.
3911 *
3912 * Returns true if any indexes were rebuilt (including toast table's index
3913 * when relevant). Note that a CommandCounterIncrement will occur after each
3914 * index rebuild.
3915 */
3916 bool
3919 {
3920 Relation rel;
3921 Oid toast_relid;
3928 /*
3929 * Open and lock the relation. ShareLock is sufficient since we only need
3930 * to prevent schema and data changes in it. The lock level used here
3931 * should match ReindexTable().
3932 */
3935 else
3938 /* if relation is gone, leave */
3942 /*
3943 * Partitioned tables should never get processed here, as they have no
3944 * physical storage.
3945 */
3953 /*
3954 * Get the list of index OIDs for this relation. (We trust the relcache
3955 * to get this with a sequential scan if ignoring system indexes.)
3956 */
3960 {
3961 /* Suppress use of all the indexes until they are rebuilt */
3964 /*
3965 * Make the new heap contents visible --- now things might be
3966 * inconsistent!
3967 */
3969 }
3971 /*
3972 * Reindex the toast table, if any, before the main table.
3973 *
3974 * This helps in cases where a corruption in the toast table's index would
3975 * otherwise error and stop REINDEX TABLE command when it tries to fetch a
3976 * toasted datum. This way. the toast table's index is rebuilt and fixed
3977 * before it is used for reindexing the main table.
3978 *
3979 * It is critical to call reindex_relation() *after* the call to
3980 * RelationGetIndexList() returning the list of indexes on the relation,
3981 * because reindex_relation() will call CommandCounterIncrement() after
3982 * every reindex_index(). See REINDEX_REL_SUPPRESS_INDEX_USE for more
3983 * details.
3984 */
3986 {
3987 /*
3988 * Note that this should fail if the toast relation is missing, so
3989 * reset REINDEXOPT_MISSING_OK. Even if a new tablespace is set for
3990 * the parent relation, the indexes on its toast table are not moved.
3991 * This rule is enforced by setting tablespaceOid to InvalidOid.
3992 */
3998 }
4000 /*
4001 * Compute persistence of indexes: same as that of owning rel, unless
4002 * caller specified otherwise.
4003 */
4008 else
4011 /* Reindex all the indexes. */
4014 {
4018 /*
4019 * Skip any invalid indexes on a TOAST table. These can only be
4020 * duplicate leftovers from a failed REINDEX CONCURRENTLY, and if
4021 * rebuilt it would not be possible to drop them anymore.
4022 */
4025 {
4032 /*
4033 * Remove this invalid toast index from the reindex pending list,
4034 * as it is skipped here due to the hard failure that would happen
4035 * in reindex_index(), should we try to process it.
4036 */
4040 }
4047 /* Index should no longer be in the pending list */
4050 /* Set index rebuild count */
4052 i);
4053 i++;
4054 }
4056 /*
4057 * Close rel, but continue to hold the lock.
4058 */
4064 }
4067 /* ----------------------------------------------------------------
4068 * System index reindexing support
4069 *
4070 * When we are busy reindexing a system index, this code provides support
4071 * for preventing catalog lookups from using that index. We also make use
4072 * of this to catch attempted uses of user indexes during reindexing of
4073 * those indexes. This information is propagated to parallel workers;
4074 * attempting to change it during a parallel operation is not permitted.
4075 * ----------------------------------------------------------------
4076 */
4083 /*
4084 * ReindexIsProcessingHeap
4085 * True if heap specified by OID is currently being reindexed.
4086 */
4087 bool
4089 {
4091 }
4093 /*
4094 * ReindexIsCurrentlyProcessingIndex
4095 * True if index specified by OID is currently being reindexed.
4096 */
4097 static bool
4099 {
4101 }
4103 /*
4104 * ReindexIsProcessingIndex
4105 * True if index specified by OID is currently being reindexed,
4106 * or should be treated as invalid because it is awaiting reindex.
4107 */
4108 bool
4110 {
4113 }
4115 /*
4116 * SetReindexProcessing
4117 * Set flag that specified heap/index are being reindexed.
4118 */
4119 static void
4121 {
4123 /* Reindexing is not re-entrant. */
4128 /* Index is no longer "pending" reindex. */
4130 /* This may have been set already, but in case it isn't, do so now. */
4132 }
4134 /*
4135 * ResetReindexProcessing
4136 * Unset reindexing status.
4137 */
4138 static void
4140 {
4143 /* reindexingNestLevel remains set till end of (sub)transaction */
4144 }
4146 /*
4147 * SetReindexPending
4148 * Mark the given indexes as pending reindex.
4149 *
4150 * NB: we assume that the current memory context stays valid throughout.
4151 */
4152 static void
4154 {
4155 /* Reindexing is not re-entrant. */
4162 }
4164 /*
4165 * RemoveReindexPending
4166 * Remove the given index from the pending list.
4167 */
4168 static void
4170 {
4174 indexOid);
4175 }
4177 /*
4178 * ResetReindexState
4179 * Clear all reindexing state during (sub)transaction abort.
4180 */
4181 void
4183 {
4184 /*
4185 * Because reindexing is not re-entrant, we don't need to cope with nested
4186 * reindexing states. We just need to avoid messing up the outer-level
4187 * state in case a subtransaction fails within a REINDEX. So checking the
4188 * current nest level against that of the reindex operation is sufficient.
4189 */
4191 {
4195 /*
4196 * We needn't try to release the contents of pendingReindexedIndexes;
4197 * that list should be in a transaction-lifespan context, so it will
4198 * go away automatically.
4199 */
4203 }
4204 }
4206 /*
4207 * EstimateReindexStateSpace
4208 * Estimate space needed to pass reindex state to parallel workers.
4209 */
4210 Size
4212 {
4215 }
4217 /*
4218 * SerializeReindexState
4219 * Serialize reindex state for parallel workers.
4220 */
4221 void
4223 {
4233 }
4235 /*
4236 * RestoreReindexState
4237 * Restore reindex state in a parallel worker.
4238 */
4239 void
4241 {
4244 MemoryContext oldcontext;
4252 pendingReindexedIndexes =
4257 /* Note the worker has its own transaction nesting level */
4259 }