| blob | e5cf1bde13feb58d7d77296bd1eb9df8173057b0 |
1 /*-------------------------------------------------------------------------
2 *
3 * indexcmds.c
4 * POSTGRES define and remove index code.
5 *
6 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/commands/indexcmds.c
12 *
13 *-------------------------------------------------------------------------
14 */
70 /* non-export function prototypes */
80 Oid relId,
107 /*
108 * callback argument type for RangeVarCallbackForReindexIndex()
109 */
110 struct ReindexIndexCallbackState
111 {
114 };
116 /*
117 * callback arguments for reindex_error_callback()
118 */
120 {
126 /*
127 * CheckIndexCompatible
128 * Determine whether an existing index definition is compatible with a
129 * prospective index definition, such that the existing index storage
130 * could become the storage of the new index, avoiding a rebuild.
131 *
132 * 'heapRelation': the relation the index would apply to.
133 * 'accessMethodName': name of the AM to use.
134 * 'attributeList': a list of IndexElem specifying columns and expressions
135 * to index on.
136 * 'exclusionOpNames': list of names of exclusion-constraint operators,
137 * or NIL if not an exclusion constraint.
138 *
139 * This is tailored to the needs of ALTER TABLE ALTER TYPE, which recreates
140 * any indexes that depended on a changing column from their pg_get_indexdef
141 * or pg_get_constraintdef definitions. We omit some of the sanity checks of
142 * DefineIndex. We assume that the old and new indexes have the same number
143 * of columns and that if one has an expression column or predicate, both do.
144 * Errors arising from the attribute list still apply.
145 *
146 * Most column type changes that can skip a table rewrite do not invalidate
147 * indexes. We acknowledge this when all operator classes, collations and
148 * exclusion operators match. Though we could further permit intra-opfamily
149 * changes for btree and hash indexes, that adds subtle complexity with no
150 * concrete benefit for core types. Note, that INCLUDE columns aren't
151 * checked by this function, for them it's enough that table rewrite is
152 * skipped.
153 *
154 * When a comparison or exclusion operator has a polymorphic input type, the
155 * actual input types must also match. This defends against the possibility
156 * that operators could vary behavior in response to get_fn_expr_argtype().
157 * At present, this hazard is theoretical: check_exclusion_constraint() and
158 * all core index access methods decline to set fn_expr for such calls.
159 *
160 * We do not yet implement a test to verify compatibility of expression
161 * columns or predicates, so assume any such index is incompatible.
162 */
163 bool
168 {
173 Oid accessMethodId;
174 Oid relationId;
175 HeapTuple tuple;
176 Form_pg_index indexForm;
177 Form_pg_am accessMethodForm;
188 Relation irel;
190 Datum d;
192 /* Caller should already have the relation locked in some way. */
195 /*
196 * We can pretend isconstraint = false unconditionally. It only serves to
197 * decide the text of an error message that should never happen for us.
198 */
205 /* look up the access method */
211 accessMethodName)));
219 /*
220 * Compute the operator classes, collations, and exclusion operators for
221 * the new index, so we can test whether it's compatible with the existing
222 * one. Note that ComputeIndexAttrs might fail here, but that's OK:
223 * DefineIndex would have called this function with the same arguments
224 * later on, and it would have failed then anyway. Our attributeList
225 * contains only key attributes, thus we're filling ii_NumIndexAttrs and
226 * ii_NumIndexKeyAttrs with same value.
227 */
242 /* Get the soon-obsolete pg_index tuple. */
248 /*
249 * We don't assess expressions or predicates; assume incompatibility.
250 * Also, if the index is invalid for any reason, treat it as incompatible.
251 */
255 {
258 }
260 /* Any change in operator class or collation breaks compatibility. */
282 /* For polymorphic opcintype, column type changes break compatibility. */
285 {
288 {
291 }
292 }
294 /* Any change in opclass options break compatibility. */
296 {
304 }
306 /* Any change in exclusion operator selections breaks compatibility. */
308 {
317 /* Require an exact input type match for polymorphic operators. */
319 {
321 {
322 Oid left,
323 right;
328 {
331 }
332 }
333 }
334 }
338 }
340 /*
341 * CompareOpclassOptions
342 *
343 * Compare per-column opclass options which are represented by arrays of text[]
344 * datums. Both elements of arrays and array themselves can be NULL.
345 */
346 static bool
348 {
355 {
360 {
363 else
365 }
369 /* Compare non-NULL text[] datums. */
372 }
375 }
377 /*
378 * WaitForOlderSnapshots
379 *
380 * Wait for transactions that might have an older snapshot than the given xmin
381 * limit, because it might not contain tuples deleted just before it has
382 * been taken. Obtain a list of VXIDs of such transactions, and wait for them
383 * individually. This is used when building an index concurrently.
384 *
385 * We can exclude any running transactions that have xmin > the xmin given;
386 * their oldest snapshot must be newer than our xmin limit.
387 * We can also exclude any transactions that have xmin = zero, since they
388 * evidently have no live snapshot at all (and any one they might be in
389 * process of taking is certainly newer than ours). Transactions in other
390 * DBs can be ignored too, since they'll never even be able to see the
391 * index being worked on.
392 *
393 * We can also exclude autovacuum processes and processes running manual
394 * lazy VACUUMs, because they won't be fazed by missing index entries
395 * either. (Manual ANALYZEs, however, can't be excluded because they
396 * might be within transactions that are going to do arbitrary operations
397 * later.) Processes running CREATE INDEX CONCURRENTLY or REINDEX CONCURRENTLY
398 * on indexes that are neither expressional nor partial are also safe to
399 * ignore, since we know that those processes won't examine any data
400 * outside the table they're indexing.
401 *
402 * Also, GetCurrentVirtualXIDs never reports our own vxid, so we need not
403 * check for that.
404 *
405 * If a process goes idle-in-transaction with xmin zero, we do not need to
406 * wait for it anymore, per the above argument. We do not have the
407 * infrastructure right now to stop waiting if that happens, but we can at
408 * least avoid the folly of waiting when it is idle at the time we would
409 * begin to wait. We do this by repeatedly rechecking the output of
410 * GetCurrentVirtualXIDs. If, during any iteration, a particular vxid
411 * doesn't show up in the output, we know we can forget about it.
412 */
413 void
415 {
421 PROC_IS_AUTOVACUUM | PROC_IN_VACUUM
428 {
433 {
434 /* see if anything's changed ... */
442 PROC_IS_AUTOVACUUM | PROC_IN_VACUUM
446 {
450 {
454 }
457 }
459 }
462 {
463 /* If requested, publish who we're going to wait for. */
465 {
471 }
473 }
477 }
478 }
481 /*
482 * DefineIndex
483 * Creates a new index.
484 *
485 * 'relationId': the OID of the heap relation on which the index is to be
486 * created
487 * 'stmt': IndexStmt describing the properties of the new index.
488 * 'indexRelationId': normally InvalidOid, but during bootstrap can be
489 * nonzero to specify a preselected OID for the index.
490 * 'parentIndexId': the OID of the parent index; InvalidOid if not the child
491 * of a partitioned index.
492 * 'parentConstraintId': the OID of the parent constraint; InvalidOid if not
493 * the child of a constraint (only used when recursing)
494 * 'is_alter_table': this is due to an ALTER rather than a CREATE operation.
495 * 'check_rights': check for CREATE rights in namespace and tablespace. (This
496 * should be true except when ALTER is deleting/recreating an index.)
497 * 'check_not_in_use': check for table not already in use in current session.
498 * This should be true unless caller is holding the table open, in which
499 * case the caller had better have checked it earlier.
500 * 'skip_build': make the catalog entries but don't create the index files
501 * 'quiet': suppress the NOTICE chatter ordinarily provided for constraints.
502 *
503 * Returns the object address of the created index.
504 */
505 ObjectAddress
508 Oid indexRelationId,
509 Oid parentIndexId,
510 Oid parentConstraintId,
516 {
523 Oid accessMethodId;
524 Oid namespaceId;
525 Oid tablespaceId;
529 Relation rel;
530 HeapTuple tuple;
531 Form_pg_am accessMethodForm;
534 amoptions_function amoptions;
537 Datum reloptions;
540 bits16 flags;
541 bits16 constr_flags;
544 TransactionId limitXmin;
545 ObjectAddress address;
546 LockRelId heaprelid;
547 LOCKTAG heaplocktag;
548 LOCKMODE lockmode;
549 Snapshot snapshot;
553 /*
554 * Some callers need us to run with an empty default_tablespace; this is a
555 * necessary hack to be able to reproduce catalog state accurately when
556 * recreating indexes after table-rewriting ALTER TABLE.
557 */
559 {
564 }
566 /*
567 * Force non-concurrent build on temporary relations, even if CONCURRENTLY
568 * was requested. Other backends can't access a temporary relation, so
569 * there's no harm in grabbing a stronger lock, and a non-concurrent DROP
570 * is more efficient. Do this before any use of the concurrent option is
571 * done.
572 */
575 else
578 /*
579 * Start progress report. If we're building a partition, this was already
580 * done.
581 */
583 {
585 relationId);
587 concurrent ?
588 PROGRESS_CREATEIDX_COMMAND_CREATE_CONCURRENTLY :
589 PROGRESS_CREATEIDX_COMMAND_CREATE);
590 }
592 /*
593 * No index OID to report yet
594 */
596 InvalidOid);
598 /*
599 * count key attributes in index
600 */
603 /*
604 * Calculate the new list of index columns including both key columns and
605 * INCLUDE columns. Later we can determine which of these are key
606 * columns, and which are just part of the INCLUDE list by checking the
607 * list position. A list item in a position less than ii_NumIndexKeyAttrs
608 * is part of the key columns, and anything equal to and over is part of
609 * the INCLUDE columns.
610 */
623 INDEX_MAX_KEYS)));
625 /*
626 * Only SELECT ... FOR UPDATE/SHARE are allowed while doing a standard
627 * index build; but for concurrent builds we allow INSERT/UPDATE/DELETE
628 * (but not VACUUM).
629 *
630 * NB: Caller is responsible for making sure that relationId refers to the
631 * relation on which the index should be built; except in bootstrap mode,
632 * this will typically require the caller to have already locked the
633 * relation. To avoid lock upgrade hazards, that lock should be at least
634 * as strong as the one we take here.
635 *
636 * NB: If the lock strength here ever changes, code that is run by
637 * parallel workers under the control of certain particular ambuild
638 * functions will need to be updated, too.
639 */
645 /* Ensure that it makes sense to index this kind of relation */
647 {
651 /* OK */
660 }
662 /*
663 * Establish behavior for partitioned tables, and verify sanity of
664 * parameters.
665 *
666 * We do not build an actual index in this case; we only create a few
667 * catalog entries. The actual indexes are built by recursing for each
668 * partition.
669 */
672 {
673 /*
674 * Note: we check 'stmt->concurrent' rather than 'concurrent', so that
675 * the error is thrown also for temporary tables. Seems better to be
676 * consistent, even though we could do it on temporary table because
677 * we're not actually doing it concurrently.
678 */
689 }
691 /*
692 * Don't try to CREATE INDEX on temp tables of other backends.
693 */
699 /*
700 * Unless our caller vouches for having checked this already, insist that
701 * the table not be in use by our own session, either. Otherwise we might
702 * fail to make entries in the new index (for instance, if an INSERT or
703 * UPDATE is in progress and has already made its list of target indexes).
704 */
708 /*
709 * Verify we (still) have CREATE rights in the rel's namespace.
710 * (Presumably we did when the rel was created, but maybe not anymore.)
711 * Skip check if caller doesn't want it. Also skip check if
712 * bootstrapping, since permissions machinery may not be working yet.
713 */
715 {
716 AclResult aclresult;
719 ACL_CREATE);
723 }
725 /*
726 * Select tablespace to use. If not specified, use default tablespace
727 * (which may in turn default to database's default).
728 */
730 {
736 }
737 else
738 {
740 partitioned);
741 /* note InvalidOid is OK in this case */
742 }
744 /* Check tablespace permissions */
747 {
748 AclResult aclresult;
751 ACL_CREATE);
755 }
757 /*
758 * Force shared indexes into the pg_global tablespace. This is a bit of a
759 * hack but seems simpler than marking them in the BKI commands. On the
760 * other hand, if it's not shared, don't allow it to be placed there.
761 */
769 /*
770 * Choose the index column names.
771 */
774 /*
775 * Select name for index if caller didn't specify
776 */
780 namespaceId,
781 indexColNames,
786 /*
787 * look up the access method, verify it can handle the requested features
788 */
792 {
793 /*
794 * Hack to provide more-or-less-transparent updating of old RTREE
795 * indexes to GiST: if RTREE is requested and not found, use GIST.
796 */
798 {
803 }
809 accessMethodName)));
810 }
816 accessMethodId);
822 accessMethodName)));
827 accessMethodName)));
832 accessMethodName)));
837 accessMethodName)));
845 /*
846 * Validate predicate, if given
847 */
851 /*
852 * Parse AM-specific options, convert to text array form, validate.
853 */
859 /*
860 * Prepare arguments for index_create, primarily an IndexInfo structure.
861 * Note that predicates must be in implicit-AND format. In a concurrent
862 * build, mark it not-ready-for-inserts.
863 */
865 numberOfKeyAttributes,
866 accessMethodId,
871 concurrent);
884 /*
885 * Extra checks when creating a PRIMARY KEY index.
886 */
890 /*
891 * If this table is partitioned and we're creating a unique index or a
892 * primary key, make sure that the partition key is a subset of the
893 * index's columns. Otherwise it would be possible to violate uniqueness
894 * by putting values that ought to be unique in different partitions.
895 *
896 * We could lift this limitation if we had global indexes, but those have
897 * their own problems, so this is a useful feature combination.
898 */
900 {
911 else
912 {
915 }
917 /*
918 * Verify that all the columns in the partition key appear in the
919 * unique key definition, with the same notion of equality.
920 */
922 {
925 Oid ptkey_eqop;
928 /*
929 * Identify the equality operator associated with this partkey
930 * column. For list and range partitioning, partkeys use btree
931 * operator classes; hash partitioning uses hash operator classes.
932 * (Keep this in sync with ComputePartitionAttrs!)
933 */
936 else
942 eq_strategy);
948 /*
949 * We'll need to be able to identify the equality operators
950 * associated with index columns, too. We know what to do with
951 * btree opclasses; if there are ever any other index types that
952 * support unique indexes, this logic will need extension.
953 */
956 else
960 accessMethodName)));
962 /*
963 * It may be possible to support UNIQUE constraints when partition
964 * keys are expressions, but is it worth it? Give up for now.
965 */
970 constraint_type),
972 constraint_type)));
974 /* Search the index column(s) for a match */
976 {
978 {
979 /* Matched the column, now what about the equality op? */
980 Oid idx_opfamily;
981 Oid idx_opcintype;
986 {
987 Oid idx_eqop;
990 idx_opcintype,
991 idx_opcintype,
992 eq_strategy);
994 {
997 }
998 }
999 }
1000 }
1003 {
1004 Form_pg_attribute att;
1011 errdetail("%s constraint on table \"%s\" lacks column \"%s\" which is part of the partition key.",
1014 }
1015 }
1016 }
1019 /*
1020 * We disallow indexes on system columns. They would not necessarily get
1021 * updated correctly, and they don't seem useful anyway.
1022 */
1024 {
1031 }
1033 /*
1034 * Also check for system columns used in expressions or predicates.
1035 */
1037 {
1044 {
1046 indexattrs))
1050 }
1051 }
1053 /* Is index safe for others to ignore? See set_indexsafe_procflags() */
1057 /*
1058 * Report index creation if appropriate (delay this till after most of the
1059 * error checks)
1060 */
1062 {
1071 else
1072 {
1075 }
1080 constraint_type,
1082 }
1084 /*
1085 * A valid stmt->oldNode implies that we already have a built form of the
1086 * index. The caller should also decline any index build.
1087 */
1090 /*
1091 * Make the catalog entries for the index, including constraints. This
1092 * step also actually builds the index, except if caller requested not to
1093 * or in concurrent mode, in which case it'll be done later, or doing a
1094 * partitioned index (because those don't have storage).
1095 */
1110 /*
1111 * If the table is partitioned, and recursion was declined but partitions
1112 * exist, mark the index as invalid.
1113 */
1115 {
1120 }
1127 indexRelationId =
1129 parentConstraintId,
1140 /*
1141 * Revert to original default_tablespace. Must do this before any return
1142 * from this function, but after index_create, so this is a good time.
1143 */
1148 {
1151 /* If this is the top-level index, we're done */
1156 }
1158 /* Add any requested comment */
1164 {
1165 PartitionDesc partdesc;
1167 /*
1168 * Unless caller specified to skip this step (via ONLY), process each
1169 * partition to make sure they all contain a corresponding index.
1170 *
1171 * If we're called internally (no stmt->relation), recurse always.
1172 */
1175 {
1179 TupleDesc parentDesc;
1183 nparts);
1192 /*
1193 * For each partition, scan all existing indexes; if one matches
1194 * our index definition and is not already attached to some other
1195 * parent index, attach it to the one we just created.
1196 *
1197 * If none matches, build a new index by calling ourselves
1198 * recursively with the same options (except for the index name).
1199 */
1201 {
1203 Relation childrel;
1211 /*
1212 * Don't try to create indexes on foreign tables, though. Skip
1213 * those if a regular index, or fail if trying to create a
1214 * constraint index.
1215 */
1217 {
1228 }
1231 attmap =
1233 parentDesc);
1236 {
1238 Relation cldidx;
1241 /* this index is already partition of another one */
1249 collationObjectId,
1251 opfamOids,
1252 attmap))
1253 {
1256 /*
1257 * Found a match.
1258 *
1259 * If this index is being created in the parent
1260 * because of a constraint, then the child needs to
1261 * have a constraint also, so look for one. If there
1262 * is no such constraint, this index is no good, so
1263 * keep looking.
1264 */
1266 {
1267 cldConstrOid =
1269 cldidxid);
1271 {
1274 }
1275 }
1277 /* Attach index to parent and we're done. */
1281 createdConstraintId,
1282 childRelid);
1288 /* keep lock till commit */
1291 }
1294 }
1299 /*
1300 * If no matching index was found, create our own.
1301 */
1303 {
1308 /*
1309 * We can't use the same index name for the child index,
1310 * so clear idxname to let the recursive invocation choose
1311 * a new name. Likewise, the existing target relation
1312 * field is wrong, and if indexOid or oldNode are set,
1313 * they mustn't be applied to the child either.
1314 */
1322 /*
1323 * Adjust any Vars (both in expressions and in the index's
1324 * WHERE clause) to match the partition's column numbering
1325 * in case it's different from the parent's.
1326 */
1328 {
1331 /*
1332 * If the index parameter is an expression, we must
1333 * translate it to contain child Vars.
1334 */
1336 {
1340 InvalidOid,
1344 }
1345 }
1348 attmap,
1356 createdConstraintId,
1359 }
1364 }
1366 /*
1367 * The pg_index row we inserted for this index was marked
1368 * indisvalid=true. But if we attached an existing index that is
1369 * invalid, this is incorrect, so update our row to invalid too.
1370 */
1372 {
1374 HeapTuple tup,
1375 newtup;
1381 indexRelationId);
1388 }
1389 }
1391 /*
1392 * Indexes on partitioned tables are not themselves built, so we're
1393 * done here.
1394 */
1399 }
1402 {
1403 /* Close the heap and we're done, in the non-concurrent case */
1406 /* If this is the top-level index, we're done. */
1411 }
1413 /* save lockrelid and locktag for below, then close rel */
1418 /*
1419 * For a concurrent build, it's important to make the catalog entries
1420 * visible to other transactions before we start to build the index. That
1421 * will prevent them from making incompatible HOT updates. The new index
1422 * will be marked not indisready and not indisvalid, so that no one else
1423 * tries to either insert into it or use it for queries.
1424 *
1425 * We must commit our current transaction so that the index becomes
1426 * visible; then start another. Note that all the data structures we just
1427 * built are lost in the commit. The only data we keep past here are the
1428 * relation IDs.
1429 *
1430 * Before committing, get a session-level lock on the table, to ensure
1431 * that neither it nor the index can be dropped before we finish. This
1432 * cannot block, even if someone else is waiting for access, because we
1433 * already have the same lock within our transaction.
1434 *
1435 * Note: we don't currently bother with a session lock on the index,
1436 * because there are no operations that could change its state while we
1437 * hold lock on the parent table. This might need to change later.
1438 */
1445 /* Tell concurrent index builds to ignore us, if index qualifies */
1449 /*
1450 * The index is now visible, so we can report the OID. While on it,
1451 * include the report for the beginning of phase 2.
1452 */
1453 {
1455 PROGRESS_CREATEIDX_INDEX_OID,
1456 PROGRESS_CREATEIDX_PHASE
1457 };
1459 indexRelationId,
1460 PROGRESS_CREATEIDX_PHASE_WAIT_1
1461 };
1464 }
1466 /*
1467 * Phase 2 of concurrent index build (see comments for validate_index()
1468 * for an overview of how this works)
1469 *
1470 * Now we must wait until no running transaction could have the table open
1471 * with the old list of indexes. Use ShareLock to consider running
1472 * transactions that hold locks that permit writing to the table. Note we
1473 * do not need to worry about xacts that open the table for writing after
1474 * this point; they will see the new index when they open it.
1475 *
1476 * Note: the reason we use actual lock acquisition here, rather than just
1477 * checking the ProcArray and sleeping, is that deadlock is possible if
1478 * one of the transactions in question is blocked trying to acquire an
1479 * exclusive lock on our table. The lock code will detect deadlock and
1480 * error out properly.
1481 */
1484 /*
1485 * At this moment we are sure that there are no transactions with the
1486 * table open for write that don't have this new index in their list of
1487 * indexes. We have waited out all the existing transactions and any new
1488 * transaction will have the new index in its list, but the index is still
1489 * marked as "not-ready-for-inserts". The index is consulted while
1490 * deciding HOT-safety though. This arrangement ensures that no new HOT
1491 * chains can be created where the new tuple and the old tuple in the
1492 * chain have different index keys.
1493 *
1494 * We now take a new snapshot, and build the index using all tuples that
1495 * are visible in this snapshot. We can be sure that any HOT updates to
1496 * these tuples will be compatible with the index, since any updates made
1497 * by transactions that didn't know about the index are now committed or
1498 * rolled back. Thus, each visible tuple is either the end of its
1499 * HOT-chain or the extension of the chain is HOT-safe for this index.
1500 */
1502 /* Set ActiveSnapshot since functions in the indexes may need it */
1505 /* Perform concurrent build of index */
1508 /* we can do away with our snapshot */
1511 /*
1512 * Commit this transaction to make the indisready update visible.
1513 */
1517 /* Tell concurrent index builds to ignore us, if index qualifies */
1521 /*
1522 * Phase 3 of concurrent index build
1523 *
1524 * We once again wait until no transaction can have the table open with
1525 * the index marked as read-only for updates.
1526 */
1528 PROGRESS_CREATEIDX_PHASE_WAIT_2);
1531 /*
1532 * Now take the "reference snapshot" that will be used by validate_index()
1533 * to filter candidate tuples. Beware! There might still be snapshots in
1534 * use that treat some transaction as in-progress that our reference
1535 * snapshot treats as committed. If such a recently-committed transaction
1536 * deleted tuples in the table, we will not include them in the index; yet
1537 * those transactions which see the deleting one as still-in-progress will
1538 * expect such tuples to be there once we mark the index as valid.
1539 *
1540 * We solve this by waiting for all endangered transactions to exit before
1541 * we mark the index as valid.
1542 *
1543 * We also set ActiveSnapshot to this snap, since functions in indexes may
1544 * need a snapshot.
1545 */
1549 /*
1550 * Scan the index and the heap, insert any missing index entries.
1551 */
1554 /*
1555 * Drop the reference snapshot. We must do this before waiting out other
1556 * snapshot holders, else we will deadlock against other processes also
1557 * doing CREATE INDEX CONCURRENTLY, which would see our snapshot as one
1558 * they must wait for. But first, save the snapshot's xmin to use as
1559 * limitXmin for GetCurrentVirtualXIDs().
1560 */
1566 /*
1567 * The snapshot subsystem could still contain registered snapshots that
1568 * are holding back our process's advertised xmin; in particular, if
1569 * default_transaction_isolation = serializable, there is a transaction
1570 * snapshot that is still active. The CatalogSnapshot is likewise a
1571 * hazard. To ensure no deadlocks, we must commit and start yet another
1572 * transaction, and do our wait before any snapshot has been taken in it.
1573 */
1577 /* Tell concurrent index builds to ignore us, if index qualifies */
1581 /* We should now definitely not be advertising any xmin. */
1584 /*
1585 * The index is now valid in the sense that it contains all currently
1586 * interesting tuples. But since it might not contain tuples deleted just
1587 * before the reference snap was taken, we have to wait out any
1588 * transactions that might have older snapshots.
1589 */
1591 PROGRESS_CREATEIDX_PHASE_WAIT_3);
1594 /*
1595 * Index can now be marked valid -- update its pg_index entry
1596 */
1599 /*
1600 * The pg_index update will cause backends (including this one) to update
1601 * relcache entries for the index itself, but we should also send a
1602 * relcache inval on the parent table to force replanning of cached plans.
1603 * Otherwise existing sessions might fail to use the new index where it
1604 * would be useful. (Note that our earlier commits did not create reasons
1605 * to replan; so relcache flush on the index itself was sufficient.)
1606 */
1609 /*
1610 * Last thing to do is release the session-level lock on the parent table.
1611 */
1617 }
1620 /*
1621 * CheckMutability
1622 * Test whether given expression is mutable
1623 */
1624 static bool
1626 {
1627 /*
1628 * First run the expression through the planner. This has a couple of
1629 * important consequences. First, function default arguments will get
1630 * inserted, which may affect volatility (consider "default now()").
1631 * Second, inline-able functions will get inlined, which may allow us to
1632 * conclude that the function is really less volatile than it's marked. As
1633 * an example, polymorphic functions must be marked with the most volatile
1634 * behavior that they have for any input type, but once we inline the
1635 * function we may be able to conclude that it's not so volatile for the
1636 * particular input type we're dealing with.
1637 *
1638 * We assume here that expression_planner() won't scribble on its input.
1639 */
1642 /* Now we can search for non-immutable functions */
1644 }
1647 /*
1648 * CheckPredicate
1649 * Checks that the given partial-index predicate is valid.
1650 *
1651 * This used to also constrain the form of the predicate to forms that
1652 * indxpath.c could do something with. However, that seems overly
1653 * restrictive. One useful application of partial indexes is to apply
1654 * a UNIQUE constraint across a subset of a table, and in that scenario
1655 * any evaluable predicate will work. So accept any predicate here
1656 * (except ones requiring a plan), and let indxpath.c fend for itself.
1657 */
1658 static void
1660 {
1661 /*
1662 * transformExpr() should have already rejected subqueries, aggregates,
1663 * and window functions, based on the EXPR_KIND_ for a predicate.
1664 */
1666 /*
1667 * A predicate using mutable functions is probably wrong, for the same
1668 * reasons that we don't allow an index expression to use one.
1669 */
1674 }
1676 /*
1677 * Compute per-index-column information, including indexed column numbers
1678 * or index expressions, opclasses and their options. Note, all output vectors
1679 * should be allocated for all columns, including "including" ones.
1680 */
1681 static void
1689 Oid relId,
1691 Oid accessMethodId,
1694 {
1700 /* Allocate space for exclusion operator info, if needed */
1702 {
1708 }
1709 else
1712 /*
1713 * process attributeList
1714 */
1717 {
1719 Oid atttype;
1720 Oid attcollation;
1722 /*
1723 * Process the column-or-expression to be indexed.
1724 */
1726 {
1727 /* Simple index attribute */
1728 HeapTuple atttuple;
1729 Form_pg_attribute attform;
1734 {
1735 /* difference in error message spellings is historical */
1741 else
1746 }
1752 }
1753 else
1754 {
1755 /* Index expression */
1767 /*
1768 * Strip any top-level COLLATE clause. This ensures that we treat
1769 * "x COLLATE y" and "(x COLLATE y)" alike.
1770 */
1776 {
1777 /*
1778 * User wrote "(column)" or "(column COLLATE something)".
1779 * Treat it like simple attribute anyway.
1780 */
1782 }
1783 else
1784 {
1787 expr);
1789 /*
1790 * transformExpr() should have already rejected subqueries,
1791 * aggregates, and window functions, based on the EXPR_KIND_
1792 * for an index expression.
1793 */
1795 /*
1796 * An expression using mutable functions is probably wrong,
1797 * since if you aren't going to get the same result for the
1798 * same data every time, it's not clear what the index entries
1799 * mean at all.
1800 */
1805 }
1806 }
1810 /*
1811 * Included columns have no collation, no opclass and no ordering
1812 * options.
1813 */
1815 {
1836 attn++;
1839 }
1841 /*
1842 * Apply collation override if any
1843 */
1847 /*
1848 * Check we have a collation iff it's a collatable type. The only
1849 * expected failures here are (1) COLLATE applied to a noncollatable
1850 * type, or (2) index expression had an unresolved collation. But we
1851 * might as well code this to be a complete consistency check.
1852 */
1854 {
1860 }
1861 else
1862 {
1868 }
1872 /*
1873 * Identify the opclass to use.
1874 */
1876 atttype,
1877 accessMethodName,
1878 accessMethodId);
1880 /*
1881 * Identify the exclusion operator, if any.
1882 */
1884 {
1886 Oid opid;
1887 Oid opfamily;
1890 /*
1891 * Find the operator --- it must accept the column datatype
1892 * without runtime coercion (but binary compatibility is OK)
1893 */
1896 /*
1897 * Only allow commutative operators to be used in exclusion
1898 * constraints. If X conflicts with Y, but Y does not conflict
1899 * with X, bad things will happen.
1900 */
1908 /*
1909 * Operator must be a member of the right opfamily, too
1910 */
1914 {
1915 HeapTuple opftuple;
1916 Form_pg_opfamily opfform;
1918 /*
1919 * attribute->opclass might not explicitly name the opfamily,
1920 * so fetch the name of the selected opfamily for use in the
1921 * error message.
1922 */
1927 opfamily);
1935 errdetail("The exclusion operator must be related to the index operator class for the constraint.")));
1936 }
1942 }
1944 /*
1945 * Set up the per-column options (indoption field). For now, this is
1946 * zero for any un-ordered index, while ordered indexes have DESC and
1947 * NULLS FIRST/LAST options.
1948 */
1951 {
1952 /* default ordering is ASC */
1955 /* default null ordering is LAST for ASC, FIRST for DESC */
1957 {
1960 }
1963 }
1964 else
1965 {
1966 /* index AM does not support ordering */
1971 accessMethodName)));
1976 accessMethodName)));
1977 }
1979 /* Set up the per-column opclass options (attoptions field). */
1981 {
1991 }
1993 attn++;
1994 }
1995 }
1997 /*
1998 * Resolve possibly-defaulted operator class specification
1999 *
2000 * Note: This is used to resolve operator class specifications in index and
2001 * partition key definitions.
2002 */
2003 Oid
2006 {
2009 HeapTuple tuple;
2010 Form_pg_opclass opform;
2011 Oid opClassId,
2012 opInputType;
2015 {
2016 /* no operator class specified, so find the default */
2023 errhint("You must specify an operator class for the index or define a default operator class for the data type.")));
2025 }
2027 /*
2028 * Specific opclass name given, so look up the opclass.
2029 */
2031 /* deconstruct the name list */
2035 {
2036 /* Look in specific schema only */
2037 Oid namespaceId;
2044 }
2045 else
2046 {
2047 /* Unqualified opclass name, so search the search path */
2055 }
2063 /*
2064 * Verify that the index operator class accepts this datatype. Note we
2065 * will accept binary compatibility.
2066 */
2080 }
2082 /*
2083 * GetDefaultOpClass
2084 *
2085 * Given the OIDs of a datatype and an access method, find the default
2086 * operator class, if any. Returns InvalidOid if there is none.
2087 */
2088 Oid
2090 {
2095 Relation rel;
2097 SysScanDesc scan;
2098 HeapTuple tup;
2099 TYPCATEGORY tcategory;
2101 /* If it's a domain, look at the base type instead */
2106 /*
2107 * We scan through all the opclasses available for the access method,
2108 * looking for one that is marked default and matches the target type
2109 * (either exactly or binary-compatibly, but prefer an exact match).
2110 *
2111 * We could find more than one binary-compatible match. If just one is
2112 * for a preferred type, use that one; otherwise we fail, forcing the user
2113 * to specify which one he wants. (The preferred-type special case is a
2114 * kluge for varchar: it's binary-compatible to both text and bpchar, so
2115 * we need a tiebreaker.) If we find more than one exact match, then
2116 * someone put bogus entries in pg_opclass.
2117 */
2121 Anum_pg_opclass_opcmethod,
2129 {
2132 /* ignore altogether if not a default opclass */
2136 {
2137 nexact++;
2139 }
2142 {
2144 {
2145 ncompatiblepreferred++;
2147 }
2149 {
2150 ncompatible++;
2152 }
2153 }
2154 }
2160 /* raise error if pg_opclass contains inconsistent data */
2173 }
2175 /*
2176 * makeObjectName()
2177 *
2178 * Create a name for an implicitly created index, sequence, constraint,
2179 * extended statistics, etc.
2180 *
2181 * The parameters are typically: the original table name, the original field
2182 * name, and a "type" string (such as "seq" or "pkey"). The field name
2183 * and/or type can be NULL if not relevant.
2184 *
2185 * The result is a palloc'd string.
2186 *
2187 * The basic result we want is "name1_name2_label", omitting "_name2" or
2188 * "_label" when those parameters are NULL. However, we must generate
2189 * a name with less than NAMEDATALEN characters! So, we truncate one or
2190 * both names if necessary to make a short-enough string. The label part
2191 * is never truncated (so it had better be reasonably short).
2192 *
2193 * The caller is responsible for checking uniqueness of the generated
2194 * name and retrying as needed; retrying will be done by altering the
2195 * "label" string (which is why we never truncate that part).
2196 */
2199 {
2209 {
2212 }
2213 else
2221 /*
2222 * If we must truncate, preferentially truncate the longer name. This
2223 * logic could be expressed without a loop, but it's simple and obvious as
2224 * a loop.
2225 */
2227 {
2229 name1chars--;
2230 else
2231 name2chars--;
2232 }
2238 /* Now construct the string using the chosen lengths */
2243 {
2247 }
2249 {
2252 }
2253 else
2257 }
2259 /*
2260 * Select a nonconflicting name for a new relation. This is ordinarily
2261 * used to choose index names (which is why it's here) but it can also
2262 * be used for sequences, or any autogenerated relation kind.
2263 *
2264 * name1, name2, and label are used the same way as for makeObjectName(),
2265 * except that the label can't be NULL; digits will be appended to the label
2266 * if needed to create a name that is unique within the specified namespace.
2267 *
2268 * If isconstraint is true, we also avoid choosing a name matching any
2269 * existing constraint in the same namespace. (This is stricter than what
2270 * Postgres itself requires, but the SQL standard says that constraint names
2271 * should be unique within schemas, so we follow that for autogenerated
2272 * constraint names.)
2273 *
2274 * Note: it is theoretically possible to get a collision anyway, if someone
2275 * else chooses the same name concurrently. This is fairly unlikely to be
2276 * a problem in practice, especially if one is holding an exclusive lock on
2277 * the relation identified by name1. However, if choosing multiple names
2278 * within a single command, you'd better create the new object and do
2279 * CommandCounterIncrement before choosing the next one!
2280 *
2281 * Returns a palloc'd string.
2282 */
2287 {
2292 /* try the unmodified label first */
2296 {
2300 {
2304 }
2306 /* found a conflict, so try a new name component */
2309 }
2312 }
2314 /*
2315 * Select the name to be used for an index.
2316 *
2317 * The argument list is pretty ad-hoc :-(
2318 */
2323 {
2327 {
2328 /* the primary key's name does not depend on the specific column(s) */
2330 NULL,
2332 namespaceId,
2334 }
2336 {
2340 namespaceId,
2342 }
2344 {
2348 namespaceId,
2350 }
2351 else
2352 {
2356 namespaceId,
2358 }
2361 }
2363 /*
2364 * Generate "name2" for a new index given the list of column names for it
2365 * (as produced by ChooseIndexColumnNames). This will be passed to
2366 * ChooseRelationName along with the parent table name and a suitable label.
2367 *
2368 * We know that less than NAMEDATALEN characters will actually be used,
2369 * so we can truncate the result once we've generated that many.
2370 *
2371 * XXX See also ChooseForeignKeyConstraintNameAddition and
2372 * ChooseExtendedStatisticNameAddition.
2373 */
2376 {
2383 {
2389 /*
2390 * At this point we have buflen <= NAMEDATALEN. name should be less
2391 * than NAMEDATALEN already, but use strlcpy for paranoia.
2392 */
2397 }
2399 }
2401 /*
2402 * Select the actual names to be used for the columns of an index, given the
2403 * list of IndexElems for the columns. This is mostly about ensuring the
2404 * names are unique so we don't get a conflicting-attribute-names error.
2405 *
2406 * Returns a List of plain strings (char *, not String nodes).
2407 */
2410 {
2415 {
2422 /* Get the preliminary name from the IndexElem */
2427 else
2430 /* If it conflicts with any previous column, tweak it */
2433 {
2439 {
2442 }
2448 /* Ensure generated names are shorter than NAMEDATALEN */
2454 }
2456 /* And attach to the result list */
2458 }
2460 }
2462 /*
2463 * ExecReindex
2464 *
2465 * Primary entry point for manual REINDEX commands. This is mainly a
2466 * preparation wrapper for the real operations that will happen in
2467 * each subroutine of REINDEX.
2468 */
2469 void
2471 {
2478 /* Parse option list */
2480 {
2489 else
2495 }
2505 /*
2506 * Assign the tablespace OID to move indexes to, with InvalidOid to do
2507 * nothing.
2508 */
2510 {
2513 /* Check permissions except when moving to database's default */
2516 {
2517 AclResult aclresult;
2524 }
2525 }
2526 else
2530 {
2541 /*
2542 * This cannot run inside a user transaction block; if we were
2543 * inside a transaction, then its commit- and
2544 * start-transaction-command calls would not have the intended
2545 * effect!
2546 */
2557 }
2558 }
2560 /*
2561 * ReindexIndex
2562 * Recreate a specific index.
2563 */
2564 static void
2566 {
2568 Oid indOid;
2572 /*
2573 * Find and lock index, and check permissions on table; use callback to
2574 * obtain lock on table first, to avoid deadlock hazard. The lock level
2575 * used here must match the index lock obtained in reindex_index().
2576 *
2577 * If it's a temporary index, we will perform a non-concurrent reindex,
2578 * even if CONCURRENTLY was requested. In that case, reindex_index() will
2579 * upgrade the lock, but that's OK, because other sessions can't hold
2580 * locks on our temporary table.
2581 */
2588 RangeVarCallbackForReindexIndex,
2591 /*
2592 * Obtain the current persistence and kind of the existing index. We
2593 * already hold a lock on the index.
2594 */
2603 else
2604 {
2609 }
2610 }
2612 /*
2613 * Check permissions on table before acquiring relation lock; also lock
2614 * the heap before the RangeVarGetRelidExtended takes the index lock, to avoid
2615 * deadlocks.
2616 */
2617 static void
2620 {
2623 LOCKMODE table_lockmode;
2625 /*
2626 * Lock level here should match table lock in reindex_index() for
2627 * non-concurrent case and table locks used by index_concurrently_*() for
2628 * concurrent case.
2629 */
2633 /*
2634 * If we previously locked some other index's heap, and the name we're
2635 * looking up no longer refers to that relation, release the now-useless
2636 * lock.
2637 */
2639 {
2642 }
2644 /* If the relation does not exist, there's nothing more to do. */
2648 /*
2649 * If the relation does exist, check whether it's an index. But note that
2650 * the relation might have been dropped between the time we did the name
2651 * lookup and now. In that case, there's nothing to do.
2652 */
2662 /* Check permissions */
2666 /* Lock heap before index to avoid deadlock. */
2668 {
2671 /*
2672 * If the OID isn't valid, it means the index was concurrently
2673 * dropped, which is not a problem for us; just return normally.
2674 */
2676 {
2679 }
2680 }
2681 }
2683 /*
2684 * ReindexTable
2685 * Recreate all indexes of a table (and of its toast table, if any)
2686 */
2687 static Oid
2689 {
2690 Oid heapOid;
2693 /*
2694 * The lock level used here should match reindex_relation().
2695 *
2696 * If it's a temporary table, we will perform a non-concurrent reindex,
2697 * even if CONCURRENTLY was requested. In that case, reindex_relation()
2698 * will upgrade the lock, but that's OK, because other sessions can't hold
2699 * locks on our temporary table.
2700 */
2711 {
2718 }
2719 else
2720 {
2725 REINDEX_REL_PROCESS_TOAST |
2726 REINDEX_REL_CHECK_CONSTRAINTS,
2732 }
2735 }
2737 /*
2738 * ReindexMultipleTables
2739 * Recreate indexes of tables selected by objectName/objectKind.
2740 *
2741 * To reduce the probability of deadlocks, each table is reindexed in a
2742 * separate transaction, so we can release the lock on it right away.
2743 * That means this must not be called within a user transaction block!
2744 */
2745 static void
2748 {
2749 Oid objectOid;
2750 Relation relationRelation;
2751 TableScanDesc scan;
2753 HeapTuple tuple;
2754 MemoryContext private_context;
2755 MemoryContext old;
2772 /*
2773 * Get OID of object to reindex, being the database currently being used
2774 * by session for a database or for system catalogs, or the schema defined
2775 * by caller. At the same time do permission checks that need different
2776 * processing depending on the object type.
2777 */
2779 {
2784 objectName);
2785 }
2786 else
2787 {
2796 objectName);
2797 }
2799 /*
2800 * Create a memory context that will survive forced transaction commits we
2801 * do below. Since it is a child of PortalContext, it will go away
2802 * eventually even if we suffer an error; there's no need for special
2803 * abort cleanup logic.
2804 */
2807 ALLOCSET_SMALL_SIZES);
2809 /*
2810 * Define the search keys to find the objects to reindex. For a schema, we
2811 * select target relations using relnamespace, something not necessary for
2812 * a database-wide operation.
2813 */
2815 {
2818 Anum_pg_class_relnamespace,
2821 }
2822 else
2825 /*
2826 * Scan pg_class to build a list of the relations we need to reindex.
2827 *
2828 * We only consider plain relations and materialized views here (toast
2829 * rels will be processed indirectly by reindex_relation).
2830 */
2834 {
2838 /*
2839 * Only regular tables and matviews can have indexes, so ignore any
2840 * other kind of relation.
2841 *
2842 * Partitioned tables/indexes are skipped but matching leaf partitions
2843 * are processed.
2844 */
2849 /* Skip temp tables of other backends; we can't reindex them at all */
2854 /* Check user/system classification, and optionally skip */
2859 /*
2860 * The table can be reindexed if the user is superuser, the table
2861 * owner, or the database/schema owner (but in the latter case, only
2862 * if it's not a shared relation). pg_class_ownercheck includes the
2863 * superuser case, and depending on objectKind we already know that
2864 * the user has permission to run REINDEX on this database or schema
2865 * per the permission checks at the beginning of this routine.
2866 */
2871 /*
2872 * Skip system tables, since index_create() would reject indexing them
2873 * concurrently (and it would likely fail if we tried).
2874 */
2877 {
2884 }
2886 /*
2887 * If a new tablespace is set, check if this relation has to be
2888 * skipped.
2889 */
2891 {
2894 /*
2895 * Mapped relations cannot be moved to different tablespaces (in
2896 * particular this eliminates all shared catalogs.).
2897 */
2902 /*
2903 * A system relation is always skipped, even with
2904 * allow_system_table_mods enabled.
2905 */
2910 {
2917 }
2918 }
2920 /* Save the list of relation OIDs in private context */
2923 /*
2924 * We always want to reindex pg_class first if it's selected to be
2925 * reindexed. This ensures that if there is any corruption in
2926 * pg_class' indexes, they will be fixed before we process any other
2927 * tables. This is critical because reindexing itself will try to
2928 * update pg_class.
2929 */
2932 else
2936 }
2940 /*
2941 * Process each relation listed in a separate transaction. Note that this
2942 * commits and then starts a new transaction immediately.
2943 */
2947 }
2949 /*
2950 * Error callback specific to ReindexPartitions().
2951 */
2952 static void
2954 {
2965 }
2967 /*
2968 * ReindexPartitions
2969 *
2970 * Reindex a set of partitions, per the partitioned index or table given
2971 * by the caller.
2972 */
2973 static void
2975 {
2980 MemoryContext reindex_context;
2983 ErrorContextCallback errcallback;
2984 ReindexErrorInfo errinfo;
2988 /*
2989 * Check if this runs in a transaction block, with an error callback to
2990 * provide more context under which a problem happens.
2991 */
3004 /* Pop the error context stack */
3007 /*
3008 * Create special memory context for cross-transaction storage.
3009 *
3010 * Since it is a child of PortalContext, it will go away eventually even
3011 * if we suffer an error so there is no need for special abort cleanup
3012 * logic.
3013 */
3015 ALLOCSET_DEFAULT_SIZES);
3017 /* ShareLock is enough to prevent schema modifications */
3020 /*
3021 * The list of relations to reindex are the physical partitions of the
3022 * tree so discard any partitioned table or index.
3023 */
3025 {
3028 MemoryContext old_context;
3030 /*
3031 * This discards partitioned tables, partitioned indexes and foreign
3032 * tables.
3033 */
3040 /* Save partition OID */
3044 }
3046 /*
3047 * Process each partition listed in a separate transaction. Note that
3048 * this commits and then starts a new transaction immediately.
3049 */
3052 /*
3053 * Clean up working storage --- note we must do this after
3054 * StartTransactionCommand, else we might be trying to delete the active
3055 * context!
3056 */
3058 }
3060 /*
3061 * ReindexMultipleInternal
3062 *
3063 * Reindex a list of relations, each one being processed in its own
3064 * transaction. This commits the existing transaction immediately,
3065 * and starts a new transaction when finished.
3066 */
3067 static void
3069 {
3076 {
3083 /* functions in indexes may want a snapshot set */
3086 /* check if the relation still exists */
3088 {
3092 }
3094 /*
3095 * Check permissions except when moving to database's default if a new
3096 * tablespace is chosen. Note that this check also happens in
3097 * ExecReindex(), but we do an extra check here as this runs across
3098 * multiple transactions.
3099 */
3102 {
3103 AclResult aclresult;
3110 }
3115 /*
3116 * Partitioned tables and indexes can never be processed directly, and
3117 * a list of their leaves should be built first.
3118 */
3123 {
3128 /* ReindexRelationConcurrently() does the verbose output */
3129 }
3131 {
3138 /* reindex_index() does the verbose output */
3139 }
3140 else
3141 {
3148 REINDEX_REL_PROCESS_TOAST |
3149 REINDEX_REL_CHECK_CONSTRAINTS,
3159 }
3162 }
3165 }
3168 /*
3169 * ReindexRelationConcurrently - process REINDEX CONCURRENTLY for given
3170 * relation OID
3171 *
3172 * 'relationOid' can either belong to an index, a table or a materialized
3173 * view. For tables and materialized views, all its indexes will be rebuilt,
3174 * excluding invalid indexes and any indexes used in exclusion constraints,
3175 * but including its associated toast table indexes. For indexes, the index
3176 * itself will be rebuilt.
3177 *
3178 * The locks taken on parent tables and involved indexes are kept until the
3179 * transaction is committed, at which point a session lock is taken on each
3180 * relation. Both of these protect against concurrent schema changes.
3181 *
3182 * Returns true if any indexes have been rebuilt (including toast table's
3183 * indexes, when relevant), otherwise returns false.
3184 *
3185 * NOTE: This cannot be used on temporary relations. A concurrent build would
3186 * cause issues with ON COMMIT actions triggered by the transactions of the
3187 * concurrent build. Temporary relations are not subject to concurrent
3188 * concerns, so there's no need for the more complicated concurrent build,
3189 * anyway, and a non-concurrent reindex is more efficient.
3190 */
3191 static bool
3193 {
3195 {
3196 Oid indexId;
3197 Oid tableId;
3198 Oid amId;
3208 MemoryContext private_context;
3209 MemoryContext oldcontext;
3213 PGRUsage ru0;
3215 PROGRESS_CREATEIDX_COMMAND,
3216 PROGRESS_CREATEIDX_PHASE,
3217 PROGRESS_CREATEIDX_INDEX_OID,
3218 PROGRESS_CREATEIDX_ACCESS_METHOD_OID
3219 };
3222 /*
3223 * Create a memory context that will survive forced transaction commits we
3224 * do below. Since it is a child of PortalContext, it will go away
3225 * eventually even if we suffer an error; there's no need for special
3226 * abort cleanup logic.
3227 */
3230 ALLOCSET_SMALL_SIZES);
3233 {
3234 /* Save data needed by REINDEX VERBOSE in private context */
3243 }
3247 /*
3248 * Extract the list of indexes that are going to be rebuilt based on the
3249 * relation Oid given by caller.
3250 */
3252 {
3256 {
3257 /*
3258 * In the case of a relation, find all its indexes including
3259 * toast indexes.
3260 */
3261 Relation heapRelation;
3263 /* Save the list of relation OIDs in private context */
3266 /* Track this relation for session locks */
3276 /* Open relation to get its indexes */
3278 {
3280 ShareUpdateExclusiveLock);
3281 /* leave if relation does not exist */
3284 }
3285 else
3287 ShareUpdateExclusiveLock);
3296 /* Add all the valid indexes of relation to list */
3298 {
3301 ShareUpdateExclusiveLock);
3315 else
3316 {
3319 /* Save the list of relation OIDs in private context */
3324 /* other fields set later */
3329 }
3332 }
3334 /* Also add the toast indexes */
3336 {
3339 ShareUpdateExclusiveLock);
3341 /* Save the list of relation OIDs in private context */
3344 /* Track this relation for session locks */
3350 {
3353 ShareUpdateExclusiveLock);
3361 else
3362 {
3365 /*
3366 * Save the list of relation OIDs in private
3367 * context
3368 */
3374 /* other fields set later */
3377 }
3380 }
3383 }
3387 }
3389 {
3392 Relation heapRelation;
3395 /* if relation is missing, leave */
3404 /*
3405 * Don't allow reindex for an invalid index on TOAST table, as
3406 * if rebuilt it would not be possible to drop it. Match
3407 * error message in reindex_index().
3408 */
3415 /*
3416 * Check if parent relation can be locked and if it exists,
3417 * this needs to be done at this stage as the list of indexes
3418 * to rebuild is not complete yet, and REINDEXOPT_MISSING_OK
3419 * should not be used once all the session locks are taken.
3420 */
3422 {
3424 ShareUpdateExclusiveLock);
3425 /* leave if relation does not exist */
3428 }
3429 else
3431 ShareUpdateExclusiveLock);
3442 /* Save the list of relation OIDs in private context */
3445 /* Track the heap relation of this index for session locks */
3448 /*
3449 * Save the list of relation OIDs in private context. Note
3450 * that invalid indexes are allowed here.
3451 */
3455 /* other fields set later */
3459 }
3464 /* Return error if type of relation is not supported */
3469 }
3471 /*
3472 * Definitely no indexes, so leave. Any checks based on
3473 * REINDEXOPT_MISSING_OK should be done only while the list of indexes to
3474 * work on is built as the session locks taken before this transaction
3475 * commits will make sure that they cannot be dropped by a concurrent
3476 * session until this operation completes.
3477 */
3479 {
3482 }
3484 /* It's not a shared catalog, so refuse to move it to shared tablespace */
3493 /*-----
3494 * Now we have all the indexes we want to process in indexIds.
3495 *
3496 * The phases now are:
3497 *
3498 * 1. create new indexes in the catalog
3499 * 2. build new indexes
3500 * 3. let new indexes catch up with tuples inserted in the meantime
3501 * 4. swap index names
3502 * 5. mark old indexes as dead
3503 * 6. drop old indexes
3504 *
3505 * We process each phase for all indexes before moving to the next phase,
3506 * for efficiency.
3507 */
3509 /*
3510 * Phase 1 of REINDEX CONCURRENTLY
3511 *
3512 * Create a new index with the same properties as the old one, but it is
3513 * only registered in catalogs and will be built later. Then get session
3514 * locks on all involved tables. See analogous code in DefineIndex() for
3515 * more detailed comments.
3516 */
3519 {
3523 Oid newIndexId;
3524 Relation indexRel;
3525 Relation heapRel;
3526 Relation newIndexRel;
3528 Oid tablespaceid;
3532 ShareUpdateExclusiveLock);
3534 /* determine safety of this index for set_indexsafe_procflags */
3540 /* This function shouldn't be called for temporary relations. */
3553 /* Choose a temporary relation name for the new index */
3555 NULL,
3560 /* Choose the new tablespace, indexes of toast tables are not moved */
3564 else
3567 /* Create new index definition based on given index */
3570 tablespaceid,
3571 concurrentName);
3573 /*
3574 * Now open the relation of the new index, a session-level lock is
3575 * also needed on it.
3576 */
3579 /*
3580 * Save the list of OIDs and locks in private context
3581 */
3592 /*
3593 * Save lockrelid to protect each relation from drop then close
3594 * relations. The lockrelid on parent relation is not taken here to
3595 * avoid multiple locks taken on the same relation, instead we rely on
3596 * parentRelationIds built earlier.
3597 */
3610 }
3612 /*
3613 * Save the heap lock for following visibility checks with other backends
3614 * might conflict with this session.
3615 */
3617 {
3622 /* Save the list of locks in private context */
3625 /* Add lockrelid of heap relation to the list of locked relations */
3632 /* Save the LOCKTAG for this parent relation for the wait phase */
3638 /* Close heap relation */
3640 }
3642 /* Get a session-level lock on each table. */
3644 {
3648 }
3654 /*
3655 * Because we don't take a snapshot in this transaction, there's no need
3656 * to set the PROC_IN_SAFE_IC flag here.
3657 */
3659 /*
3660 * Phase 2 of REINDEX CONCURRENTLY
3661 *
3662 * Build the new indexes in a separate transaction for each index to avoid
3663 * having open transactions for an unnecessary long time. But before
3664 * doing that, wait until no running transactions could have the table of
3665 * the index open with the old list of indexes. See "phase 2" in
3666 * DefineIndex() for more details.
3667 */
3670 PROGRESS_CREATEIDX_PHASE_WAIT_1);
3675 {
3678 /* Start new transaction for this index's concurrent build */
3681 /*
3682 * Check for user-requested abort. This is inside a transaction so as
3683 * xact.c does not issue a useless WARNING, and ensures that
3684 * session-level locks are cleaned up on abort.
3685 */
3688 /* Tell concurrent indexing to ignore us, if index qualifies */
3692 /* Set ActiveSnapshot since functions in the indexes may need it */
3695 /*
3696 * Update progress for the index to build, with the correct parent
3697 * table involved.
3698 */
3706 /* Perform concurrent build of new index */
3711 }
3715 /*
3716 * Because we don't take a snapshot or Xid in this transaction, there's no
3717 * need to set the PROC_IN_SAFE_IC flag here.
3718 */
3720 /*
3721 * Phase 3 of REINDEX CONCURRENTLY
3722 *
3723 * During this phase the old indexes catch up with any new tuples that
3724 * were created during the previous phase. See "phase 3" in DefineIndex()
3725 * for more details.
3726 */
3729 PROGRESS_CREATEIDX_PHASE_WAIT_2);
3734 {
3736 TransactionId limitXmin;
3737 Snapshot snapshot;
3741 /*
3742 * Check for user-requested abort. This is inside a transaction so as
3743 * xact.c does not issue a useless WARNING, and ensures that
3744 * session-level locks are cleaned up on abort.
3745 */
3748 /* Tell concurrent indexing to ignore us, if index qualifies */
3752 /*
3753 * Take the "reference snapshot" that will be used by validate_index()
3754 * to filter candidate tuples.
3755 */
3759 /*
3760 * Update progress for the index to build, with the correct parent
3761 * table involved.
3762 */
3773 /*
3774 * We can now do away with our active snapshot, we still need to save
3775 * the xmin limit to wait for older snapshots.
3776 */
3782 /*
3783 * To ensure no deadlocks, we must commit and start yet another
3784 * transaction, and do our wait before any snapshot has been taken in
3785 * it.
3786 */
3790 /*
3791 * The index is now valid in the sense that it contains all currently
3792 * interesting tuples. But since it might not contain tuples deleted
3793 * just before the reference snap was taken, we have to wait out any
3794 * transactions that might have older snapshots.
3795 *
3796 * Because we don't take a snapshot or Xid in this transaction,
3797 * there's no need to set the PROC_IN_SAFE_IC flag here.
3798 */
3800 PROGRESS_CREATEIDX_PHASE_WAIT_3);
3804 }
3806 /*
3807 * Phase 4 of REINDEX CONCURRENTLY
3808 *
3809 * Now that the new indexes have been validated, swap each new index with
3810 * its corresponding old index.
3811 *
3812 * We mark the new indexes as valid and the old indexes as not valid at
3813 * the same time to make sure we only get constraint violations from the
3814 * indexes with the correct names.
3815 */
3819 /*
3820 * Because this transaction only does catalog manipulations and doesn't do
3821 * any index operations, we can set the PROC_IN_SAFE_IC flag here
3822 * unconditionally.
3823 */
3827 {
3832 /*
3833 * Check for user-requested abort. This is inside a transaction so as
3834 * xact.c does not issue a useless WARNING, and ensures that
3835 * session-level locks are cleaned up on abort.
3836 */
3839 /* Choose a relation name for old index */
3841 NULL,
3846 /*
3847 * Swap old index with the new one. This also marks the new one as
3848 * valid and the old one as not valid.
3849 */
3852 /*
3853 * Invalidate the relcache for the table, so that after this commit
3854 * all sessions will refresh any cached plans that might reference the
3855 * index.
3856 */
3859 /*
3860 * CCI here so that subsequent iterations see the oldName in the
3861 * catalog and can choose a nonconflicting name for their oldName.
3862 * Otherwise, this could lead to conflicts if a table has two indexes
3863 * whose names are equal for the first NAMEDATALEN-minus-a-few
3864 * characters.
3865 */
3867 }
3869 /* Commit this transaction and make index swaps visible */
3873 /*
3874 * While we could set PROC_IN_SAFE_IC if all indexes qualified, there's no
3875 * real need for that, because we only acquire an Xid after the wait is
3876 * done, and that lasts for a very short period.
3877 */
3879 /*
3880 * Phase 5 of REINDEX CONCURRENTLY
3881 *
3882 * Mark the old indexes as dead. First we must wait until no running
3883 * transaction could be using the index for a query. See also
3884 * index_drop() for more details.
3885 */
3888 PROGRESS_CREATEIDX_PHASE_WAIT_4);
3892 {
3895 /*
3896 * Check for user-requested abort. This is inside a transaction so as
3897 * xact.c does not issue a useless WARNING, and ensures that
3898 * session-level locks are cleaned up on abort.
3899 */
3903 }
3905 /* Commit this transaction to make the updates visible. */
3909 /*
3910 * While we could set PROC_IN_SAFE_IC if all indexes qualified, there's no
3911 * real need for that, because we only acquire an Xid after the wait is
3912 * done, and that lasts for a very short period.
3913 */
3915 /*
3916 * Phase 6 of REINDEX CONCURRENTLY
3917 *
3918 * Drop the old indexes.
3919 */
3922 PROGRESS_CREATEIDX_PHASE_WAIT_5);
3927 {
3931 {
3933 ObjectAddress object;
3940 }
3942 /*
3943 * Use PERFORM_DELETION_CONCURRENT_LOCK so that index_drop() uses the
3944 * right lock level.
3945 */
3948 }
3953 /*
3954 * Finally, release the session-level lock on the table.
3955 */
3957 {
3961 }
3963 /* Start a new transaction to finish process properly */
3966 /* Log what we did */
3968 {
3975 else
3976 {
3978 {
3986 /* Don't show rusage here, since it's not per index. */
3987 }
3994 }
3995 }
4002 }
4004 /*
4005 * Insert or delete an appropriate pg_inherits tuple to make the given index
4006 * be a partition of the indicated parent index.
4007 *
4008 * This also corrects the pg_depend information for the affected index.
4009 */
4010 void
4012 {
4013 Relation pg_inherits;
4015 SysScanDesc scan;
4017 HeapTuple tuple;
4020 /* Make sure this is an index */
4024 /*
4025 * Scan pg_inherits for rows linking our index to some parent.
4026 */
4029 Anum_pg_inherits_inhrelid,
4033 Anum_pg_inherits_inhseqno,
4041 {
4043 {
4044 /*
4045 * No pg_inherits row, and no parent wanted: nothing to do in this
4046 * case.
4047 */
4049 }
4050 else
4051 {
4054 }
4055 }
4056 else
4057 {
4061 {
4062 /*
4063 * There exists a pg_inherits row, which we want to clear; do so.
4064 */
4067 }
4068 else
4069 {
4070 /*
4071 * A pg_inherits row exists. If it's the same we want, then we're
4072 * good; if it differs, that amounts to a corrupt catalog and
4073 * should not happen.
4074 */
4076 {
4077 /* unexpected: we should not get called in this case */
4080 }
4082 /* already in the right state */
4084 }
4085 }
4087 /* done with pg_inherits */
4091 /* set relhassubclass if an index partition has been added to the parent */
4095 /* set relispartition correctly on the partition */
4099 {
4100 /*
4101 * Insert/delete pg_depend rows. If setting a parent, add PARTITION
4102 * dependencies on the parent index and the table; if removing a
4103 * parent, delete PARTITION dependencies.
4104 */
4106 {
4107 ObjectAddress partIdx;
4108 ObjectAddress parentIdx;
4109 ObjectAddress partitionTbl;
4116 DEPENDENCY_PARTITION_PRI);
4118 DEPENDENCY_PARTITION_SEC);
4119 }
4120 else
4121 {
4123 RelationRelationId,
4124 DEPENDENCY_PARTITION_PRI);
4126 RelationRelationId,
4127 DEPENDENCY_PARTITION_SEC);
4128 }
4130 /* make our updates visible */
4132 }
4133 }
4135 /*
4136 * Subroutine of IndexSetParentIndex to update the relispartition flag of the
4137 * given index to the given value.
4138 */
4139 static void
4141 {
4142 HeapTuple tup;
4143 Relation classRel;
4154 }
4156 /*
4157 * Set the PROC_IN_SAFE_IC flag in MyProc->statusFlags.
4158 *
4159 * When doing concurrent index builds, we can set this flag
4160 * to tell other processes concurrently running CREATE
4161 * INDEX CONCURRENTLY or REINDEX CONCURRENTLY to ignore us when
4162 * doing their waits for concurrent snapshots. On one hand it
4163 * avoids pointlessly waiting for a process that's not interesting
4164 * anyway; but more importantly it avoids deadlocks in some cases.
4165 *
4166 * This can be done safely only for indexes that don't execute any
4167 * expressions that could access other tables, so index must not be
4168 * expressional nor partial. Caller is responsible for only calling
4169 * this routine when that assumption holds true.
4170 *
4171 * (The flag is reset automatically at transaction end, so it must be
4172 * set for each transaction.)
4173 */
4176 {
4177 /*
4178 * This should only be called before installing xid or xmin in MyProc;
4179 * otherwise, concurrent processes could see an Xmin that moves backwards.
4180 */
4188 }