| blob | 259b4237a2430cc167429b6b484935da3fd9aca7 |
1 /*-------------------------------------------------------------------------
2 *
3 * tablecmds.c
4 * Commands for creating and altering table structures and settings
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/commands/tablecmds.c
12 *
13 *-------------------------------------------------------------------------
14 */
107 /*
108 * ON COMMIT action list
109 */
111 {
115 /*
116 * If this entry was created during the current transaction,
117 * creating_subid is the ID of the creating subxact; if created in a prior
118 * transaction, creating_subid is zero. If deleted during the current
119 * transaction, deleting_subid is the ID of the deleting subxact; if no
120 * deletion request is pending, deleting_subid is zero.
121 */
122 SubTransactionId creating_subid;
123 SubTransactionId deleting_subid;
129 /*
130 * State information for ALTER TABLE
131 *
132 * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
133 * structs, one for each table modified by the operation (the named table
134 * plus any child tables that are affected). We save lists of subcommands
135 * to apply to this table (possibly modified by parse transformation steps);
136 * these lists will be executed in Phase 2. If a Phase 3 step is needed,
137 * necessary information is stored in the constraints and newvals lists.
138 *
139 * Phase 2 is divided into multiple passes; subcommands are executed in
140 * a pass determined by subcommand type.
141 */
144 {
152 /* We could support a RENAME COLUMN pass here, but not currently used */
161 #define AT_NUM_PASSES (AT_PASS_MISC + 1)
164 {
165 /* Information saved before any work commences: */
170 /*
171 * Transiently set during Phase 2, normally set to NULL.
172 *
173 * ATRewriteCatalogs sets this when it starts, and closes when ATExecCmd
174 * returns control. This can be exploited by ATExecCmd subroutines to
175 * close/reopen across transaction boundaries.
176 */
177 Relation rel;
179 /* Information saved by Phase 1 for Phase 2: */
181 /* Information saved by Phases 1/2 for Phase 3: */
189 * if above is true */
194 /* true, if validating default due to some other attach/detach */
196 /* Objects to rebuild after completing ALTER TYPE operations */
207 /* Struct describing one new constraint to check in Phase 3 scan */
208 /* Note: new not-null constraints are handled elsewhere */
210 {
221 /*
222 * Struct describing one new column value that needs to be computed during
223 * Phase 3 copy (this could be either a new column with a non-null default, or
224 * a column that we're changing the type of). Columns without such an entry
225 * are just copied from the old table during ATRewriteTable. Note that the
226 * expr is an expression over *old* table values, except when is_generated
227 * is true; then it is an expression over columns of the *new* tuple.
228 */
230 {
237 /*
238 * Error-reporting support for RemoveRelations
239 */
240 struct dropmsgstrings
241 {
248 };
252 ERRCODE_UNDEFINED_TABLE,
258 ERRCODE_UNDEFINED_TABLE,
264 ERRCODE_UNDEFINED_TABLE,
270 ERRCODE_UNDEFINED_TABLE,
276 ERRCODE_UNDEFINED_OBJECT,
282 ERRCODE_UNDEFINED_OBJECT,
288 ERRCODE_UNDEFINED_OBJECT,
294 ERRCODE_UNDEFINED_TABLE,
300 ERRCODE_UNDEFINED_OBJECT,
306 };
308 /* communication between RemoveRelations and RangeVarCallbackForDropRelation */
309 struct DropRelationCallbackState
310 {
311 /* These fields are set by RemoveRelations: */
313 LOCKMODE heap_lockmode;
314 /* These fields are state to track which subsidiary locks are held: */
315 Oid heapOid;
316 Oid partParentOid;
317 /* These fields are passed back by RangeVarCallbackForDropRelation: */
320 };
322 /* Alter table target-type flags for ATSimplePermissions */
323 #define ATT_TABLE 0x0001
324 #define ATT_VIEW 0x0002
325 #define ATT_MATVIEW 0x0004
326 #define ATT_INDEX 0x0008
327 #define ATT_COMPOSITE_TYPE 0x0010
328 #define ATT_FOREIGN_TABLE 0x0020
329 #define ATT_PARTITIONED_INDEX 0x0040
330 #define ATT_SEQUENCE 0x0080
332 /*
333 * ForeignTruncateInfo
334 *
335 * Information related to truncation of foreign tables. This is used for
336 * the elements in a hash table. It uses the server OID as lookup key,
337 * and includes a per-server list of all foreign tables involved in the
338 * truncation.
339 */
341 {
342 Oid serverid;
346 /*
347 * Partition tables are expected to be dropped when the parent partitioned
348 * table gets dropped. Hence for partitioning we use AUTO dependency.
349 * Otherwise, for regular inheritance use NORMAL dependency.
350 */
351 #define child_dependency_type(child_is_partition) \
352 ((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)
363 static void MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef);
364 static ColumnDef *MergeInheritedAttribute(List *inh_columns, int exist_attno, const ColumnDef *newdef);
365 static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel, bool ispartition);
377 LOCKMODE lockmode);
382 LOCKMODE lockmode);
416 AlterTablePass cur_pass,
429 LOCKMODE lockmode,
432 DropBehavior behavior);
446 LOCKMODE lockmode);
466 static ObjectAddress ATExecDropIdentity(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode,
468 static ObjectAddress ATExecSetExpression(AlteredTableInfo *tab, Relation rel, const char *colName,
470 static void ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode);
471 static ObjectAddress ATExecDropExpression(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
482 DropBehavior behavior,
495 LOCKMODE lockmode);
503 LOCKMODE lockmode);
507 LOCKMODE lockmode);
529 Relation partitionRel);
532 Relation partRel);
535 Oid indexOid,
540 Oid indexOid,
544 Oid partRelid,
548 Oid parentInsTrigger,
549 Oid parentUpdTrigger,
550 Relation trigrel);
566 LOCKMODE lockmode);
581 LOCKMODE lockmode);
597 LOCKMODE lockmode);
607 AlterTableType operation,
608 LOCKMODE lockmode);
611 LOCKMODE lockmode);
618 DependencyType deptype);
636 static void ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
638 PartitionStrategy strategy);
664 Relation partitionTbl);
672 /* ----------------------------------------------------------------
673 * DefineRelation
674 * Creates a new relation.
675 *
676 * stmt carries parsetree information from an ordinary CREATE TABLE statement.
677 * The other arguments are used to extend the behavior for other cases:
678 * relkind: relkind to assign to the new relation
679 * ownerId: if not InvalidOid, use this as the new relation's owner.
680 * typaddress: if not null, it's set to the pg_type entry's address.
681 * queryString: for error reporting
682 *
683 * Note that permissions checks are done against current user regardless of
684 * ownerId. A nonzero ownerId is used when someone is creating a relation
685 * "on behalf of" someone else, so we still want to see that the current user
686 * has permissions to do it.
687 *
688 * If successful, returns the address of the new relation.
689 * ----------------------------------------------------------------
690 */
691 ObjectAddress
694 {
696 Oid namespaceId;
697 Oid relationId;
698 Oid tablespaceId;
699 Relation rel;
700 TupleDesc descriptor;
707 Datum reloptions;
709 AttrNumber attnum;
712 Oid ofTypeId;
713 ObjectAddress address;
714 LOCKMODE parentLockmode;
717 /*
718 * Truncate relname to appropriate length (probably a waste of time, as
719 * parser should have done this already).
720 */
723 /*
724 * Check consistency of arguments
725 */
733 {
739 }
740 else
743 /*
744 * Look up the namespace in which we are supposed to create the relation,
745 * check we have permission to create there, lock it against concurrent
746 * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
747 * namespace is selected.
748 */
749 namespaceId =
752 /*
753 * Security check: disallow creating temp tables from security-restricted
754 * code. This is needed because calling code might not expect untrusted
755 * tables to appear in pg_temp at the front of its search path.
756 */
763 /*
764 * Determine the lockmode to use when scanning parents. A self-exclusive
765 * lock is needed here.
766 *
767 * For regular inheritance, if two backends attempt to add children to the
768 * same parent simultaneously, and that parent has no pre-existing
769 * children, then both will attempt to update the parent's relhassubclass
770 * field, leading to a "tuple concurrently updated" error. Also, this
771 * interlocks against a concurrent ANALYZE on the parent table, which
772 * might otherwise be attempting to clear the parent's relhassubclass
773 * field, if its previous children were recently dropped.
774 *
775 * If the child table is a partition, then we instead grab an exclusive
776 * lock on the parent because its partition descriptor will be changed by
777 * addition of the new partition.
778 */
780 ShareUpdateExclusiveLock);
782 /* Determine the list of OIDs of the parents. */
785 {
787 Oid parentOid;
791 /*
792 * Reject duplications in the list of parents.
793 */
801 }
803 /*
804 * Select tablespace to use: an explicitly indicated one, or (in the case
805 * of a partitioned table) the parent's, if it has one.
806 */
808 {
815 }
817 {
820 }
821 else
824 /* still nothing? use the default */
827 partitioned);
829 /* Check permissions except when using database's default */
831 {
832 AclResult aclresult;
835 ACL_CREATE);
839 }
841 /* In all cases disallow placing user relations in pg_global */
847 /* Identify user ID that will own the table */
851 /*
852 * Parse and validate reloptions, if any.
853 */
858 {
867 }
870 {
871 AclResult aclresult;
878 }
879 else
882 /*
883 * Look up inheritance ancestors and generate relation schema, including
884 * inherited attributes. (Note that stmt->tableElts is destructively
885 * modified by MergeAttributes.)
886 */
893 /*
894 * Create a tuple descriptor from the relation schema. Note that this
895 * deals with column names, types, and in-descriptor NOT NULL flags, but
896 * not default values, NOT NULL or CHECK constraints; we handle those
897 * below.
898 */
901 /*
902 * Find columns with default values and prepare for insertion of the
903 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
904 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
905 * while raw defaults go into a list of RawColumnDefault structs that will
906 * be processed by AddRelationNewConstraints. (We can't deal with raw
907 * expressions until we can do transformExpr.)
908 *
909 * We can set the atthasdef flags now in the tuple descriptor; this just
910 * saves StoreAttrDefault from having to do an immediate update of the
911 * pg_attribute rows.
912 */
918 {
920 Form_pg_attribute attr;
922 attnum++;
926 {
938 }
940 {
955 }
956 }
958 /*
959 * Select access method to use: an explicitly indicated one, or (in the
960 * case of a partitioned table) the parent's, if it has one.
961 */
965 {
968 }
969 else
972 /* still nothing? use the default */
976 /*
977 * Create the relation. Inherited defaults and constraints are passed in
978 * for immediate handling --- since they don't need parsing, they can be
979 * stored immediately.
980 */
982 namespaceId,
983 tablespaceId,
984 InvalidOid,
985 InvalidOid,
986 ofTypeId,
987 ownerId,
988 accessMethodId,
989 descriptor,
991 old_constraints),
992 relkind,
997 reloptions,
999 allowSystemTableMods,
1001 InvalidOid,
1002 typaddress);
1004 /*
1005 * We must bump the command counter to make the newly-created relation
1006 * tuple visible for opening.
1007 */
1010 /*
1011 * Open the new relation and acquire exclusive lock on it. This isn't
1012 * really necessary for locking out other backends (since they can't see
1013 * the new rel anyway until we commit), but it keeps the lock manager from
1014 * complaining about deadlock risks.
1015 */
1018 /*
1019 * Now add any newly specified column default and generation expressions
1020 * to the new relation. These are passed to us in the form of raw
1021 * parsetrees; we need to transform them to executable expression trees
1022 * before they can be added. The most convenient way to do that is to
1023 * apply the parser's transformExpr routine, but transformExpr doesn't
1024 * work unless we have a pre-existing relation. So, the transformation has
1025 * to be postponed to this final step of CREATE TABLE.
1026 *
1027 * This needs to be before processing the partitioning clauses because
1028 * those could refer to generated columns.
1029 */
1034 /*
1035 * Make column generation expressions visible for use by partitioning.
1036 */
1039 /* Process and store partition bound, if any. */
1041 {
1045 defaultPartOid;
1046 Relation parent,
1050 /* Already have strong enough lock on the parent */
1053 /*
1054 * We are going to try to validate the partition bound specification
1055 * against the partition key of parentRel, so it better have one.
1056 */
1063 /*
1064 * The partition constraint of the default partition depends on the
1065 * partition bounds of every other partition. It is possible that
1066 * another backend might be about to execute a query on the default
1067 * partition table, and that the query relies on previously cached
1068 * default partition constraints. We must therefore take a table lock
1069 * strong enough to prevent all queries on the default partition from
1070 * proceeding until we commit and send out a shared-cache-inval notice
1071 * that will make them update their index lists.
1072 *
1073 * Order of locking: The relation being added won't be visible to
1074 * other backends until it is committed, hence here in
1075 * DefineRelation() the order of locking the default partition and the
1076 * relation being added does not matter. But at all other places we
1077 * need to lock the default relation before we lock the relation being
1078 * added or removed i.e. we should take the lock in same order at all
1079 * the places such that lock parent, lock default partition and then
1080 * lock the partition so as to avoid a deadlock.
1081 */
1082 defaultPartOid =
1088 /* Transform the bound values */
1092 /*
1093 * Add an nsitem containing this relation, so that transformExpr
1094 * called on partition bound expressions is able to report errors
1095 * using a proper context.
1096 */
1103 /*
1104 * Check first that the new partition's bound is valid and does not
1105 * overlap with any of existing partitions of the parent.
1106 */
1109 /*
1110 * If the default partition exists, its partition constraints will
1111 * change after the addition of this new partition such that it won't
1112 * allow any row that qualifies for this new partition. So, check that
1113 * the existing data in the default partition satisfies the constraint
1114 * as it will exist after adding this partition.
1115 */
1117 {
1119 /* Keep the lock until commit. */
1121 }
1123 /* Update the pg_class entry. */
1127 }
1129 /* Store inheritance information for new rel. */
1132 /*
1133 * Process the partitioning specification (if any) and store the partition
1134 * key information into the catalog.
1135 */
1137 {
1150 /* Protect fixed-size arrays here and in executor */
1155 PARTITION_MAX_KEYS)));
1157 /*
1158 * We need to transform the raw parsetrees corresponding to partition
1159 * expressions into executable expression trees. Like column defaults
1160 * and CHECK constraints, we could not have done the transformation
1161 * earlier.
1162 */
1170 partexprs,
1173 /* make it all visible */
1175 }
1177 /*
1178 * If we're creating a partition, create now all the indexes, triggers,
1179 * FKs defined in the parent.
1180 *
1181 * We can't do it earlier, because DefineIndex wants to know the partition
1182 * key which we just stored.
1183 */
1185 {
1187 Relation parent;
1191 /* Already have strong enough lock on the parent */
1195 /*
1196 * For each index in the parent table, create one in the partition
1197 */
1199 {
1203 Oid constraintOid;
1206 {
1214 else
1215 {
1218 }
1219 }
1224 idxstmt =
1228 idxstmt,
1229 InvalidOid,
1231 constraintOid,
1236 }
1240 /*
1241 * If there are any row-level triggers, clone them to the new
1242 * partition.
1243 */
1247 /*
1248 * And foreign keys too. Note that because we're freshly creating the
1249 * table, there is no need to verify these new constraints.
1250 */
1254 }
1256 /*
1257 * Now add any newly specified CHECK constraints to the new relation. Same
1258 * as for defaults above, but these need to come after partitioning is set
1259 * up.
1260 */
1265 /*
1266 * Finally, merge the not-null constraints that are declared directly with
1267 * those that come from parent relations (making sure to count inheritance
1268 * appropriately for each), create them, and set the attnotnull flag on
1269 * columns that don't yet have it.
1270 */
1272 old_notnulls);
1278 /*
1279 * Clean up. We keep lock on new relation (although it shouldn't be
1280 * visible to anyone else anyway, until commit).
1281 */
1285 }
1287 /*
1288 * BuildDescForRelation
1289 *
1290 * Given a list of ColumnDef nodes, build a TupleDesc.
1291 *
1292 * Note: tdtypeid will need to be filled in later on.
1293 */
1294 TupleDesc
1296 {
1298 AttrNumber attnum;
1300 TupleDesc desc;
1303 Oid atttypid;
1304 int32 atttypmod;
1305 Oid attcollation;
1308 /*
1309 * allocate a new tuple descriptor
1310 */
1318 {
1320 AclResult aclresult;
1321 Form_pg_attribute att;
1323 /*
1324 * for each entry in the list, get the name and type information from
1325 * the list and have TupleDescInitEntry fill in the attribute
1326 * information we need.
1327 */
1328 attnum++;
1348 attname)));
1354 /* Override TupleDescInitEntry's settings as requested */
1357 /* Fill in additional stuff not handled by TupleDescInitEntry */
1369 }
1372 {
1383 }
1384 else
1385 {
1387 }
1390 }
1392 /*
1393 * Emit the right error or warning message for a "DROP" command issued on a
1394 * non-existent relation
1395 */
1396 static void
1398 {
1403 {
1405 {
1409 }
1410 else
1411 {
1415 }
1417 }
1420 {
1422 {
1424 {
1428 }
1429 else
1430 {
1433 }
1434 }
1435 }
1438 }
1440 /*
1441 * Emit the right error message for a "DROP" command issued on a
1442 * relation of the wrong type
1443 */
1444 static void
1446 {
1458 /* wrongkind could be something we don't have in our table... */
1464 }
1466 /*
1467 * RemoveRelations
1468 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW,
1469 * DROP MATERIALIZED VIEW, DROP FOREIGN TABLE
1470 */
1471 void
1473 {
1480 /* DROP CONCURRENTLY uses a weaker lock, and has some restrictions */
1482 {
1483 /*
1484 * Note that for temporary relations this lock may get upgraded later
1485 * on, but as no other session can access a temporary relation, this
1486 * is actually fine.
1487 */
1498 }
1500 /*
1501 * First we identify all the relations, then we delete them in a single
1502 * performMultipleDeletions() call. This is to avoid unwanted DROP
1503 * RESTRICT errors if one of the relations depends on another.
1504 */
1506 /* Determine required relkind */
1508 {
1538 }
1540 /* Lock and validate each relation; build a list of object addresses */
1544 {
1546 Oid relOid;
1547 ObjectAddress obj;
1550 /*
1551 * These next few steps are a great deal like relation_openrv, but we
1552 * don't bother building a relcache entry since we don't need it.
1553 *
1554 * Check for shared-cache-inval messages before trying to access the
1555 * relation. This is needed to cover the case where the name
1556 * identifies a rel that has been dropped and recreated since the
1557 * start of our transaction: if we don't flush the old syscache entry,
1558 * then we'll latch onto that entry and suffer an error later.
1559 */
1562 /* Look up the appropriate relation using namespace search. */
1566 /* We must initialize these fields to show that no locks are held: */
1571 RangeVarCallbackForDropRelation,
1574 /* Not there? */
1576 {
1579 }
1581 /*
1582 * Decide if concurrent mode needs to be used here or not. The
1583 * callback retrieved the rel's persistence for us.
1584 */
1587 {
1591 }
1593 /*
1594 * Concurrent index drop cannot be used with partitioned indexes,
1595 * either.
1596 */
1604 /*
1605 * If we're told to drop a partitioned index, we must acquire lock on
1606 * all the children of its parent partitioned table before proceeding.
1607 * Otherwise we'd try to lock the child index partitions before their
1608 * tables, leading to potential deadlock against other sessions that
1609 * will lock those objects in the other order.
1610 */
1614 NULL);
1616 /* OK, we're ready to delete this one */
1622 }
1627 }
1629 /*
1630 * Before acquiring a table lock, check whether we have sufficient rights.
1631 * In the case of DROP INDEX, also try to lock the table before the index.
1632 * Also, if the table to be dropped is a partition, we try to lock the parent
1633 * first.
1634 */
1635 static void
1638 {
1639 HeapTuple tuple;
1643 Form_pg_class classform;
1644 LOCKMODE heap_lockmode;
1650 /*
1651 * If we previously locked some other index's heap, and the name we're
1652 * looking up no longer refers to that relation, release the now-useless
1653 * lock.
1654 */
1656 {
1659 }
1661 /*
1662 * Similarly, if we previously locked some other partition's heap, and the
1663 * name we're looking up no longer refers to that relation, release the
1664 * now-useless lock.
1665 */
1667 {
1670 }
1672 /* Didn't find a relation, so no need for locking or permission checks. */
1682 /* Pass back some data to save lookups in RemoveRelations */
1686 /*
1687 * Both RELKIND_RELATION and RELKIND_PARTITIONED_TABLE are OBJECT_TABLE,
1688 * but RemoveRelations() can only pass one relkind for a given relation.
1689 * It chooses RELKIND_RELATION for both regular and partitioned tables.
1690 * That means we must be careful before giving the wrong type error when
1691 * the relation is RELKIND_PARTITIONED_TABLE. An equivalent problem
1692 * exists with indexes.
1693 */
1698 else
1705 /* Allow DROP to either table owner or schema owner */
1712 /*
1713 * Check the case of a system index that might have been invalidated by a
1714 * failed concurrent process and allow its drop. For the time being, this
1715 * only concerns indexes of toast relations that became invalid during a
1716 * REINDEX CONCURRENTLY process.
1717 */
1719 {
1720 HeapTuple locTuple;
1721 Form_pg_index indexform;
1726 {
1729 }
1735 /* Mark object as being an invalid index of system catalogs */
1738 }
1740 /* In the case of an invalid index, it is fine to bypass this check */
1749 /*
1750 * In DROP INDEX, attempt to acquire lock on the parent table before
1751 * locking the index. index_drop() will need this anyway, and since
1752 * regular queries lock tables before their indexes, we risk deadlock if
1753 * we do it the other way around. No error if we don't find a pg_index
1754 * entry, though --- the relation may have been dropped. Note that this
1755 * code will execute for either plain or partitioned indexes.
1756 */
1759 {
1763 }
1765 /*
1766 * Similarly, if the relation is a partition, we must acquire lock on its
1767 * parent before locking the partition. That's because queries lock the
1768 * parent before its partitions, so we risk deadlock if we do it the other
1769 * way around.
1770 */
1772 {
1776 }
1777 }
1779 /*
1780 * ExecuteTruncate
1781 * Executes a TRUNCATE command.
1782 *
1783 * This is a multi-relation truncate. We first open and grab exclusive
1784 * lock on all relations involved, checking permissions and otherwise
1785 * verifying that the relation is OK for truncation. Note that if relations
1786 * are foreign tables, at this stage, we have not yet checked that their
1787 * foreign data in external data sources are OK for truncation. These are
1788 * checked when foreign data are actually truncated later. In CASCADE mode,
1789 * relations having FK references to the targeted relations are automatically
1790 * added to the group; in RESTRICT mode, we check that all FK references are
1791 * internal to the group that's being truncated. Finally all the relations
1792 * are truncated and reindexed.
1793 */
1794 void
1796 {
1802 /*
1803 * Open, exclusive-lock, and check all the explicitly-specified relations
1804 */
1806 {
1808 Relation rel;
1810 Oid myrelid;
1815 NULL);
1817 /* don't throw error for "TRUNCATE foo, foo" */
1821 /* open the relation, we already hold a lock on it */
1824 /*
1825 * RangeVarGetRelidExtended() has done most checks with its callback,
1826 * but other checks with the now-opened Relation remain.
1827 */
1833 /* Log this relation only if needed for logical decoding */
1838 {
1845 {
1851 /* find_all_inheritors already got lock */
1854 /*
1855 * It is possible that the parent table has children that are
1856 * temp tables of other backends. We cannot safely access
1857 * such tables (because of buffering issues), and the best
1858 * thing to do is to silently ignore them. Note that this
1859 * check is the same as one of the checks done in
1860 * truncate_check_activity() called below, still it is kept
1861 * here for simplicity.
1862 */
1864 {
1867 }
1869 /*
1870 * Inherited TRUNCATE commands perform access permission
1871 * checks on the parent table only. So we skip checking the
1872 * children's permissions and don't call
1873 * truncate_check_perms() here.
1874 */
1881 /* Log this relation only if needed for logical decoding */
1884 }
1885 }
1890 errhint("Do not specify the ONLY keyword, or use TRUNCATE ONLY on the partitions directly.")));
1891 }
1896 /* And close the rels */
1898 {
1902 }
1903 }
1905 /*
1906 * ExecuteTruncateGuts
1907 *
1908 * Internal implementation of TRUNCATE. This is called by the actual TRUNCATE
1909 * command (see above) as well as replication subscribers that execute a
1910 * replicated TRUNCATE action.
1911 *
1912 * explicit_rels is the list of Relations to truncate that the command
1913 * specified. relids is the list of Oids corresponding to explicit_rels.
1914 * relids_logged is the list of Oids (a subset of relids) that require
1915 * WAL-logging. This is all a bit redundant, but the existing callers have
1916 * this information handy in this form.
1917 */
1918 void
1924 {
1931 SubTransactionId mySubid;
1935 /*
1936 * Check the explicitly-specified relations.
1937 *
1938 * In CASCADE mode, suck in all referencing relations as well. This
1939 * requires multiple iterations to find indirectly-dependent relations. At
1940 * each phase, we need to exclusive-lock new rels before looking for their
1941 * dependencies, else we might miss something. Also, we check each rel as
1942 * soon as we open it, to avoid a faux pas such as holding lock for a long
1943 * time on a rel we have no permissions for.
1944 */
1947 {
1949 {
1957 {
1959 Relation rel;
1971 /* Log this relation only if needed for logical decoding */
1974 }
1975 }
1976 }
1978 /*
1979 * Check foreign key references. In CASCADE mode, this should be
1980 * unnecessary since we just pulled in all the references; but as a
1981 * cross-check, do it anyway if in an Assert-enabled build.
1982 */
1983 #ifdef USE_ASSERT_CHECKING
1985 #else
1988 #endif
1990 /*
1991 * If we are asked to restart sequences, find all the sequences, lock them
1992 * (we need AccessExclusiveLock for ResetSequence), and check permissions.
1993 * We want to do this early since it's pointless to do all the truncation
1994 * work only to fail on sequence permissions.
1995 */
1997 {
1999 {
2005 {
2007 Relation seq_rel;
2011 /* This check must match AlterSequence! */
2019 }
2020 }
2021 }
2023 /* Prepare to catch AFTER triggers. */
2026 /*
2027 * To fire triggers, we'll need an EState as well as a ResultRelInfo for
2028 * each relation. We don't need to call ExecOpenIndices, though.
2029 *
2030 * We put the ResultRelInfos in the es_opened_result_relations list, even
2031 * though we don't have a range table and don't populate the
2032 * es_result_relations array. That's a bit bogus, but it's enough to make
2033 * ExecGetTriggerResultRel() find them.
2034 */
2040 {
2044 rel,
2046 NULL,
2050 resultRelInfo++;
2051 }
2053 /*
2054 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
2055 * truncating (this is because one of them might throw an error). Also, if
2056 * we were to allow them to prevent statement execution, that would need
2057 * to be handled here.
2058 */
2061 {
2062 UserContext ucxt;
2070 resultRelInfo++;
2071 }
2073 /*
2074 * OK, truncate each table.
2075 */
2079 {
2082 /* Skip partitioned tables as there is nothing to do */
2086 /*
2087 * Build the lists of foreign tables belonging to each foreign server
2088 * and pass each list to the foreign data wrapper's callback function,
2089 * so that each server can truncate its all foreign tables in bulk.
2090 * Each list is saved as a single entry in a hash table that uses the
2091 * server OID as lookup key.
2092 */
2094 {
2099 /* First time through, initialize hashtable for foreign tables */
2101 {
2102 HASHCTL hctl;
2113 }
2115 /* Find or create cached entry for the foreign table */
2120 /*
2121 * Save the foreign table in the entry of the server that the
2122 * foreign table belongs to.
2123 */
2126 }
2128 /*
2129 * Normally, we need a transaction-safe truncation here. However, if
2130 * the table was either created in the current (sub)transaction or has
2131 * a new relfilenumber in the current (sub)transaction, then we can
2132 * just truncate it in-place, because a rollback would cause the whole
2133 * table or the current physical file to be thrown away anyway.
2134 */
2137 {
2138 /* Immediate, non-rollbackable truncation is OK */
2140 }
2141 else
2142 {
2143 Oid heap_relid;
2144 Oid toast_relid;
2147 /*
2148 * This effectively deletes all rows in the table, and may be done
2149 * in a serializable transaction. In that case we must record a
2150 * rw-conflict in to this transaction from each transaction
2151 * holding a predicate lock on the table.
2152 */
2155 /*
2156 * Need the full transaction-safe pushups.
2157 *
2158 * Create a new empty storage file for the relation, and assign it
2159 * as the relfilenumber value. The old storage file is scheduled
2160 * for deletion at commit.
2161 */
2166 /*
2167 * The same for the toast table, if any.
2168 */
2171 {
2173 AccessExclusiveLock);
2178 }
2180 /*
2181 * Reconstruct the indexes to match, and we're done.
2182 */
2185 }
2188 }
2190 /* Now go through the hash table, and truncate foreign tables */
2192 {
2194 HASH_SEQ_STATUS seq;
2199 {
2201 {
2204 /* truncate_check_rel() has checked that already */
2208 behavior,
2209 restart_seqs);
2210 }
2211 }
2213 {
2215 }
2217 }
2219 /*
2220 * Restart owned sequences if we were asked to.
2221 */
2223 {
2227 }
2229 /*
2230 * Write a WAL record to allow this set of actions to be logically
2231 * decoded.
2232 *
2233 * Assemble an array of relids so we can write a single WAL record for the
2234 * whole action.
2235 */
2237 {
2238 xl_heap_truncate xlrec;
2241 /* should only get here if wal_level >= logical */
2263 }
2265 /*
2266 * Process all AFTER STATEMENT TRUNCATE triggers.
2267 */
2270 {
2271 UserContext ucxt;
2279 resultRelInfo++;
2280 }
2282 /* Handle queued AFTER triggers */
2285 /* We can clean up the EState now */
2288 /*
2289 * Close any rels opened by CASCADE (can't do this while EState still
2290 * holds refs)
2291 */
2294 {
2298 }
2299 }
2301 /*
2302 * Check that a given relation is safe to truncate. Subroutine for
2303 * ExecuteTruncate() and RangeVarCallbackForTruncate().
2304 */
2305 static void
2307 {
2310 /*
2311 * Only allow truncate on regular tables, foreign tables using foreign
2312 * data wrappers supporting TRUNCATE and partitioned tables (although, the
2313 * latter are only being included here for the following checks; no
2314 * physical truncation will occur in their case.).
2315 */
2317 {
2325 relname)));
2326 }
2333 /*
2334 * Most system catalogs can't be truncated at all, or at least not unless
2335 * allow_system_table_mods=on. As an exception, however, we allow
2336 * pg_largeobject to be truncated as part of pg_upgrade, because we need
2337 * to change its relfilenode to match the old cluster, and allowing a
2338 * TRUNCATE command to be executed is the easiest way of doing that.
2339 */
2345 relname)));
2348 }
2350 /*
2351 * Check that current user has the permission to truncate given relation.
2352 */
2353 static void
2355 {
2357 AclResult aclresult;
2359 /* Permissions checks */
2363 relname);
2364 }
2366 /*
2367 * Set of extra sanity checks to check if a given relation is safe to
2368 * truncate. This is split with truncate_check_rel() as
2369 * RangeVarCallbackForTruncate() cannot open a Relation yet.
2370 */
2371 static void
2373 {
2374 /*
2375 * Don't allow truncate on temp tables of other backends ... their local
2376 * buffer manager is not going to cope.
2377 */
2383 /*
2384 * Also check for active uses of the relation in the current transaction,
2385 * including open scans and pending AFTER trigger events.
2386 */
2388 }
2390 /*
2391 * storage_name
2392 * returns the name corresponding to a typstorage/attstorage enum value
2393 */
2396 {
2398 {
2409 }
2410 }
2412 /*----------
2413 * MergeAttributes
2414 * Returns new schema given initial schema and superclasses.
2415 *
2416 * Input arguments:
2417 * 'columns' is the column/attribute definition for the table. (It's a list
2418 * of ColumnDef's.) It is destructively changed.
2419 * 'supers' is a list of OIDs of parent relations, already locked by caller.
2420 * 'relpersistence' is the persistence type of the table.
2421 * 'is_partition' tells if the table is a partition.
2422 *
2423 * Output arguments:
2424 * 'supconstr' receives a list of constraints belonging to the parents,
2425 * updated as necessary to be valid for the child.
2426 * 'supnotnulls' receives a list of CookedConstraints that corresponds to
2427 * constraints coming from inheritance parents.
2428 *
2429 * Return value:
2430 * Completed schema list.
2431 *
2432 * Notes:
2433 * The order in which the attributes are inherited is very important.
2434 * Intuitively, the inherited attributes should come first. If a table
2435 * inherits from multiple parents, the order of those attributes are
2436 * according to the order of the parents specified in CREATE TABLE.
2437 *
2438 * Here's an example:
2439 *
2440 * create table person (name text, age int4, location point);
2441 * create table emp (salary int4, manager text) inherits(person);
2442 * create table student (gpa float8) inherits (person);
2443 * create table stud_emp (percent int4) inherits (emp, student);
2444 *
2445 * The order of the attributes of stud_emp is:
2446 *
2447 * person {1:name, 2:age, 3:location}
2448 * / \
2449 * {6:gpa} student emp {4:salary, 5:manager}
2450 * \ /
2451 * stud_emp {7:percent}
2452 *
2453 * If the same attribute name appears multiple times, then it appears
2454 * in the result table in the proper location for its first appearance.
2455 *
2456 * Constraints (including not-null constraints) for the child table
2457 * are the union of all relevant constraints, from both the child schema
2458 * and parent tables. In addition, in legacy inheritance, each column that
2459 * appears in a primary key in any of the parents also gets a NOT NULL
2460 * constraint (partitioning doesn't need this, because the PK itself gets
2461 * inherited.)
2462 *
2463 * The default value for a child column is defined as:
2464 * (1) If the child schema specifies a default, that value is used.
2465 * (2) If neither the child nor any parent specifies a default, then
2466 * the column will not have a default.
2467 * (3) If conflicting defaults are inherited from different parents
2468 * (and not overridden by the child), an error is raised.
2469 * (4) Otherwise the inherited default is used.
2470 *
2471 * Note that the default-value infrastructure is used for generated
2472 * columns' expressions too, so most of the preceding paragraph applies
2473 * to generation expressions too. We insist that a child column be
2474 * generated if and only if its parent(s) are, but it need not have
2475 * the same generation expression.
2476 *----------
2477 */
2481 {
2491 /*
2492 * Check for and reject tables with too many columns. We perform this
2493 * check relatively early for two reasons: (a) we don't run the risk of
2494 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
2495 * okay if we're processing <= 1600 columns, but could take minutes to
2496 * execute if the user attempts to create a table with hundreds of
2497 * thousands of columns.
2498 *
2499 * Note that we also need to check that we do not exceed this figure after
2500 * including columns from inherited relations.
2501 */
2506 MaxHeapAttributeNumber)));
2508 /*
2509 * Check for duplicate names in the explicit list of attributes.
2510 *
2511 * Although we might consider merging such entries in the same way that we
2512 * handle name conflicts for inherited attributes, it seems to make more
2513 * sense to assume such conflicts are errors.
2514 *
2515 * We don't use foreach() here because we have two nested loops over the
2516 * columns list, with possible element deletions in the inner one. If we
2517 * used foreach_delete_current() it could only fix up the state of one of
2518 * the loops, so it seems cleaner to use looping over list indexes for
2519 * both loops. Note that any deletion will happen beyond where the outer
2520 * loop is, so its index never needs adjustment.
2521 */
2523 {
2527 {
2528 /*
2529 * Typed table column option that does not belong to a column from
2530 * the type. This works because the columns from the type come
2531 * first in the list. (We omit this check for partition column
2532 * lists; those are processed separately below.)
2533 */
2538 }
2540 /* restpos scans all entries beyond coldef; incr is in loop body */
2542 {
2546 {
2548 {
2549 /*
2550 * merge the column options into the column from the type
2551 */
2558 }
2559 else
2564 }
2565 else
2566 restpos++;
2567 }
2568 }
2570 /*
2571 * In case of a partition, there are no new column definitions, only dummy
2572 * ColumnDefs created for column constraints. Set them aside for now and
2573 * process them at the end.
2574 */
2576 {
2579 }
2581 /*
2582 * Scan the parents left-to-right, and merge their attributes to form a
2583 * list of inherited columns (inh_columns).
2584 */
2587 {
2589 Relation relation;
2590 TupleDesc tupleDesc;
2601 /* caller already got lock */
2604 /*
2605 * Check for active uses of the parent partitioned table in the
2606 * current transaction, such as being used in some manner by an
2607 * enclosing command.
2608 */
2612 /*
2613 * We do not allow partitioned tables and partitions to participate in
2614 * regular inheritance.
2615 */
2635 /*
2636 * If the parent is permanent, so must be all of its partitions. Note
2637 * that inheritance allows that case.
2638 */
2647 /* Permanent rels cannot inherit from temporary ones */
2657 /* If existing rel is temp, it must belong to this session */
2666 /*
2667 * We should have an UNDER permission flag for this, but for now,
2668 * demand that creator of a child table own the parent.
2669 */
2677 /*
2678 * newattmap->attnums[] will contain the child-table attribute numbers
2679 * for the attributes of this parent table. (They are not the same
2680 * for parents after the first one, nor if we have dropped columns.)
2681 */
2684 /* We can't process inherited defaults until newattmap is complete. */
2687 /*
2688 * All columns that are part of the parent's primary key need to be
2689 * NOT NULL; if partition just the attnotnull bit, otherwise a full
2690 * constraint (if they don't have one already). Also, we request
2691 * attnotnull on columns that have a not-null constraint that's not
2692 * marked NO INHERIT.
2693 */
2695 INDEX_ATTR_BITMAP_PRIMARY_KEY);
2702 parent_attno++)
2703 {
2711 /*
2712 * Ignore dropped columns in the parent.
2713 */
2717 /*
2718 * Create new column definition
2719 */
2728 /*
2729 * Regular inheritance children are independent enough not to
2730 * inherit identity columns. But partitions are integral part of
2731 * a partitioned table and inherit identity column.
2732 */
2736 /*
2737 * Does it match some previously considered column from another
2738 * parent?
2739 */
2742 {
2743 /*
2744 * Yes, try to merge the two column definitions.
2745 */
2750 /*
2751 * Partitions have only one parent, so conflict should never
2752 * occur.
2753 */
2755 }
2756 else
2757 {
2758 /*
2759 * No, create a new inherited column
2760 */
2768 }
2770 /*
2771 * mark attnotnull if parent has it and it's not NO INHERIT
2772 */
2775 pkattrs))
2778 /*
2779 * In regular inheritance, columns in the parent's primary key get
2780 * an extra not-null constraint. Partitioning doesn't need this,
2781 * because the PK itself is going to be cloned to the partition.
2782 */
2785 FirstLowInvalidHeapAttributeNumber,
2786 pkattrs))
2787 {
2802 }
2804 /*
2805 * Locate default/generation expression if any
2806 */
2808 {
2816 /*
2817 * If it's a GENERATED default, it might contain Vars that
2818 * need to be mapped to the inherited column(s)' new numbers.
2819 * We can't do that till newattmap is ready, so just remember
2820 * all the inherited default expressions for the moment.
2821 */
2824 }
2825 }
2827 /*
2828 * Now process any inherited default expressions, adjusting attnos
2829 * using the completed newattmap map.
2830 */
2832 {
2837 /* Adjust Vars to match new table's column numbering */
2840 newattmap,
2843 /*
2844 * For the moment we have to reject whole-row variables. We could
2845 * convert them, if we knew the new table's rowtype OID, but that
2846 * hasn't been assigned yet. (A variable could only appear in a
2847 * generation expression, so the error message is correct.)
2848 */
2853 errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
2857 /*
2858 * If we already had a default from some prior parent, check to
2859 * see if they are the same. If so, no problem; if not, mark the
2860 * column as having a bogus default. Below, we will complain if
2861 * the bogus default isn't overridden by the child columns.
2862 */
2867 {
2870 }
2871 }
2873 /*
2874 * Now copy the CHECK constraints of this parent, adjusting attnos
2875 * using the completed newattmap map. Identically named constraints
2876 * are merged if possible, else we throw error.
2877 */
2879 {
2883 {
2888 /* ignore if the constraint is non-inheritable */
2892 /* Adjust Vars to match new table's column numbering */
2895 newattmap,
2898 /*
2899 * For the moment we have to reject whole-row variables. We
2900 * could convert them, if we knew the new table's rowtype OID,
2901 * but that hasn't been assigned yet.
2902 */
2908 name,
2912 }
2913 }
2915 /*
2916 * Also copy the not-null constraints from this parent. The
2917 * attnotnull markings were already installed above.
2918 */
2920 {
2930 }
2934 /*
2935 * Close the parent rel, but keep our lock on it until xact commit.
2936 * That will prevent someone else from deleting or ALTERing the parent
2937 * before the child is committed.
2938 */
2940 }
2942 /*
2943 * If we had no inherited attributes, the result columns are just the
2944 * explicitly declared columns. Otherwise, we need to merge the declared
2945 * columns into the inherited column list. Although, we never have any
2946 * explicitly declared columns if the table is a partition.
2947 */
2949 {
2953 {
2958 /*
2959 * Partitions have only one parent and have no column definitions
2960 * of their own, so conflict should never occur.
2961 */
2964 newcol_attno++;
2966 /*
2967 * Does it match some inherited column?
2968 */
2971 {
2972 /*
2973 * Yes, try to merge the two column definitions.
2974 */
2976 }
2977 else
2978 {
2979 /*
2980 * No, attach new column unchanged to result columns.
2981 */
2983 }
2984 }
2988 /*
2989 * Check that we haven't exceeded the legal # of columns after merging
2990 * in inherited columns.
2991 */
2996 MaxHeapAttributeNumber)));
2997 }
2999 /*
3000 * Now that we have the column definition list for a partition, we can
3001 * check whether the columns referenced in the column constraint specs
3002 * actually exist. Also, merge column defaults.
3003 */
3005 {
3007 {
3013 {
3017 {
3020 /*
3021 * Check for conflicts related to generated columns.
3022 *
3023 * Same rules as above: generated-ness has to match the
3024 * parent, but the contents of the generation expression
3025 * can be different.
3026 */
3028 {
3039 }
3040 else
3041 {
3048 }
3050 /*
3051 * Override the parent's default value for this column
3052 * (coldef->cooked_default) with the partition's local
3053 * definition (restdef->raw_default), if there's one. It
3054 * should be physically impossible to get a cooked default
3055 * in the local definition or a raw default in the
3056 * inherited definition, but make sure they're nulls, for
3057 * future-proofing.
3058 */
3062 {
3065 }
3066 }
3067 }
3069 /* complain for constraints on columns not in parent */
3075 }
3076 }
3078 /*
3079 * If we found any conflicting parent default values, check to make sure
3080 * they were overridden by the child.
3081 */
3083 {
3085 {
3089 {
3096 else
3102 }
3103 }
3104 }
3110 }
3113 /*
3114 * MergeCheckConstraint
3115 * Try to merge an inherited CHECK constraint with previous ones
3116 *
3117 * If we inherit identically-named constraints from multiple parents, we must
3118 * merge them, or throw an error if they don't have identical definitions.
3119 *
3120 * constraints is a list of CookedConstraint structs for previous constraints.
3121 *
3122 * If the new constraint matches an existing one, then the existing
3123 * constraint's inheritance count is updated. If there is a conflict (same
3124 * name but different expression), throw an error. If the constraint neither
3125 * matches nor conflicts with an existing one, a new constraint is appended to
3126 * the list.
3127 */
3130 {
3135 {
3140 /* Non-matching names never conflict */
3145 {
3146 /* OK to merge constraint with existing */
3153 }
3158 name)));
3159 }
3161 /*
3162 * Constraint couldn't be merged with an existing one and also didn't
3163 * conflict with an existing one, so add it as a new one to the list.
3164 */
3171 }
3173 /*
3174 * MergeChildAttribute
3175 * Merge given child attribute definition into given inherited attribute.
3176 *
3177 * Input arguments:
3178 * 'inh_columns' is the list of inherited ColumnDefs.
3179 * 'exist_attno' is the number of the inherited attribute in inh_columns
3180 * 'newcol_attno' is the attribute number in child table's schema definition
3181 * 'newdef' is the column/attribute definition from the child table.
3182 *
3183 * The ColumnDef in 'inh_columns' list is modified. The child attribute's
3184 * ColumnDef remains unchanged.
3185 *
3186 * Notes:
3187 * - The attribute is merged according to the rules laid out in the prologue
3188 * of MergeAttributes().
3189 * - If matching inherited attribute exists but the child attribute can not be
3190 * merged into it, the function throws respective errors.
3191 * - A partition can not have its own column definitions. Hence this function
3192 * is applicable only to a regular inheritance child.
3193 */
3194 static void
3195 MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef)
3196 {
3199 Oid inhtypeid,
3200 newtypeid;
3201 int32 inhtypmod,
3202 newtypmod;
3203 Oid inhcollid,
3204 newcollid;
3209 attributeName)));
3210 else
3217 /*
3218 * Must have the same type and typmod
3219 */
3226 attributeName),
3231 /*
3232 * Must have the same collation
3233 */
3240 attributeName),
3245 /*
3246 * Identity is never inherited by a regular inheritance child. Pick
3247 * child's identity definition if there's one.
3248 */
3251 /*
3252 * Copy storage parameter
3253 */
3260 attributeName),
3265 /*
3266 * Copy compression parameter
3267 */
3271 {
3276 attributeName),
3278 }
3280 /*
3281 * Merge of not-null constraints = OR 'em together
3282 */
3285 /*
3286 * Check for conflicts related to generated columns.
3287 *
3288 * If the parent column is generated, the child column will be made a
3289 * generated column if it isn't already. If it is a generated column,
3290 * we'll take its generation expression in preference to the parent's. We
3291 * must check that the child column doesn't specify a default value or
3292 * identity, which matches the rules for a single column in
3293 * parse_utilcmd.c.
3294 *
3295 * Conversely, if the parent column is not generated, the child column
3296 * can't be either. (We used to allow that, but it results in being able
3297 * to override the generation expression via UPDATEs through the parent.)
3298 */
3300 {
3311 }
3312 else
3313 {
3320 }
3322 /*
3323 * If new def has a default, override previous default
3324 */
3326 {
3329 }
3331 /* Mark the column as locally defined */
3333 }
3335 /*
3336 * MergeInheritedAttribute
3337 * Merge given parent attribute definition into specified attribute
3338 * inherited from the previous parents.
3339 *
3340 * Input arguments:
3341 * 'inh_columns' is the list of previously inherited ColumnDefs.
3342 * 'exist_attno' is the number the existing matching attribute in inh_columns.
3343 * 'newdef' is the new parent column/attribute definition to be merged.
3344 *
3345 * The matching ColumnDef in 'inh_columns' list is modified and returned.
3346 *
3347 * Notes:
3348 * - The attribute is merged according to the rules laid out in the prologue
3349 * of MergeAttributes().
3350 * - If matching inherited attribute exists but the new attribute can not be
3351 * merged into it, the function throws respective errors.
3352 * - A partition inherits from only a single parent. Hence this function is
3353 * applicable only to a regular inheritance.
3354 */
3359 {
3362 Oid prevtypeid,
3363 newtypeid;
3364 int32 prevtypmod,
3365 newtypmod;
3366 Oid prevcollid,
3367 newcollid;
3371 attributeName)));
3374 /*
3375 * Must have the same type and typmod
3376 */
3383 attributeName),
3388 /*
3389 * Must have the same collation
3390 */
3397 attributeName),
3402 /*
3403 * Copy/check storage parameter
3404 */
3411 attributeName),
3416 /*
3417 * Copy/check compression parameter
3418 */
3425 attributeName),
3428 /*
3429 * Check for GENERATED conflicts
3430 */
3435 attributeName)));
3437 /*
3438 * Default and other constraints are handled by the caller.
3439 */
3448 }
3450 /*
3451 * StoreCatalogInheritance
3452 * Updates the system catalogs with proper inheritance information.
3453 *
3454 * supers is a list of the OIDs of the new relation's direct ancestors.
3455 */
3456 static void
3459 {
3460 Relation relation;
3461 int32 seqNumber;
3464 /*
3465 * sanity checks
3466 */
3472 /*
3473 * Store INHERITS information in pg_inherits using direct ancestors only.
3474 * Also enter dependencies on the direct ancestors, and make sure they are
3475 * marked with relhassubclass = true.
3476 *
3477 * (Once upon a time, both direct and indirect ancestors were found here
3478 * and then entered into pg_ipl. Since that catalog doesn't exist
3479 * anymore, there's no need to look for indirect ancestors.)
3480 */
3485 {
3489 child_is_partition);
3490 seqNumber++;
3491 }
3494 }
3496 /*
3497 * Make catalog entries showing relationId as being an inheritance child
3498 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
3499 */
3500 static void
3504 {
3505 ObjectAddress childobject,
3506 parentobject;
3508 /* store the pg_inherits row */
3511 /*
3512 * Store a dependency too
3513 */
3524 /*
3525 * Post creation hook of this inheritance. Since object_access_hook
3526 * doesn't take multiple object identifiers, we relay oid of parent
3527 * relation using auxiliary_id argument.
3528 */
3533 /*
3534 * Mark the parent as having subclasses.
3535 */
3537 }
3539 /*
3540 * Look for an existing column entry with the given name.
3541 *
3542 * Returns the index (starting with 1) if attribute already exists in columns,
3543 * 0 if it doesn't.
3544 */
3545 static int
3547 {
3552 {
3556 i++;
3557 }
3559 }
3562 /*
3563 * SetRelationHasSubclass
3564 * Set the value of the relation's relhassubclass field in pg_class.
3565 *
3566 * NOTE: caller must be holding an appropriate lock on the relation.
3567 * ShareUpdateExclusiveLock is sufficient.
3568 *
3569 * NOTE: an important side-effect of this operation is that an SI invalidation
3570 * message is sent out to all backends --- including me --- causing plans
3571 * referencing the relation to be rebuilt with the new list of children.
3572 * This must happen even if we find that no change is needed in the pg_class
3573 * row.
3574 */
3575 void
3577 {
3578 Relation relationRelation;
3579 HeapTuple tuple;
3580 Form_pg_class classtuple;
3582 /*
3583 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
3584 */
3592 {
3595 }
3596 else
3597 {
3598 /* no need to change tuple, but force relcache rebuild anyway */
3600 }
3604 }
3606 /*
3607 * CheckRelationTableSpaceMove
3608 * Check if relation can be moved to new tablespace.
3609 *
3610 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3611 *
3612 * Returns true if the relation can be moved to the new tablespace; raises
3613 * an error if it is not possible to do the move; returns false if the move
3614 * would have no effect.
3615 */
3616 bool
3618 {
3619 Oid oldTableSpaceId;
3621 /*
3622 * No work if no change in tablespace. Note that MyDatabaseTableSpace is
3623 * stored as 0.
3624 */
3630 /*
3631 * We cannot support moving mapped relations into different tablespaces.
3632 * (In particular this eliminates all shared catalogs.)
3633 */
3640 /* Cannot move a non-shared relation into pg_global */
3646 /*
3647 * Do not allow moving temp tables of other backends ... their local
3648 * buffer manager is not going to cope.
3649 */
3656 }
3658 /*
3659 * SetRelationTableSpace
3660 * Set new reltablespace and relfilenumber in pg_class entry.
3661 *
3662 * newTableSpaceId is the new tablespace for the relation, and
3663 * newRelFilenumber its new filenumber. If newRelFilenumber is
3664 * InvalidRelFileNumber, this field is not updated.
3665 *
3666 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3667 *
3668 * The caller of this routine had better check if a relation can be
3669 * moved to this new tablespace by calling CheckRelationTableSpaceMove()
3670 * first, and is responsible for making the change visible with
3671 * CommandCounterIncrement().
3672 */
3673 void
3675 Oid newTableSpaceId,
3676 RelFileNumber newRelFilenumber)
3677 {
3678 Relation pg_class;
3679 HeapTuple tuple;
3680 Form_pg_class rd_rel;
3685 /* Get a modifiable copy of the relation's pg_class row. */
3693 /* Update the pg_class row. */
3700 /*
3701 * Record dependency on tablespace. This is only required for relations
3702 * that have no physical storage.
3703 */
3710 }
3712 /*
3713 * renameatt_check - basic sanity checks before attribute rename
3714 */
3715 static void
3717 {
3725 /*
3726 * Renaming the columns of sequences or toast tables doesn't actually
3727 * break anything from the system's point of view, since internal
3728 * references are by attnum. But it doesn't seem right to allow users to
3729 * change names that are hardcoded into the system, hence the following
3730 * restriction.
3731 */
3746 /*
3747 * permissions checking. only the owner of a class can change its schema.
3748 */
3757 }
3759 /*
3760 * renameatt_internal - workhorse for renameatt
3761 *
3762 * Return value is the attribute number in the 'myrelid' relation.
3763 */
3764 static AttrNumber
3771 DropBehavior behavior)
3772 {
3773 Relation targetrelation;
3774 Relation attrelation;
3775 HeapTuple atttup;
3776 Form_pg_attribute attform;
3777 AttrNumber attnum;
3779 /*
3780 * Grab an exclusive lock on the target table, which we will NOT release
3781 * until end of transaction.
3782 */
3786 /*
3787 * if the 'recurse' flag is set then we are supposed to rename this
3788 * attribute in all classes that inherit from 'relname' (as well as in
3789 * 'relname').
3790 *
3791 * any permissions or problems with duplicate attributes will cause the
3792 * whole transaction to abort, which is what we want -- all or nothing.
3793 */
3795 {
3801 /*
3802 * we need the number of parents for each child so that the recursive
3803 * calls to renameatt() can determine whether there are any parents
3804 * outside the inheritance hierarchy being processed.
3805 */
3809 /*
3810 * find_all_inheritors does the recursive search of the inheritance
3811 * hierarchy, so all we have to do is process all of the relids in the
3812 * list that it returns.
3813 */
3815 {
3821 /* note we need not recurse again */
3823 }
3824 }
3825 else
3826 {
3827 /*
3828 * If we are told not to recurse, there had better not be any child
3829 * tables; else the rename would put them out of step.
3830 *
3831 * expected_parents will only be 0 if we are not already recursing.
3832 */
3838 oldattname)));
3839 }
3841 /* rename attributes in typed tables of composite type */
3843 {
3849 behavior);
3853 }
3862 oldattname)));
3870 oldattname)));
3872 /*
3873 * if the attribute is inherited, forbid the renaming. if this is a
3874 * top-level call to renameatt(), then expected_parents will be 0, so the
3875 * effect of this code will be to prohibit the renaming if the attribute
3876 * is inherited at all. if this is a recursive call to renameatt(),
3877 * expected_parents will be the number of parents the current relation has
3878 * within the inheritance hierarchy being processed, so we'll prohibit the
3879 * renaming only if there are additional parents from elsewhere.
3880 */
3885 oldattname)));
3887 /* new name should not already exist */
3890 /* apply the update */
3904 }
3906 /*
3907 * Perform permissions and integrity checks before acquiring a relation lock.
3908 */
3909 static void
3912 {
3913 HeapTuple tuple;
3914 Form_pg_class form;
3922 }
3924 /*
3925 * renameatt - changes the name of an attribute in a relation
3926 *
3927 * The returned ObjectAddress is that of the renamed column.
3928 */
3929 ObjectAddress
3931 {
3932 Oid relid;
3933 AttrNumber attnum;
3934 ObjectAddress address;
3936 /* lock level taken here should match renameatt_internal */
3939 RangeVarCallbackForRenameAttribute,
3940 NULL);
3943 {
3948 }
3950 attnum =
3962 }
3964 /*
3965 * same logic as renameatt_internal
3966 */
3967 static ObjectAddress
3969 Oid mytypid,
3975 {
3977 Oid constraintOid;
3978 HeapTuple tuple;
3979 Form_pg_constraint con;
3980 ObjectAddress address;
3985 {
3987 }
3988 else
3989 {
3992 /*
3993 * don't tell it whether we're recursing; we allow changing typed
3994 * tables here
3995 */
3999 }
4004 constraintOid);
4011 {
4013 {
4023 {
4030 rename_constraint_internal(childrelid, InvalidOid, oldconname, newconname, false, true, numparents);
4031 }
4032 }
4033 else
4034 {
4040 oldconname)));
4041 }
4047 oldconname)));
4048 }
4054 /* rename the index; this renames the constraint as well */
4056 else
4064 {
4065 /*
4066 * Invalidate relcache so as others can see the new constraint name.
4067 */
4071 }
4074 }
4076 ObjectAddress
4078 {
4083 {
4084 Relation rel;
4085 HeapTuple tup;
4095 }
4096 else
4097 {
4098 /* lock level taken here should match rename_constraint_internal */
4101 RangeVarCallbackForRenameAttribute,
4102 NULL);
4104 {
4109 }
4110 }
4112 return
4120 }
4122 /*
4123 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW/MATERIALIZED VIEW/FOREIGN TABLE
4124 * RENAME
4125 */
4126 ObjectAddress
4128 {
4130 Oid relid;
4131 ObjectAddress address;
4133 /*
4134 * Grab an exclusive lock on the target table, index, sequence, view,
4135 * materialized view, or foreign table, which we will NOT release until
4136 * end of transaction.
4137 *
4138 * Lock level used here should match RenameRelationInternal, to avoid lock
4139 * escalation. However, because ALTER INDEX can be used with any relation
4140 * type, we mustn't believe without verification.
4141 */
4143 {
4144 LOCKMODE lockmode;
4152 RangeVarCallbackForAlterRelation,
4156 {
4161 }
4163 /*
4164 * We allow mismatched statement and object types (e.g., ALTER INDEX
4165 * to rename a table), but we might've used the wrong lock level. If
4166 * that happens, retry with the correct lock level. We don't bother
4167 * if we already acquired AccessExclusiveLock with an index, however.
4168 */
4177 }
4179 /* Do the work */
4185 }
4187 /*
4188 * RenameRelationInternal - change the name of a relation
4189 */
4190 void
4192 {
4193 Relation targetrelation;
4195 HeapTuple reltup;
4196 Form_pg_class relform;
4197 Oid namespaceId;
4199 /*
4200 * Grab a lock on the target relation, which we will NOT release until end
4201 * of transaction. We need at least a self-exclusive lock so that
4202 * concurrent DDL doesn't overwrite the rename if they start updating
4203 * while still seeing the old version. The lock also guards against
4204 * triggering relcache reloads in concurrent sessions, which might not
4205 * handle this information changing under them. For indexes, we can use a
4206 * reduced lock level because RelationReloadIndexInfo() handles indexes
4207 * specially.
4208 */
4209 targetrelation = relation_open(myrelid, is_index ? ShareUpdateExclusiveLock : AccessExclusiveLock);
4212 /*
4213 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
4214 */
4226 newrelname)));
4228 /*
4229 * RenameRelation is careful not to believe the caller's idea of the
4230 * relation kind being handled. We don't have to worry about this, but
4231 * let's not be totally oblivious to it. We can process an index as
4232 * not-an-index, but not the other way around.
4233 */
4238 /*
4239 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
4240 * because it's a copy...)
4241 */
4252 /*
4253 * Also rename the associated type, if any.
4254 */
4259 /*
4260 * Also rename the associated constraint, if any.
4261 */
4264 {
4269 }
4271 /*
4272 * Close rel, but keep lock!
4273 */
4275 }
4277 /*
4278 * ResetRelRewrite - reset relrewrite
4279 */
4280 void
4282 {
4284 HeapTuple reltup;
4285 Form_pg_class relform;
4287 /*
4288 * Find relation's pg_class tuple.
4289 */
4297 /*
4298 * Update pg_class tuple.
4299 */
4306 }
4308 /*
4309 * Disallow ALTER TABLE (and similar commands) when the current backend has
4310 * any open reference to the target table besides the one just acquired by
4311 * the calling command; this implies there's an open cursor or active plan.
4312 * We need this check because our lock doesn't protect us against stomping
4313 * on our own foot, only other people's feet!
4314 *
4315 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
4316 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
4317 * possibly be relaxed to only error out for certain types of alterations.
4318 * But the use-case for allowing any of these things is not obvious, so we
4319 * won't work hard at it for now.
4320 *
4321 * We also reject these commands if there are any pending AFTER trigger events
4322 * for the rel. This is certainly necessary for the rewriting variants of
4323 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
4324 * events would try to fetch the wrong tuples. It might be overly cautious
4325 * in other cases, but again it seems better to err on the side of paranoia.
4326 *
4327 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
4328 * we are worried about active indexscans on the index. The trigger-event
4329 * check can be skipped, since we are doing no damage to the parent table.
4330 *
4331 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
4332 */
4333 void
4335 {
4342 /* translator: first %s is a SQL command, eg ALTER TABLE */
4351 /* translator: first %s is a SQL command, eg ALTER TABLE */
4354 }
4356 /*
4357 * AlterTableLookupRelation
4358 * Look up, and lock, the OID for the relation named by an alter table
4359 * statement.
4360 */
4361 Oid
4363 {
4366 RangeVarCallbackForAlterRelation,
4368 }
4370 /*
4371 * AlterTable
4372 * Execute ALTER TABLE, which can be a list of subcommands
4373 *
4374 * ALTER TABLE is performed in three phases:
4375 * 1. Examine subcommands and perform pre-transformation checking.
4376 * 2. Validate and transform subcommands, and update system catalogs.
4377 * 3. Scan table(s) to check new constraints, and optionally recopy
4378 * the data into new table(s).
4379 * Phase 3 is not performed unless one or more of the subcommands requires
4380 * it. The intention of this design is to allow multiple independent
4381 * updates of the table schema to be performed with only one pass over the
4382 * data.
4383 *
4384 * ATPrepCmd performs phase 1. A "work queue" entry is created for
4385 * each table to be affected (there may be multiple affected tables if the
4386 * commands traverse a table inheritance hierarchy). Also we do preliminary
4387 * validation of the subcommands. Because earlier subcommands may change
4388 * the catalog state seen by later commands, there are limits to what can
4389 * be done in this phase. Generally, this phase acquires table locks,
4390 * checks permissions and relkind, and recurses to find child tables.
4391 *
4392 * ATRewriteCatalogs performs phase 2 for each affected table.
4393 * Certain subcommands need to be performed before others to avoid
4394 * unnecessary conflicts; for example, DROP COLUMN should come before
4395 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
4396 * lists, one for each logical "pass" of phase 2.
4397 *
4398 * ATRewriteTables performs phase 3 for those tables that need it.
4399 *
4400 * For most subcommand types, phases 2 and 3 do no explicit recursion,
4401 * since phase 1 already does it. However, for certain subcommand types
4402 * it is only possible to determine how to recurse at phase 2 time; for
4403 * those cases, phase 1 sets the cmd->recurse flag.
4404 *
4405 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
4406 * the whole operation; we don't have to do anything special to clean up.
4407 *
4408 * The caller must lock the relation, with an appropriate lock level
4409 * for the subcommands requested, using AlterTableGetLockLevel(stmt->cmds)
4410 * or higher. We pass the lock level down
4411 * so that we can apply it recursively to inherited tables. Note that the
4412 * lock level we want as we recurse might well be higher than required for
4413 * that specific subcommand. So we pass down the overall lock requirement,
4414 * rather than reassess it at lower levels.
4415 *
4416 * The caller also provides a "context" which is to be passed back to
4417 * utility.c when we need to execute a subcommand such as CREATE INDEX.
4418 * Some of the fields therein, such as the relid, are used here as well.
4419 */
4420 void
4423 {
4424 Relation rel;
4426 /* Caller is required to provide an adequate lock. */
4432 }
4434 /*
4435 * AlterTableInternal
4436 *
4437 * ALTER TABLE with target specified by OID
4438 *
4439 * We do not reject if the relation is already open, because it's quite
4440 * likely that one or more layers of caller have it open. That means it
4441 * is unsafe to use this entry point for alterations that could break
4442 * existing query plans. On the assumption it's not used for such, we
4443 * don't have to reject pending AFTER triggers, either.
4444 *
4445 * Also, since we don't have an AlterTableUtilityContext, this cannot be
4446 * used for any subcommand types that require parse transformation or
4447 * could generate subcommands that have to be passed to ProcessUtility.
4448 */
4449 void
4451 {
4452 Relation rel;
4460 }
4462 /*
4463 * AlterTableGetLockLevel
4464 *
4465 * Sets the overall lock level required for the supplied list of subcommands.
4466 * Policy for doing this set according to needs of AlterTable(), see
4467 * comments there for overall explanation.
4468 *
4469 * Function is called before and after parsing, so it must give same
4470 * answer each time it is called. Some subcommands are transformed
4471 * into other subcommand types, so the transform must never be made to a
4472 * lower lock level than previously assigned. All transforms are noted below.
4473 *
4474 * Since this is called before we lock the table we cannot use table metadata
4475 * to influence the type of lock we acquire.
4476 *
4477 * There should be no lockmodes hardcoded into the subcommand functions. All
4478 * lockmode decisions for ALTER TABLE are made here only. The one exception is
4479 * ALTER TABLE RENAME which is treated as a different statement type T_RenameStmt
4480 * and does not travel through this section of code and cannot be combined with
4481 * any of the subcommands given here.
4482 *
4483 * Note that Hot Standby only knows about AccessExclusiveLocks on the primary
4484 * so any changes that might affect SELECTs running on standbys need to use
4485 * AccessExclusiveLocks even if you think a lesser lock would do, unless you
4486 * have a solution for that also.
4487 *
4488 * Also note that pg_dump uses only an AccessShareLock, meaning that anything
4489 * that takes a lock less than AccessExclusiveLock can change object definitions
4490 * while pg_dump is running. Be careful to check that the appropriate data is
4491 * derived by pg_dump using an MVCC snapshot, rather than syscache lookups,
4492 * otherwise we might end up with an inconsistent dump that can't restore.
4493 */
4494 LOCKMODE
4496 {
4497 /*
4498 * This only works if we read catalog tables using MVCC snapshots.
4499 */
4504 {
4509 {
4510 /*
4511 * These subcommands rewrite the heap, so require full locks.
4512 */
4514 * to SELECT */
4521 /*
4522 * These subcommands may require addition of toast tables. If
4523 * we add a toast table to a table currently being scanned, we
4524 * might miss data added to the new toast table by concurrent
4525 * insert transactions.
4526 */
4528 * ATRewriteCatalogs() */
4532 /*
4533 * Removing constraints can affect SELECTs that have been
4534 * optimized assuming the constraint holds true. See also
4535 * CloneFkReferenced.
4536 */
4542 /*
4543 * Subcommands that may be visible to concurrent SELECTs
4544 */
4555 /*
4556 * Changing owner may remove implicit SELECT privileges
4557 */
4562 /*
4563 * Changing foreign table options may affect optimization.
4564 */
4570 /*
4571 * These subcommands affect write operations only.
4572 */
4584 /*
4585 * These subcommands affect write operations only. XXX
4586 * Theoretically, these could be ShareRowExclusiveLock.
4587 */
4613 {
4617 {
4622 /*
4623 * Cases essentially the same as CREATE INDEX. We
4624 * could reduce the lock strength to ShareLock if
4625 * we can work out how to allow concurrent catalog
4626 * updates. XXX Might be set down to
4627 * ShareRowExclusiveLock but requires further
4628 * analysis.
4629 */
4634 /*
4635 * We add triggers to both tables when we add a
4636 * Foreign Key, so the lock level must be at least
4637 * as strong as CREATE TRIGGER.
4638 */
4644 }
4645 }
4648 /*
4649 * These subcommands affect inheritance behaviour. Queries
4650 * started before us will continue to see the old inheritance
4651 * behaviour, while queries started after we commit will see
4652 * new behaviour. No need to prevent reads or writes to the
4653 * subtable while we hook it up though. Changing the TupDesc
4654 * may be a problem, so keep highest lock.
4655 */
4661 /*
4662 * These subcommands affect implicit row type conversion. They
4663 * have affects similar to CREATE/DROP CAST on queries. don't
4664 * provide for invalidating parse trees as a result of such
4665 * changes, so we keep these at AccessExclusiveLock.
4666 */
4672 /*
4673 * Only used by CREATE OR REPLACE VIEW which must conflict
4674 * with an SELECTs currently using the view.
4675 */
4680 /*
4681 * These subcommands affect general strategies for performance
4682 * and maintenance, though don't change the semantic results
4683 * from normal data reads and writes. Delaying an ALTER TABLE
4684 * behind currently active writes only delays the point where
4685 * the new strategy begins to take effect, so there is no
4686 * benefit in waiting. In this case the minimum restriction
4687 * applies: we don't currently allow concurrent catalog
4688 * updates.
4689 */
4707 /*
4708 * Rel options are more complex than first appears. Options
4709 * are set here for tables, views and indexes; for historical
4710 * reasons these can all be used with ALTER TABLE, so we can't
4711 * decide between them using the basic grammar.
4712 */
4714 * getTables() */
4716 * getTables() */
4727 else
4739 }
4741 /*
4742 * Take the greatest lockmode from any subcommand
4743 */
4746 }
4749 }
4751 /*
4752 * ATController provides top level control over the phases.
4753 *
4754 * parsetree is passed in to allow it to be passed to event triggers
4755 * when requested.
4756 */
4757 static void
4761 {
4765 /* Phase 1: preliminary examination of commands, create work queue */
4767 {
4771 }
4773 /* Close the relation, but keep lock until commit */
4776 /* Phase 2: update system catalogs */
4779 /* Phase 3: scan/rewrite tables as needed, and run afterStmts */
4781 }
4783 /*
4784 * ATPrepCmd
4785 *
4786 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
4787 * recursion and permission checks.
4788 *
4789 * Caller must have acquired appropriate lock type on relation already.
4790 * This lock should be held until commit.
4791 */
4792 static void
4796 {
4800 /* Find or create work queue entry for this table */
4803 /*
4804 * Disallow any ALTER TABLE other than ALTER TABLE DETACH FINALIZE on
4805 * partitions that are pending detach.
4806 */
4814 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
4816 /*
4817 * Copy the original subcommand for each table, so we can scribble on it.
4818 * This avoids conflicts when different child tables need to make
4819 * different parse transformations (for example, the same column may have
4820 * different column numbers in different children).
4821 */
4824 /*
4825 * Do permissions and relkind checking, recursion to child tables if
4826 * needed, and any additional phase-1 processing needed. (But beware of
4827 * adding any processing that looks at table details that another
4828 * subcommand could change. In some cases we reject multiple subcommands
4829 * that could try to change the same state in contrary ways.)
4830 */
4832 {
4838 /* Recursion occurs during execution phase */
4845 /* Recursion occurs during execution phase */
4850 /*
4851 * We allow defaults on views so that INSERT into a view can have
4852 * default-ish behavior. This works because the rewriter
4853 * substitutes default values into INSERTs before it expands
4854 * rules.
4855 */
4858 /* No command-specific prep needed */
4862 /* This is currently used only in CREATE TABLE */
4863 /* (so the permission check really isn't necessary) */
4865 /* This command never recurses */
4870 /* Set up recursion for phase 2; no other prep needed */
4877 /* Set up recursion for phase 2; no other prep needed */
4880 /* This should run after AddIdentity, so do it in MISC pass */
4885 /* Set up recursion for phase 2; no other prep needed */
4892 /* Set up recursion for phase 2; no other prep needed */
4899 /* Set up recursion for phase 2; no other prep needed */
4905 * a constraint */
4907 /* Need command-specific recursion decision */
4923 ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX | ATT_PARTITIONED_INDEX | ATT_FOREIGN_TABLE);
4925 /* No command-specific prep needed */
4931 /* This command never recurses */
4937 /* No command-specific prep needed */
4942 /* This command never recurses */
4943 /* No command-specific prep needed */
4951 /* Recursion occurs during execution phase */
4956 /* This command never recurses */
4957 /* No command-specific prep needed */
4962 /* Recursion occurs during execution phase */
4963 /* No command-specific prep needed except saving recurse flag */
4970 /* This command never recurses */
4971 /* No command-specific prep needed */
4977 /* Other recursion occurs during execution phase */
4978 /* No command-specific prep needed except saving recurse flag */
4986 /* See comments for ATPrepAlterColumnType */
4990 /* Performs own recursion */
4997 /* This command never recurses */
4998 /* No command-specific prep needed */
5002 /* This command never recurses */
5003 /* No command-specific prep needed */
5009 /* These commands never recurse */
5010 /* No command-specific prep needed */
5020 /* force rewrite if necessary; see comment in ATRewriteTables */
5022 {
5025 }
5035 /* force rewrite if necessary; see comment in ATRewriteTables */
5037 {
5040 }
5050 /* check if another access method change was already requested */
5061 ATT_PARTITIONED_INDEX);
5062 /* This command never recurses */
5070 /* This command never recurses */
5071 /* No command-specific prep needed */
5076 /* This command never recurses */
5082 /* This command never recurses */
5083 /* No command-specific prep needed */
5088 /* Recursion occurs during execution phase */
5093 /* Recursion occurs during execution phase */
5094 /* No command-specific prep needed except saving recurse flag */
5102 /* This command never recurses */
5103 /* No command-specific prep needed */
5114 /* Set up recursion for phase 2; no other prep needed */
5130 /* These commands never recurse */
5131 /* No command-specific prep needed */
5136 /* No command-specific prep needed */
5141 /* No command-specific prep needed */
5146 /* No command-specific prep needed */
5151 /* No command-specific prep needed */
5159 }
5162 /* Add the subcommand to the appropriate list for phase 2 */
5164 }
5166 /*
5167 * ATRewriteCatalogs
5168 *
5169 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
5170 * dispatched in a "safe" execution order (designed to avoid unnecessary
5171 * conflicts).
5172 */
5173 static void
5176 {
5179 /*
5180 * We process all the tables "in parallel", one pass at a time. This is
5181 * needed because we may have to propagate work from one table to another
5182 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
5183 * re-adding of the foreign key constraint to the other table). Work can
5184 * only be propagated into later passes, however.
5185 */
5187 {
5188 /* Go through each table that needs to be processed */
5190 {
5198 /*
5199 * Open the relation and store it in tab. This allows subroutines
5200 * close and reopen, if necessary. Appropriate lock was obtained
5201 * by phase 1, needn't get it again.
5202 */
5210 /*
5211 * After the ALTER TYPE or SET EXPRESSION pass, do cleanup work
5212 * (this is not done in ATExecAlterColumnType since it should be
5213 * done only once if multiple columns of a table are altered).
5214 */
5219 {
5222 }
5223 }
5224 }
5226 /* Check to see if a toast table must be added. */
5228 {
5231 /*
5232 * If the table is source table of ATTACH PARTITION command, we did
5233 * not modify anything about it that will change its toasting
5234 * requirement, so no need to check.
5235 */
5241 }
5242 }
5244 /*
5245 * ATExecCmd: dispatch a subcommand to appropriate execution routine
5246 */
5247 static void
5251 {
5256 {
5314 lockmode);
5320 NULL);
5324 lockmode);
5328 lockmode);
5335 /* Transform the command only during initial examination */
5340 /* Depending on constraint type, might be no more work to do now */
5342 address =
5348 address =
5353 * constraint */
5354 address =
5357 NULL);
5364 lockmode);
5379 /* parse transformation was done earlier */
5383 address =
5402 /* nothing to do here, oid columns don't exist anymore */
5406 /*
5407 * Only do this for partitioned tables, for which this is just a
5408 * catalog change. Tables with storage are handled by Phase 3.
5409 */
5416 /*
5417 * Only do this for partitioned tables and indexes, for which this
5418 * is just a catalog change. Other relation types which have
5419 * storage are handled by Phase 3.
5420 */
5435 lockmode);
5441 lockmode);
5447 lockmode);
5453 lockmode);
5459 lockmode);
5465 lockmode);
5471 lockmode);
5477 lockmode);
5533 context);
5534 else
5542 /* ATPrepCmd ensures it must be a table */
5555 }
5557 /*
5558 * Report the subcommand to interested event triggers.
5559 */
5563 /*
5564 * Bump the command counter to ensure the next subcommand in the sequence
5565 * can see the changes so far
5566 */
5568 }
5570 /*
5571 * ATParseTransformCmd: perform parse transformation for one subcommand
5572 *
5573 * Returns the transformed subcommand tree, if there is one, else NULL.
5574 *
5575 * The parser may hand back additional AlterTableCmd(s) and/or other
5576 * utility statements, either before or after the original subcommand.
5577 * Other AlterTableCmds are scheduled into the appropriate slot of the
5578 * AlteredTableInfo (they had better be for later passes than the current one).
5579 * Utility statements that are supposed to happen before the AlterTableCmd
5580 * are executed immediately. Those that are supposed to happen afterwards
5581 * are added to the tab->afterStmts list to be done at the very end.
5582 */
5587 {
5594 /* Gin up an AlterTableStmt with just this subcommand and this table */
5604 /* Transform the AlterTableStmt */
5606 atstmt,
5611 /* Execute any statements that should happen before these subcommand(s) */
5613 {
5618 }
5620 /* Examine the transformed subcommands and schedule them appropriately */
5622 {
5624 AlterTablePass pass;
5626 /*
5627 * This switch need only cover the subcommand types that can be added
5628 * by parse_utilcmd.c; otherwise, we'll use the default strategy of
5629 * executing the subcommand immediately, as a substitute for the
5630 * original subcommand. (Note, however, that this does cause
5631 * AT_AddConstraint subcommands to be rescheduled into later passes,
5632 * which is important for index and foreign key constraints.)
5633 *
5634 * We assume we needn't do any phase-1 checks for added subcommands.
5635 */
5637 {
5644 /*
5645 * A primary key on a inheritance parent needs supporting NOT
5646 * NULL constraint on its children; enqueue commands to create
5647 * those or mark them inherited if they already exist.
5648 */
5653 /* as above */
5658 /* Recursion occurs during execution phase */
5662 {
5671 }
5674 /* This command never recurses */
5675 /* No command-specific prep needed */
5681 }
5684 {
5685 /* Cannot schedule into a pass we already finished */
5687 pass);
5688 }
5690 {
5691 /* OK, queue it up for later */
5693 }
5694 else
5695 {
5696 /*
5697 * We should see at most one subcommand for the current pass,
5698 * which is the transformed version of the original subcommand.
5699 */
5701 {
5702 /* Found the transformed version of our subcommand */
5704 }
5705 else
5707 pass);
5708 }
5709 }
5711 /* Queue up any after-statements to happen at the end */
5715 }
5717 /*
5718 * ATRewriteTables: ALTER TABLE phase 3
5719 */
5720 static void
5723 {
5726 /* Go through each table that needs to be checked or rewritten */
5728 {
5731 /* Relations without storage may be ignored here */
5735 /*
5736 * If we change column data types, the operation has to be propagated
5737 * to tables that use this table's rowtype as a column type.
5738 * tab->newvals will also be non-NULL in the case where we're adding a
5739 * column with a default. We choose to forbid that case as well,
5740 * since composite types might eventually support defaults.
5741 *
5742 * (Eventually we'll probably need to check for composite type
5743 * dependencies even when we're just scanning the table without a
5744 * rewrite, but at the moment a composite type does not enforce any
5745 * constraints, so it's not necessary/appropriate to enforce them just
5746 * during ALTER.)
5747 */
5749 {
5750 Relation rel;
5755 }
5757 /*
5758 * We only need to rewrite the table if at least one column needs to
5759 * be recomputed, or we are changing its persistence or access method.
5760 *
5761 * There are two reasons for requiring a rewrite when changing
5762 * persistence: on one hand, we need to ensure that the buffers
5763 * belonging to each of the two relations are marked with or without
5764 * BM_PERMANENT properly. On the other hand, since rewriting creates
5765 * and assigns a new relfilenumber, we automatically create or drop an
5766 * init fork for the relation as appropriate.
5767 */
5769 {
5770 /* Build a temporary relation and copy data */
5771 Relation OldHeap;
5772 Oid OIDNewHeap;
5773 Oid NewAccessMethod;
5774 Oid NewTableSpace;
5779 /*
5780 * We don't support rewriting of system catalogs; there are too
5781 * many corner cases and too little benefit. In particular this
5782 * is certainly not going to work for mapped catalogs.
5783 */
5796 /*
5797 * Don't allow rewrite on temp tables of other backends ... their
5798 * local buffer manager is not going to cope.
5799 */
5805 /*
5806 * Select destination tablespace (same as original unless user
5807 * requested a change)
5808 */
5811 else
5814 /*
5815 * Select destination access method (same as original unless user
5816 * requested a change)
5817 */
5820 else
5823 /*
5824 * Select persistence of transient table (same as original unless
5825 * user requested a change)
5826 */
5832 /*
5833 * Fire off an Event Trigger now, before actually rewriting the
5834 * table.
5835 *
5836 * We don't support Event Trigger for nested commands anywhere,
5837 * here included, and parsetree is given NULL when coming from
5838 * AlterTableInternal.
5839 *
5840 * And fire it only once.
5841 */
5847 /*
5848 * Create transient table that will receive the modified data.
5849 *
5850 * Ensure it is marked correctly as logged or unlogged. We have
5851 * to do this here so that buffers for the new relfilenumber will
5852 * have the right persistence set, and at the same time ensure
5853 * that the original filenumbers's buffers will get read in with
5854 * the correct setting (i.e. the original one). Otherwise a
5855 * rollback after the rewrite would possibly result with buffers
5856 * for the original filenumbers having the wrong persistence
5857 * setting.
5858 *
5859 * NB: This relies on swap_relation_files() also swapping the
5860 * persistence. That wouldn't work for pg_class, but that can't be
5861 * unlogged anyway.
5862 */
5866 /*
5867 * Copy the heap data into the new table with the desired
5868 * modifications, and test the current data within the table
5869 * against new constraints generated by ALTER TABLE commands.
5870 */
5873 /*
5874 * Swap the physical files of the old and new heaps, then rebuild
5875 * indexes and discard the old heap. We can use RecentXmin for
5876 * the table's new relfrozenxid because we rewrote all the tuples
5877 * in ATRewriteTable, so no older Xid remains in the table. Also,
5878 * we never try to swap toast tables by content, since we have no
5879 * interest in letting this code work on system catalogs.
5880 */
5884 RecentXmin,
5886 persistence);
5889 }
5891 {
5894 }
5895 else
5896 {
5897 /*
5898 * If required, test the current data within the table against new
5899 * constraints generated by ALTER TABLE commands, but don't
5900 * rebuild data.
5901 */
5906 /*
5907 * If we had SET TABLESPACE but no reason to reconstruct tuples,
5908 * just do a block-by-block copy.
5909 */
5912 }
5914 /*
5915 * Also change persistence of owned sequences, so that it matches the
5916 * table persistence.
5917 */
5919 {
5924 {
5928 }
5929 }
5930 }
5932 /*
5933 * Foreign key constraints are checked in a final pass, since (a) it's
5934 * generally best to examine each one separately, and (b) it's at least
5935 * theoretically possible that we have changed both relations of the
5936 * foreign key, and we'd better have finished both rewrites before we try
5937 * to read the tables.
5938 */
5940 {
5945 /* Relations without storage may be ignored here too */
5950 {
5954 {
5956 Relation refrel;
5959 {
5960 /* Long since locked, no need for another */
5962 }
5971 /*
5972 * No need to mark the constraint row as validated, we did
5973 * that when we inserted the row earlier.
5974 */
5977 }
5978 }
5982 }
5984 /* Finally, run any afterStmts that were queued up */
5986 {
5991 {
5996 }
5997 }
5998 }
6000 /*
6001 * ATRewriteTable: scan or rewrite one table
6002 *
6003 * OIDNewHeap is InvalidOid if we don't need to rewrite
6004 */
6005 static void
6007 {
6008 Relation oldrel;
6009 Relation newrel;
6010 TupleDesc oldTupDesc;
6011 TupleDesc newTupDesc;
6017 CommandId mycid;
6018 BulkInsertState bistate;
6022 /*
6023 * Open the relation(s). We have surely already locked the existing
6024 * table.
6025 */
6032 else
6035 /*
6036 * Prepare a BulkInsertState and options for table_tuple_insert. The FSM
6037 * is empty, so don't bother using it.
6038 */
6040 {
6044 }
6045 else
6046 {
6047 /* keep compiler quiet about using these uninitialized */
6051 }
6053 /*
6054 * Generate the constraint and default execution states
6055 */
6059 /* Build the needed expression execution states */
6061 {
6065 {
6071 /* Nothing to do here */
6076 }
6077 }
6079 /* Build expression execution states for partition check quals */
6081 {
6084 }
6087 {
6090 /* expr already planned */
6092 }
6096 {
6097 /*
6098 * If we are rebuilding the tuples OR if we added any new but not
6099 * verified not-null constraints, check all not-null constraints. This
6100 * is a bit of overkill but it minimizes risk of bugs, and
6101 * heap_attisnull is a pretty cheap test anyway.
6102 */
6104 {
6109 }
6112 }
6115 {
6119 TableScanDesc scan;
6120 MemoryContext oldCxt;
6123 Snapshot snapshot;
6129 else
6135 {
6136 /*
6137 * All predicate locks on the tuples or pages are about to be made
6138 * invalid, because we move tuples around. Promote them to
6139 * relation locks.
6140 */
6142 }
6146 /*
6147 * Create necessary tuple slots. When rewriting, two slots are needed,
6148 * otherwise one suffices. In the case where one slot suffices, we
6149 * need to use the new tuple descriptor, otherwise some constraints
6150 * can't be evaluated. Note that even when the tuple layout is the
6151 * same and no rewrite is required, the tupDescs might not be
6152 * (consider ADD COLUMN without a default).
6153 */
6155 {
6162 /*
6163 * Set all columns in the new slot to NULL initially, to ensure
6164 * columns added as part of the rewrite are initialized to NULL.
6165 * That is necessary as tab->newvals will not contain an
6166 * expression for columns with a NULL default, e.g. when adding a
6167 * column without a default together with a column with a default
6168 * requiring an actual rewrite.
6169 */
6171 }
6172 else
6173 {
6177 }
6179 /*
6180 * Any attributes that are dropped according to the new tuple
6181 * descriptor can be set to NULL. We precompute the list of dropped
6182 * attributes to avoid needing to do so in the per-tuple loop.
6183 */
6185 {
6188 }
6190 /*
6191 * Scan through the rows, generating a new row if needed and then
6192 * checking all the constraints.
6193 */
6197 /*
6198 * Switch to per-tuple memory context and reset it for each tuple
6199 * produced, so we don't leak memory.
6200 */
6204 {
6208 {
6209 /* Extract data from old tuple */
6213 /* copy attributes */
6219 /* Set dropped attributes to null in new tuple */
6223 /*
6224 * Constraints and GENERATED expressions might reference the
6225 * tableoid column, so fill tts_tableOid with the desired
6226 * value. (We must do this each time, because it gets
6227 * overwritten with newrel's OID during storing.)
6228 */
6231 /*
6232 * Process supplied expressions to replace selected columns.
6233 *
6234 * First, evaluate expressions whose inputs come from the old
6235 * tuple.
6236 */
6240 {
6248 econtext,
6250 }
6254 /*
6255 * Now, evaluate any expressions whose inputs come from the
6256 * new tuple. We assume these columns won't reference each
6257 * other, so that there's no ordering dependency.
6258 */
6262 {
6270 econtext,
6272 }
6275 }
6276 else
6277 {
6278 /*
6279 * If there's no rewrite, old and new table are guaranteed to
6280 * have the same AM, so we can just use the old slot to verify
6281 * new constraints etc.
6282 */
6284 }
6286 /* Now check any constraints on the possibly-changed tuple */
6290 {
6294 {
6303 }
6304 }
6307 {
6311 {
6323 /* Nothing to do here */
6328 }
6329 }
6332 {
6336 errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
6339 else
6345 }
6347 /* Write the tuple out to the new relation */
6355 }
6364 }
6370 {
6376 }
6377 }
6379 /*
6380 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
6381 */
6384 {
6390 {
6394 }
6396 /*
6397 * Not there, so add it. Note that we make a copy of the relation's
6398 * existing descriptor before anything interesting can happen to it.
6399 */
6414 }
6418 {
6420 {
6549 }
6552 }
6554 /*
6555 * ATSimplePermissions
6556 *
6557 * - Ensure that it is a relation (or possibly a view)
6558 * - Ensure this user is the owner
6559 * - Ensure that it is not a system table
6560 */
6561 static void
6563 {
6567 {
6596 }
6598 /* Wrong target type? */
6600 {
6606 /* translator: %s is a group of some SQL keywords */
6610 else
6611 /* internal error? */
6614 }
6616 /* Permissions checks */
6626 }
6628 /*
6629 * ATSimpleRecursion
6630 *
6631 * Simple table recursion sufficient for most ALTER TABLE operations.
6632 * All direct and indirect children are processed in an unspecified order.
6633 * Note that if a child inherits from the original table via multiple
6634 * inheritance paths, it will be visited just once.
6635 */
6636 static void
6640 {
6641 /*
6642 * Propagate to children, if desired and if there are (or might be) any
6643 * children.
6644 */
6646 {
6653 /*
6654 * find_all_inheritors does the recursive search of the inheritance
6655 * hierarchy, so all we have to do is process all of the relids in the
6656 * list that it returns.
6657 */
6659 {
6661 Relation childrel;
6665 /* find_all_inheritors already got lock */
6670 }
6671 }
6672 }
6674 /*
6675 * Obtain list of partitions of the given table, locking them all at the given
6676 * lockmode and ensuring that they all pass CheckTableNotInUse.
6677 *
6678 * This function is a no-op if the given relation is not a partitioned table;
6679 * in particular, nothing is done if it's a legacy inheritance parent.
6680 */
6681 static void
6683 {
6685 {
6690 /* first element is the parent rel; must ignore it */
6692 {
6693 Relation childrel;
6695 /* find_all_inheritors already got lock */
6699 }
6701 }
6702 }
6704 /*
6705 * ATTypedTableRecursion
6706 *
6707 * Propagate ALTER TYPE operations to the typed tables of that type.
6708 * Also check the RESTRICT/CASCADE behavior. Given CASCADE, also permit
6709 * recursion to inheritance children of the typed tables.
6710 */
6711 static void
6714 {
6725 {
6727 Relation childrel;
6733 }
6734 }
6737 /*
6738 * find_composite_type_dependencies
6739 *
6740 * Check to see if the type "typeOid" is being used as a column in some table
6741 * (possibly nested several levels deep in composite types, arrays, etc!).
6742 * Eventually, we'd like to propagate the check or rewrite operation
6743 * into such tables, but for now, just error out if we find any.
6744 *
6745 * Caller should provide either the associated relation of a rowtype,
6746 * or a type name (not both) for use in the error message, if any.
6747 *
6748 * Note that "typeOid" is not necessarily a composite type; it could also be
6749 * another container type such as an array or range, or a domain over one of
6750 * these things. The name of this function is therefore somewhat historical,
6751 * but it's not worth changing.
6752 *
6753 * We assume that functions and views depending on the type are not reasons
6754 * to reject the ALTER. (How safe is this really?)
6755 */
6756 void
6759 {
6760 Relation depRel;
6762 SysScanDesc depScan;
6763 HeapTuple depTup;
6765 /* since this function recurses, it could be driven to stack overflow */
6768 /*
6769 * We scan pg_depend to find those things that depend on the given type.
6770 * (We assume we can ignore refobjsubid for a type.)
6771 */
6775 Anum_pg_depend_refclassid,
6779 Anum_pg_depend_refobjid,
6787 {
6789 Relation rel;
6790 TupleDesc tupleDesc;
6791 Form_pg_attribute att;
6793 /* Check for directly dependent types */
6795 {
6796 /*
6797 * This must be an array, domain, or range containing the given
6798 * type, so recursively check for uses of this type. Note that
6799 * any error message will mention the original type not the
6800 * container; this is intentional.
6801 */
6805 }
6807 /* Else, ignore dependees that aren't relations */
6814 /*
6815 * If objsubid identifies a specific column, refer to that in error
6816 * messages. Otherwise, search to see if there's a user column of the
6817 * type. (We assume system columns are never of interesting types.)
6818 * The search is needed because an index containing an expression
6819 * column of the target type will just be recorded as a whole-relation
6820 * dependency. If we do not find a column of the type, the dependency
6821 * must indicate that the type is transiently referenced in an index
6822 * expression but not stored on disk, which we assume is OK, just as
6823 * we do for references in views. (It could also be that the target
6824 * type is embedded in some container type that is stored in an index
6825 * column, but the previous recursion should catch such cases.)
6826 */
6829 else
6830 {
6833 {
6838 }
6840 {
6841 /* No such column, so assume OK */
6844 }
6845 }
6847 /*
6848 * We definitely should reject if the relation has storage. If it's
6849 * partitioned, then perhaps we don't have to reject: if there are
6850 * partitions then we'll fail when we find one, else there is no
6851 * stored data to worry about. However, it's possible that the type
6852 * change would affect conclusions about whether the type is sortable
6853 * or hashable and thus (if it's a partitioning column) break the
6854 * partitioning rule. For now, reject for partitioned rels too.
6855 */
6858 {
6863 origTypeName,
6880 else
6887 }
6889 {
6890 /*
6891 * A view or composite type itself isn't a problem, but we must
6892 * recursively check for indirect dependencies via its rowtype.
6893 */
6896 }
6899 }
6904 }
6907 /*
6908 * find_typed_table_dependencies
6909 *
6910 * Check to see if a composite type is being used as the type of a
6911 * typed table. Abort if any are found and behavior is RESTRICT.
6912 * Else return the list of tables.
6913 */
6916 {
6917 Relation classRel;
6919 TableScanDesc scan;
6920 HeapTuple tuple;
6926 Anum_pg_class_reloftype,
6933 {
6940 typeName),
6942 else
6944 }
6950 }
6953 /*
6954 * check_of_type
6955 *
6956 * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF. If it
6957 * isn't suitable, throw an error. Currently, we require that the type
6958 * originated with CREATE TYPE AS. We could support any row type, but doing so
6959 * would require handling a number of extra corner cases in the DDL commands.
6960 * (Also, allowing domain-over-composite would open up a can of worms about
6961 * whether and how the domain's constraints should apply to derived tables.)
6962 */
6963 void
6965 {
6970 {
6971 Relation typeRelation;
6977 /*
6978 * Close the parent rel, but keep our AccessShareLock on it until xact
6979 * commit. That will prevent someone else from deleting or ALTERing
6980 * the type before the typed table creation/conversion commits.
6981 */
6983 }
6989 }
6992 /*
6993 * ALTER TABLE ADD COLUMN
6994 *
6995 * Adds an additional attribute to a relation making the assumption that
6996 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
6997 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
6998 * AlterTableCmd's.
6999 *
7000 * ADD COLUMN cannot use the normal ALTER TABLE recursion mechanism, because we
7001 * have to decide at runtime whether to recurse or not depending on whether we
7002 * actually add a column or merely merge with an existing column. (We can't
7003 * check this in a static pre-pass because it won't handle multiple inheritance
7004 * situations correctly.)
7005 */
7006 static void
7010 {
7021 }
7023 /*
7024 * Add a column to a table. The return value is the address of the
7025 * new column in the parent relation.
7026 *
7027 * cmd is pass-by-ref so that we can replace it with the parse-transformed
7028 * copy (but that happens only after we check for IF NOT EXISTS).
7029 */
7030 static ObjectAddress
7035 {
7039 Relation pgclass,
7040 attrdesc;
7041 HeapTuple reltup;
7042 Form_pg_attribute attribute;
7049 ObjectAddress address;
7050 TupleDesc tupdesc;
7052 /* since this function recurses, it could be driven to stack overflow */
7055 /* At top level, permission check was done in ATPrepCmd, else do it */
7066 /*
7067 * Are we adding the column to a recursion child? If so, check whether to
7068 * merge with an existing definition for the column. If we do merge, we
7069 * must not recurse. Children will already have the column, and recursing
7070 * into them would mess up attinhcount.
7071 */
7073 {
7074 HeapTuple tuple;
7076 /* Does child already have a column by this name? */
7079 {
7081 Oid ctypeId;
7082 int32 ctypmod;
7083 Oid ccollid;
7085 /* Child column must match on type, typmod, and collation */
7103 /* Bump the existing child att's inhcount */
7113 /* Inform the user about the merge */
7120 /* Make the child column change visible */
7124 }
7125 }
7127 /* skip if the name already exists and if_not_exists is true */
7129 {
7132 }
7134 /*
7135 * Okay, we need to add the column, so go ahead and do parse
7136 * transformation. This can result in queueing up, or even immediately
7137 * executing, subsidiary operations (such as creation of unique indexes);
7138 * so we mustn't do it until we have made the if_not_exists check.
7139 *
7140 * When recursing, the command was already transformed and we needn't do
7141 * so again. Also, if context isn't given we can't transform. (That
7142 * currently happens only for AT_AddColumnToView; we expect that view.c
7143 * passed us a ColumnDef that doesn't need work.)
7144 */
7146 {
7151 }
7153 /*
7154 * Regular inheritance children are independent enough not to inherit the
7155 * identity column from parent hence cannot recursively add identity
7156 * column if the table has inheritance children.
7157 *
7158 * Partitions, on the other hand, are integral part of a partitioned table
7159 * and inherit identity column. Hence propagate identity column down the
7160 * partition hierarchy.
7161 */
7163 recurse &&
7177 /* Determine the new attribute's number */
7183 MaxHeapAttributeNumber)));
7185 /*
7186 * Construct new attribute's pg_attribute entry.
7187 */
7192 /* Fix up attribute number */
7195 /* make sure datatype is legal for a column */
7204 /*
7205 * Update pg_class tuple as appropriate
7206 */
7213 /* Post creation hook for new attribute */
7218 /* Make the attribute's catalog entry visible */
7221 /*
7222 * Store the DEFAULT, if any, in the catalogs
7223 */
7225 {
7232 /*
7233 * Attempt to skip a complete table rewrite by storing the specified
7234 * DEFAULT value outside of the heap. This may be disabled inside
7235 * AddRelationNewConstraints if the optimization cannot be applied.
7236 */
7241 /*
7242 * This function is intended for CREATE TABLE, so it processes a
7243 * _list_ of defaults, but we just do one.
7244 */
7248 /* Make the additional catalog changes visible */
7251 /*
7252 * Did the request for a missing value work? If not we'll have to do a
7253 * rewrite
7254 */
7257 }
7259 /*
7260 * Tell Phase 3 to fill in the default expression, if there is one.
7261 *
7262 * If there is no default, Phase 3 doesn't have to do anything, because
7263 * that effectively means that the default is NULL. The heap tuple access
7264 * routines always check for attnum > # of attributes in tuple, and return
7265 * NULL if so, so without any modification of the tuple data we will get
7266 * the effect of NULL values in the new column.
7267 *
7268 * An exception occurs when the new column is of a domain type: the domain
7269 * might have a not-null constraint, or a check constraint that indirectly
7270 * rejects nulls. If there are any domain constraints then we construct
7271 * an explicit NULL default value that will be passed through
7272 * CoerceToDomain processing. (This is a tad inefficient, since it causes
7273 * rewriting the table which we really don't have to do, but the present
7274 * design of domain processing doesn't offer any simple way of checking
7275 * the constraints more directly.)
7276 *
7277 * Note: we use build_column_default, and not just the cooked default
7278 * returned by AddRelationNewConstraints, so that the right thing happens
7279 * when a datatype's default applies.
7280 *
7281 * Note: it might seem that this should happen at the end of Phase 2, so
7282 * that the effects of subsequent subcommands can be taken into account.
7283 * It's intentional that we do it now, though. The new column should be
7284 * filled according to what is said in the ADD COLUMN subcommand, so that
7285 * the effects are the same as if this subcommand had been run by itself
7286 * and the later subcommands had been issued in new ALTER TABLE commands.
7287 *
7288 * We can skip this entirely for relations without storage, since Phase 3
7289 * is certainly not going to touch them. System attributes don't have
7290 * interesting defaults, either.
7291 */
7293 {
7294 /*
7295 * For an identity column, we can't use build_column_default(),
7296 * because the sequence ownership isn't set yet. So do it manually.
7297 */
7299 {
7307 /* must do a rewrite for identity columns */
7309 }
7310 else
7314 {
7315 Oid baseTypeId;
7316 int32 baseTypeMod;
7317 Oid baseTypeColl;
7325 baseTypeId,
7328 COERCION_ASSIGNMENT,
7329 COERCE_IMPLICIT_CAST,
7333 }
7336 {
7345 }
7351 {
7352 /*
7353 * If the new column is NOT NULL, and there is no missing value,
7354 * tell Phase 3 it needs to check for NULLs.
7355 */
7357 }
7358 }
7360 /*
7361 * Add needed dependency entries for the new column.
7362 */
7366 /*
7367 * Propagate to children as appropriate. Unlike most other ALTER
7368 * routines, we have to do this one level of recursion at a time; we can't
7369 * use find_all_inheritors to do it in one pass.
7370 */
7371 children =
7374 /*
7375 * If we are told not to recurse, there had better not be any child
7376 * tables; else the addition would put them out of step.
7377 */
7383 /* Children should see column as singly inherited */
7385 {
7390 }
7391 else
7395 {
7397 Relation childrel;
7400 /* find_inheritance_children already got lock */
7404 /* Find or create work queue entry for this table */
7407 /* Recurse to child; return value is ignored */
7413 }
7417 }
7419 /*
7420 * If a new or renamed column will collide with the name of an existing
7421 * column and if_not_exists is false then error out, else do nothing.
7422 */
7423 static bool
7426 {
7427 HeapTuple attTuple;
7430 /*
7431 * this test is deliberately not attisdropped-aware, since if one tries to
7432 * add a column matching a dropped column name, it's gonna fail anyway.
7433 */
7443 /*
7444 * We throw a different error message for conflicts with system column
7445 * names, since they are normally not shown and the user might otherwise
7446 * be confused about the reason for the conflict.
7447 */
7452 colname)));
7453 else
7454 {
7456 {
7462 }
7468 }
7471 }
7473 /*
7474 * Install a column's dependency on its datatype.
7475 */
7476 static void
7478 {
7479 ObjectAddress myself,
7480 referenced;
7489 }
7491 /*
7492 * Install a column's dependency on its collation.
7493 */
7494 static void
7496 {
7497 ObjectAddress myself,
7498 referenced;
7500 /* We know the default collation is pinned, so don't bother recording it */
7502 {
7510 }
7511 }
7513 /*
7514 * ALTER TABLE ALTER COLUMN DROP NOT NULL
7515 *
7516 * Return the address of the modified column. If the column was already
7517 * nullable, InvalidObjectAddress is returned.
7518 */
7519 static ObjectAddress
7521 LOCKMODE lockmode)
7522 {
7523 HeapTuple tuple;
7524 HeapTuple conTup;
7525 Form_pg_attribute attTup;
7526 AttrNumber attnum;
7527 Relation attr_rel;
7528 ObjectAddress address;
7531 /*
7532 * lookup the attribute
7533 */
7547 /* If the column is already nullable there's nothing to do. */
7549 {
7552 }
7554 /* Prevent them from altering a system attribute */
7559 colName)));
7567 /*
7568 * It's not OK to remove a constraint only for the parent and leave it in
7569 * the children, so disallow that.
7570 */
7572 {
7574 {
7575 PartitionDesc partdesc;
7584 }
7587 {
7591 colName),
7593 }
7594 }
7596 /*
7597 * If rel is partition, shouldn't drop NOT NULL if parent has the same.
7598 */
7600 {
7604 AttrNumber parent_attnum;
7611 colName)));
7613 }
7615 /*
7616 * Find the constraint that makes this column NOT NULL.
7617 */
7620 {
7623 /*
7624 * There's no not-null constraint, so throw an error. If the column
7625 * is in a primary key, we can throw a specific error. Otherwise,
7626 * this is unexpected.
7627 */
7630 pkcols))
7635 /* this shouldn't happen */
7638 }
7652 }
7654 /*
7655 * Helper to set pg_attribute.attnotnull if it isn't set, and to tell phase 3
7656 * to verify it; recurses to apply the same to children.
7657 *
7658 * When called to alter an existing table, 'wqueue' must be given so that we can
7659 * queue a check that existing tuples pass the constraint. When called from
7660 * table creation, 'wqueue' should be passed as NULL.
7661 *
7662 * Returns true if the flag was set in any table, otherwise false.
7663 */
7664 static bool
7666 LOCKMODE lockmode)
7667 {
7668 HeapTuple tuple;
7669 Form_pg_attribute attForm;
7672 /* Guard against stack overflow due to overly deep inheritance tree. */
7681 {
7682 Relation attr_rel;
7691 /*
7692 * And set up for existing values to be checked, unless another
7693 * constraint already proves this.
7694 */
7696 {
7701 }
7704 }
7707 {
7713 {
7715 Relation childrel;
7716 AttrNumber childattno;
7718 /* find_inheritance_children already got lock */
7728 }
7729 }
7732 }
7734 /*
7735 * ALTER TABLE ALTER COLUMN SET NOT NULL
7736 *
7737 * Add a not-null constraint to a single table and its children. Returns
7738 * the address of the constraint added to the parent relation, if one gets
7739 * added, or InvalidObjectAddress otherwise.
7740 *
7741 * We must recurse to child tables during execution, rather than using
7742 * ALTER TABLE's normal prep-time recursion.
7743 */
7744 static ObjectAddress
7747 LOCKMODE lockmode)
7748 {
7749 HeapTuple tuple;
7750 Relation constr_rel;
7751 ScanKeyData skey;
7752 SysScanDesc conscan;
7753 AttrNumber attnum;
7754 ObjectAddress address;
7761 /* Guard against stack overflow due to overly deep inheritance tree. */
7764 /*
7765 * In cases of multiple inheritance, we might visit the same child more
7766 * than once. In the topmost call, set up a list that we fill with all
7767 * visited relations, to skip those.
7768 */
7770 {
7773 }
7778 /* At top level, permission check was done in ATPrepCmd, else do it */
7780 {
7783 }
7792 /* Prevent them from altering a system attribute */
7797 colName)));
7799 /* See if there's already a constraint */
7802 Anum_pg_constraint_conrelid,
7809 {
7812 HeapTuple copytup;
7823 /*
7824 * If we find an appropriate constraint, we're almost done, but just
7825 * need to change some properties on it: if we're recursing, increment
7826 * coninhcount; if not, set conislocal if not already set.
7827 */
7829 {
7832 }
7834 {
7837 }
7840 {
7843 }
7850 else
7852 }
7857 /*
7858 * If we're asked not to recurse, and children exist, raise an error for
7859 * partitioned tables. For inheritance, we act as if NO INHERIT had been
7860 * specified.
7861 */
7865 {
7871 else
7873 }
7875 /*
7876 * No constraint exists; we must add one. First determine a name to use,
7877 * if we haven't already.
7878 */
7880 {
7885 NIL);
7886 }
7899 /* and do it */
7908 /*
7909 * Mark pg_attribute.attnotnull for the column. Tell that function not to
7910 * recurse, because we're going to do it here.
7911 */
7914 /*
7915 * Recurse to propagate the constraint to children that don't have one.
7916 */
7918 {
7923 lockmode);
7926 {
7927 Relation childrel;
7936 }
7937 }
7940 }
7942 /*
7943 * ALTER TABLE ALTER COLUMN SET ATTNOTNULL
7944 *
7945 * This doesn't exist in the grammar; it's used when creating a
7946 * primary key and the column is not already marked attnotnull.
7947 */
7948 static ObjectAddress
7951 {
7952 AttrNumber attnum;
7962 /*
7963 * Make the change, if necessary, and only if so report the column as
7964 * changed
7965 */
7971 }
7973 /*
7974 * NotNullImpliedByRelConstraints
7975 * Does rel's existing constraints imply NOT NULL for the given attribute?
7976 */
7977 static bool
7979 {
7990 /*
7991 * argisrow = false is correct even for a composite column, because
7992 * attnotnull does not represent a SQL-spec IS NOT NULL test in such a
7993 * case, just IS DISTINCT FROM NULL.
7994 */
7999 {
8001 (errmsg_internal("existing constraints on column \"%s.%s\" are sufficient to prove that it does not contain nulls",
8004 }
8007 }
8009 /*
8010 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
8011 *
8012 * Return the address of the affected column.
8013 */
8014 static ObjectAddress
8017 {
8019 AttrNumber attnum;
8020 ObjectAddress address;
8022 /*
8023 * get the number of the attribute
8024 */
8032 /* Prevent them from altering a system attribute */
8037 colName)));
8044 /* translator: %s is an SQL ALTER command */
8053 newDefault ?
8054 /* translator: %s is an SQL ALTER command */
8059 /*
8060 * Remove any old default for the column. We use RESTRICT here for
8061 * safety, but at present we do not expect anything to depend on the
8062 * default.
8063 *
8064 * We treat removing the existing default as an internal operation when it
8065 * is preparatory to adding a new default, but as a user-initiated
8066 * operation when the user asked for a drop.
8067 */
8072 {
8073 /* SET DEFAULT */
8082 /*
8083 * This function is intended for CREATE TABLE, so it processes a
8084 * _list_ of defaults, but we just do one.
8085 */
8088 }
8093 }
8095 /*
8096 * Add a pre-cooked default expression.
8097 *
8098 * Return the address of the affected column.
8099 */
8100 static ObjectAddress
8103 {
8104 ObjectAddress address;
8106 /* We assume no checking is required */
8108 /*
8109 * Remove any old default for the column. We use RESTRICT here for
8110 * safety, but at present we do not expect anything to depend on the
8111 * default. (In ordinary cases, there could not be a default in place
8112 * anyway, but it's possible when combining LIKE with inheritance.)
8113 */
8122 }
8124 /*
8125 * ALTER TABLE ALTER COLUMN ADD IDENTITY
8126 *
8127 * Return the address of the affected column.
8128 */
8129 static ObjectAddress
8132 {
8133 Relation attrelation;
8134 HeapTuple tuple;
8135 Form_pg_attribute attTup;
8136 AttrNumber attnum;
8137 ObjectAddress address;
8164 /* Can't alter a system attribute */
8169 colName)));
8171 /*
8172 * Creating a column as identity implies NOT NULL, so adding the identity
8173 * to an existing column that is not NOT NULL would create a state that
8174 * cannot be reproduced without contortions.
8175 */
8179 errmsg("column \"%s\" of relation \"%s\" must be declared NOT NULL before identity can be added",
8206 /*
8207 * Recurse to propagate the identity column to partitions. Identity is
8208 * not inherited in regular inheritance children.
8209 */
8211 {
8218 {
8219 Relation childrel;
8224 }
8225 }
8228 }
8230 /*
8231 * ALTER TABLE ALTER COLUMN SET { GENERATED or sequence options }
8232 *
8233 * Return the address of the affected column.
8234 */
8235 static ObjectAddress
8238 {
8241 HeapTuple tuple;
8242 Form_pg_attribute attTup;
8243 AttrNumber attnum;
8244 Relation attrelation;
8245 ObjectAddress address;
8261 {
8265 {
8271 }
8272 else
8275 }
8277 /*
8278 * Even if there is nothing to change here, we run all the checks. There
8279 * will be a subsequent ALTER SEQUENCE that relies on everything being
8280 * there.
8281 */
8298 colName)));
8307 {
8316 }
8317 else
8323 /*
8324 * Recurse to propagate the identity change to partitions. Identity is not
8325 * inherited in regular inheritance children.
8326 */
8328 {
8335 {
8336 Relation childrel;
8341 }
8342 }
8345 }
8347 /*
8348 * ALTER TABLE ALTER COLUMN DROP IDENTITY
8349 *
8350 * Return the address of the affected column.
8351 */
8352 static ObjectAddress
8355 {
8356 HeapTuple tuple;
8357 Form_pg_attribute attTup;
8358 AttrNumber attnum;
8359 Relation attrelation;
8360 ObjectAddress address;
8361 Oid seqid;
8362 ObjectAddress seqaddress;
8392 colName)));
8395 {
8401 else
8402 {
8409 }
8410 }
8424 /*
8425 * Recurse to drop the identity from column in partitions. Identity is
8426 * not inherited in regular inheritance children so ignore them.
8427 */
8429 {
8436 {
8437 Relation childrel;
8442 }
8443 }
8446 {
8447 /* drop the internal sequence */
8456 }
8459 }
8461 /*
8462 * ALTER TABLE ALTER COLUMN SET EXPRESSION
8463 *
8464 * Return the address of the affected column.
8465 */
8466 static ObjectAddress
8469 {
8470 HeapTuple tuple;
8471 Form_pg_attribute attTup;
8472 AttrNumber attnum;
8473 Oid attrdefoid;
8474 ObjectAddress address;
8493 colName)));
8502 /*
8503 * Clear all the missing values if we're rewriting the table, since this
8504 * renders them pointless.
8505 */
8508 /* make sure we don't conflict with later attribute modifications */
8511 /*
8512 * Find everything that depends on the column (constraints, indexes, etc),
8513 * and record enough information to let us recreate the objects after
8514 * rewrite.
8515 */
8518 /*
8519 * Drop the dependency records of the GENERATED expression, in particular
8520 * its INTERNAL dependency on the column, which would otherwise cause
8521 * dependency.c to refuse to perform the deletion.
8522 */
8529 /* Make above changes visible */
8532 /*
8533 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8534 * safety, but at present we do not expect anything to depend on the
8535 * expression.
8536 */
8540 /* Prepare to store the new expression, in the catalogs */
8547 /* Store the generated expression */
8551 /* Make above new expression visible */
8554 /* Prepare for table rewrite */
8565 /* Drop any pg_statistic entry for the column */
8574 }
8576 /*
8577 * ALTER TABLE ALTER COLUMN DROP EXPRESSION
8578 */
8579 static void
8580 ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
8581 {
8582 /*
8583 * Reject ONLY if there are child tables. We could implement this, but it
8584 * is a bit complicated. GENERATED clauses must be attached to the column
8585 * definition and cannot be added later like DEFAULT, so if a child table
8586 * has a generation expression that the parent does not have, the child
8587 * column will necessarily be an attislocal column. So to implement ONLY
8588 * here, we'd need extra code to update attislocal of the direct child
8589 * tables, somewhat similar to how DROP COLUMN does it, so that the
8590 * resulting state can be properly dumped and restored.
8591 */
8598 /*
8599 * Cannot drop generation expression from inherited columns.
8600 */
8602 {
8603 HeapTuple tuple;
8604 Form_pg_attribute attTup;
8619 }
8620 }
8622 /*
8623 * Return the address of the affected column.
8624 */
8625 static ObjectAddress
8627 {
8628 HeapTuple tuple;
8629 Form_pg_attribute attTup;
8630 AttrNumber attnum;
8631 Relation attrelation;
8632 Oid attrdefoid;
8633 ObjectAddress address;
8650 colName)));
8653 {
8659 else
8660 {
8667 }
8668 }
8670 /*
8671 * Mark the column as no longer generated. (The atthasdef flag needs to
8672 * get cleared too, but RemoveAttrDefault will handle that.)
8673 */
8679 attnum);
8684 /*
8685 * Drop the dependency records of the GENERATED expression, in particular
8686 * its INTERNAL dependency on the column, which would otherwise cause
8687 * dependency.c to refuse to perform the deletion.
8688 */
8695 /* Make above changes visible */
8698 /*
8699 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8700 * safety, but at present we do not expect anything to depend on the
8701 * default.
8702 */
8709 }
8711 /*
8712 * ALTER TABLE ALTER COLUMN SET STATISTICS
8713 *
8714 * Return value is the address of the modified column
8715 */
8716 static ObjectAddress
8717 ATExecSetStatistics(Relation rel, const char *colName, int16 colNum, Node *newValue, LOCKMODE lockmode)
8718 {
8721 Relation attrelation;
8722 HeapTuple tuple,
8723 newtuple;
8724 Form_pg_attribute attrtuple;
8725 AttrNumber attnum;
8726 ObjectAddress address;
8731 /*
8732 * We allow referencing columns by numbers only for indexes, since table
8733 * column numbers could contain gaps if columns are later dropped.
8734 */
8742 /* -1 was used in previous versions for the default setting */
8744 {
8747 }
8748 else
8752 {
8753 /*
8754 * Limit target to a sane range
8755 */
8757 {
8761 newtarget)));
8762 }
8764 {
8769 newtarget)));
8770 }
8771 }
8776 {
8784 }
8785 else
8786 {
8794 }
8803 colName)));
8807 {
8819 }
8821 /* Build new tuple. */
8826 else
8846 }
8848 /*
8849 * Return value is the address of the modified column
8850 */
8851 static ObjectAddress
8854 {
8855 Relation attrelation;
8856 HeapTuple tuple,
8857 newtuple;
8858 Form_pg_attribute attrtuple;
8859 AttrNumber attnum;
8860 Datum datum,
8861 newOptions;
8863 ObjectAddress address;
8884 colName)));
8886 /* Generate new proposed attoptions (text array) */
8892 /* Validate new options */
8895 /* Build new tuple. */
8900 else
8906 /* Update system catalog. */
8922 }
8924 /*
8925 * Helper function for ATExecSetStorage and ATExecSetCompression
8926 *
8927 * Set the attstorage and/or attcompression fields for index columns
8928 * associated with the specified table column.
8929 */
8930 static void
8932 AttrNumber attnum,
8935 LOCKMODE lockmode)
8936 {
8940 {
8942 Relation indrel;
8944 HeapTuple tuple;
8949 {
8951 {
8954 }
8955 }
8958 {
8961 }
8966 {
8982 }
8985 }
8986 }
8988 /*
8989 * ALTER TABLE ALTER COLUMN SET STORAGE
8990 *
8991 * Return value is the address of the modified column
8992 */
8993 static ObjectAddress
8995 {
8996 Relation attrelation;
8997 HeapTuple tuple;
8998 Form_pg_attribute attrtuple;
8999 AttrNumber attnum;
9000 ObjectAddress address;
9018 colName)));
9028 /*
9029 * Apply the change to indexes as well (only for simple index columns,
9030 * matching behavior of index.c ConstructTupleDescriptor()).
9031 */
9035 lockmode);
9044 }
9047 /*
9048 * ALTER TABLE DROP COLUMN
9049 *
9050 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
9051 * because we have to decide at runtime whether to recurse or not depending
9052 * on whether attinhcount goes to zero or not. (We can't check this in a
9053 * static pre-pass because it won't handle multiple inheritance situations
9054 * correctly.)
9055 */
9056 static void
9060 {
9071 }
9073 /*
9074 * Drops column 'colName' from relation 'rel' and returns the address of the
9075 * dropped column. The column is also dropped (or marked as no longer
9076 * inherited from relation) from the relation's inheritance children, if any.
9077 *
9078 * In the recursive invocations for inheritance child relations, instead of
9079 * dropping the column directly (if to be dropped at all), its object address
9080 * is added to 'addrs', which must be non-NULL in such invocations. All
9081 * columns are dropped at the same time after all the children have been
9082 * checked recursively.
9083 */
9084 static ObjectAddress
9086 DropBehavior behavior,
9090 {
9091 HeapTuple tuple;
9092 Form_pg_attribute targetatt;
9093 AttrNumber attnum;
9095 ObjectAddress object;
9098 /* At top level, permission check was done in ATPrepCmd, else do it */
9102 /* Initialize addrs on the first invocation */
9105 /* since this function recurses, it could be driven to stack overflow */
9111 /*
9112 * get the number of the attribute
9113 */
9116 {
9118 {
9123 }
9124 else
9125 {
9130 }
9131 }
9136 /* Can't drop a system attribute */
9141 colName)));
9143 /*
9144 * Don't drop inherited columns, unless recursing (presumably from a drop
9145 * of the parent column)
9146 */
9151 colName)));
9153 /*
9154 * Don't drop columns used in the partition key, either. (If we let this
9155 * go through, the key column's dependencies would cause a cascaded drop
9156 * of the whole table, which is surely not what the user expected.)
9157 */
9168 /*
9169 * Propagate to children as appropriate. Unlike most other ALTER
9170 * routines, we have to do this one level of recursion at a time; we can't
9171 * use find_all_inheritors to do it in one pass.
9172 */
9173 children =
9177 {
9178 Relation attr_rel;
9181 /*
9182 * In case of a partitioned table, the column must be dropped from the
9183 * partitions as well.
9184 */
9193 {
9195 Relation childrel;
9196 Form_pg_attribute childatt;
9198 /* find_inheritance_children already got lock */
9213 {
9214 /*
9215 * If the child column has other definition sources, just
9216 * decrement its inheritance count; if not, recurse to delete
9217 * it.
9218 */
9220 {
9221 /* Time to delete this child column, too */
9225 }
9226 else
9227 {
9228 /* Child column must survive my deletion */
9233 /* Make update visible */
9235 }
9236 }
9237 else
9238 {
9239 /*
9240 * If we were told to drop ONLY in this table (no recursion),
9241 * we need to mark the inheritors' attributes as locally
9242 * defined rather than inherited.
9243 */
9249 /* Make update visible */
9251 }
9256 }
9258 }
9260 /* Add object to delete */
9267 {
9268 /* Recursion has ended, drop everything that was collected */
9271 }
9274 }
9276 /*
9277 * Prepare to add a primary key on an inheritance parent, by adding NOT NULL
9278 * constraint on its children.
9279 */
9280 static void
9283 {
9289 /* No work if not creating a primary key */
9296 /* No work if no legacy inheritance children are present */
9304 {
9322 }
9325 {
9335 {
9336 /* ATPrepCmd copies newcmd, so we can scribble on it here */
9341 }
9344 }
9345 }
9347 /*
9348 * ALTER TABLE ADD INDEX
9349 *
9350 * There is no such command in the grammar, but parse_utilcmd.c converts
9351 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
9352 * us schedule creation of the index at the appropriate time during ALTER.
9353 *
9354 * Return value is the address of the new index.
9355 */
9356 static ObjectAddress
9359 {
9363 ObjectAddress address;
9368 /* The IndexStmt has already been through transformIndexStmt */
9371 /* suppress schema rights check when rebuilding existing index */
9373 /* skip index build if phase 3 will do it or we're reusing an old one */
9375 /* suppress notices when rebuilding existing index */
9379 stmt,
9385 check_rights,
9387 skip_build,
9388 quiet);
9390 /*
9391 * If TryReuseIndex() stashed a relfilenumber for us, we used it for the
9392 * new index instead of building from scratch. Restore associated fields.
9393 * This may store InvalidSubTransactionId in both fields, in which case
9394 * relcache.c will assume it can rebuild the relcache entry. Hence, do
9395 * this after the CCI that made catalog rows visible to any rebuild. The
9396 * DROP of the old edition of this index will have scheduled the storage
9397 * for deletion at commit, so cancel that pending deletion.
9398 */
9400 {
9407 }
9410 }
9412 /*
9413 * ALTER TABLE ADD STATISTICS
9414 *
9415 * This is no such command in the grammar, but we use this internally to add
9416 * AT_ReAddStatistics subcommands to rebuild extended statistics after a table
9417 * column type change.
9418 */
9419 static ObjectAddress
9422 {
9423 ObjectAddress address;
9427 /* The CreateStatsStmt has already been through transformStatsStmt */
9433 }
9435 /*
9436 * ALTER TABLE ADD CONSTRAINT USING INDEX
9437 *
9438 * Returns the address of the new constraint.
9439 */
9440 static ObjectAddress
9443 {
9445 Relation indexRel;
9450 ObjectAddress address;
9451 bits16 flags;
9457 /*
9458 * Doing this on partitioned tables is not a simple feature to implement,
9459 * so let's punt for now.
9460 */
9472 /* this should have been checked at parse time */
9476 /*
9477 * Determine name to assign to constraint. We require a constraint to
9478 * have the same name as the underlying index; therefore, use the index's
9479 * existing name as the default constraint name, and if the user
9480 * explicitly gives some other name for the constraint, rename the index
9481 * to match.
9482 */
9487 {
9492 }
9494 /* Extra checks needed if making primary key */
9498 /* Note we currently don't support EXCLUSION constraints here */
9501 else
9504 /* Create the catalog entries for the constraint */
9506 INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
9512 index_oid,
9513 InvalidOid,
9514 indexInfo,
9515 constraintName,
9516 constraintType,
9517 flags,
9518 allowSystemTableMods,
9524 }
9526 /*
9527 * ALTER TABLE ADD CONSTRAINT
9528 *
9529 * Return value is the address of the new constraint; if no constraint was
9530 * added, InvalidObjectAddress is returned.
9531 */
9532 static ObjectAddress
9535 LOCKMODE lockmode)
9536 {
9541 /*
9542 * Currently, we only expect to see CONSTR_CHECK, CONSTR_NOTNULL and
9543 * CONSTR_FOREIGN nodes arriving here (see the preprocessing done in
9544 * parse_utilcmd.c).
9545 */
9547 {
9550 address =
9553 lockmode);
9558 /*
9559 * Assign or validate constraint name
9560 */
9562 {
9571 }
9572 else
9578 NIL);
9581 newConstraint,
9583 lockmode);
9589 }
9592 }
9594 /*
9595 * Generate the column-name portion of the constraint name for a new foreign
9596 * key given the list of column names that reference the referenced
9597 * table. This will be passed to ChooseConstraintName along with the parent
9598 * table name and the "fkey" suffix.
9599 *
9600 * We know that less than NAMEDATALEN characters will actually be used, so we
9601 * can truncate the result once we've generated that many.
9602 *
9603 * XXX see also ChooseExtendedStatisticNameAddition and
9604 * ChooseIndexNameAddition.
9605 */
9608 {
9615 {
9621 /*
9622 * At this point we have buflen <= NAMEDATALEN. name should be less
9623 * than NAMEDATALEN already, but use strlcpy for paranoia.
9624 */
9629 }
9631 }
9633 /*
9634 * Add a check or not-null constraint to a single table and its children.
9635 * Returns the address of the constraint added to the parent relation,
9636 * if one gets added, or InvalidObjectAddress otherwise.
9637 *
9638 * Subroutine for ATExecAddConstraint.
9639 *
9640 * We must recurse to child tables during execution, rather than using
9641 * ALTER TABLE's normal prep-time recursion. The reason is that all the
9642 * constraints *must* be given the same name, else they won't be seen as
9643 * related later. If the user didn't explicitly specify a name, then
9644 * AddRelationNewConstraints would normally assign different names to the
9645 * child constraints. To fix that, we must capture the name assigned at
9646 * the parent table and pass that down.
9647 */
9648 static ObjectAddress
9652 {
9659 /* Guard against stack overflow due to overly deep inheritance tree. */
9662 /* At top level, permission check was done in ATPrepCmd, else do it */
9666 /*
9667 * Call AddRelationNewConstraints to do the work, making sure it works on
9668 * a copy of the Constraint so transformExpr can't modify the original. It
9669 * returns a list of cooked constraints.
9670 *
9671 * If the constraint ends up getting merged with a pre-existing one, it's
9672 * omitted from the returned list, which is what we want: we do not need
9673 * to do any validation work. That can only happen at child tables,
9674 * though, since we disallow merging at the top level.
9675 */
9682 * here */
9684 /* we don't expect more than one constraint here */
9687 /* Add each to-be-validated constraint to Phase 3's queue */
9689 {
9693 {
9702 }
9704 /* Save the actually assigned name if it was defaulted */
9708 /*
9709 * If adding a not-null constraint, set the pg_attribute flag and tell
9710 * phase 3 to verify existing rows, if needed.
9711 */
9717 }
9719 /* At this point we must have a locked-down name to use */
9722 /* Advance command counter in case same table is visited multiple times */
9725 /*
9726 * If the constraint got merged with an existing constraint, we're done.
9727 * We mustn't recurse to child tables in this case, because they've
9728 * already got the constraint, and visiting them again would lead to an
9729 * incorrect value for coninhcount.
9730 */
9734 /*
9735 * If adding a NO INHERIT constraint, no need to find our children.
9736 */
9740 /*
9741 * Propagate to children as appropriate. Unlike most other ALTER
9742 * routines, we have to do this one level of recursion at a time; we can't
9743 * use find_all_inheritors to do it in one pass.
9744 */
9745 children =
9748 /*
9749 * Check if ONLY was specified with ALTER TABLE. If so, allow the
9750 * constraint creation only if there are no children currently. Error out
9751 * otherwise.
9752 */
9758 /*
9759 * The constraint must appear as inherited in children, so create a
9760 * modified constraint object to use.
9761 */
9765 {
9767 Relation childrel;
9770 /* find_inheritance_children already got lock */
9774 /* Find or create work queue entry for this table */
9777 /*
9778 * Recurse to child. XXX if we didn't create a constraint on the
9779 * parent because it already existed, and we do create one on a child,
9780 * should we return that child's constraint ObjectAddress here?
9781 */
9786 }
9789 }
9791 /*
9792 * Add a foreign-key constraint to a single table; return the new constraint's
9793 * address.
9794 *
9795 * Subroutine for ATExecAddConstraint. Must already hold exclusive
9796 * lock on the rel, and have done appropriate validity checks for it.
9797 * We do permissions checks here, however.
9798 *
9799 * When the referenced or referencing tables (or both) are partitioned,
9800 * multiple pg_constraint rows are required -- one for each partitioned table
9801 * and each partition on each side (fortunately, not one for every combination
9802 * thereof). We also need action triggers on each leaf partition on the
9803 * referenced side, and check triggers on each leaf partition on the
9804 * referencing side.
9805 */
9806 static ObjectAddress
9810 {
9811 Relation pkrel;
9825 numpks,
9826 numfkdelsetcols;
9827 Oid indexOid;
9829 ObjectAddress address;
9832 /*
9833 * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
9834 * delete rows out from under us.
9835 */
9838 else
9841 /*
9842 * Validity checks (permission checks wait till we have the column
9843 * numbers)
9844 */
9846 {
9850 errmsg("cannot use ONLY for foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9856 errmsg("cannot add NOT VALID foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9860 }
9875 /*
9876 * References from permanent or unlogged tables to temp tables, and from
9877 * permanent tables to unlogged tables, are disallowed because the
9878 * referenced data can vanish out from under us. References from temp
9879 * tables to any other table type are also disallowed, because other
9880 * backends might need to run the RI triggers on the perm table, but they
9881 * can't reliably see tuples in the local buffers of other backends.
9882 */
9884 {
9908 }
9910 /*
9911 * Look up the referencing attributes to make sure they exist, and record
9912 * their attnums and type OIDs.
9913 */
9930 /*
9931 * If the attribute list for the referenced table was omitted, lookup the
9932 * definition of the primary key and use it. Otherwise, validate the
9933 * supplied attribute list. In either case, discover the index OID and
9934 * index opclasses, and the attnums and type OIDs of the attributes.
9935 */
9937 {
9943 /* If the primary key uses WITHOUT OVERLAPS, the fk must use PERIOD */
9948 }
9949 else
9950 {
9955 /* Since we got pk_attrs, one should be a period. */
9961 /* Look for an index matching the column list */
9964 }
9966 /*
9967 * If the referenced primary key has WITHOUT OVERLAPS, the foreign key
9968 * must use PERIOD.
9969 */
9975 /*
9976 * Now we can check permissions.
9977 */
9980 /*
9981 * Check some things for generated columns.
9982 */
9984 {
9988 {
9989 /*
9990 * Check restrictions on UPDATE/DELETE actions, per SQL standard
9991 */
10005 }
10006 }
10008 /*
10009 * Some actions are currently unsupported for foreign keys using PERIOD.
10010 */
10012 {
10028 }
10030 /*
10031 * Look up the equality operators to use in the constraint.
10032 *
10033 * Note that we have to be careful about the difference between the actual
10034 * PK column type and the opclass' declared input type, which might be
10035 * only binary-compatible with it. The declared opcintype is the right
10036 * thing to probe pg_amop with.
10037 */
10043 /*
10044 * On the strength of a previous constraint, we might avoid scanning
10045 * tables to validate this one. See below.
10046 */
10051 {
10054 Oid fktyped;
10055 HeapTuple cla_ht;
10056 Form_pg_opclass cla_tup;
10057 Oid amid;
10058 Oid opfamily;
10059 Oid opcintype;
10060 Oid pfeqop;
10061 Oid ppeqop;
10062 Oid ffeqop;
10063 int16 eqstrategy;
10064 Oid pfeqop_right;
10066 /* We need several fields out of the pg_opclass entry */
10077 {
10078 StrategyNumber rtstrategy;
10081 /*
10082 * GiST indexes are required to support temporal foreign keys
10083 * because they combine equals and overlaps.
10084 */
10090 /*
10091 * An opclass can use whatever strategy numbers it wants, so we
10092 * ask the opclass what number it actually uses instead of our RT*
10093 * constants.
10094 */
10097 {
10098 HeapTuple tuple;
10106 for_overlaps
10109 errdetail("Could not translate strategy number %d for operator class \"%s\" for access method \"%s\".",
10111 }
10112 }
10113 else
10114 {
10115 /*
10116 * Check it's a btree; currently this can never fail since no
10117 * other index AMs support unique indexes. If we ever did have
10118 * other types of unique indexes, we'd need a way to determine
10119 * which operator strategy number is equality. (We could use
10120 * something like GistTranslateStratnum.)
10121 */
10125 }
10127 /*
10128 * There had better be a primary equality operator for the index.
10129 * We'll use it for PK = PK comparisons.
10130 */
10132 eqstrategy);
10138 /*
10139 * Are there equality operators that take exactly the FK type? Assume
10140 * we should look through any domain here.
10141 */
10145 eqstrategy);
10147 {
10150 eqstrategy);
10151 }
10152 else
10153 {
10154 /* keep compiler quiet */
10157 }
10160 {
10161 /*
10162 * Otherwise, look for an implicit cast from the FK type to the
10163 * opcintype, and if found, use the primary equality operator.
10164 * This is a bit tricky because opcintype might be a polymorphic
10165 * type such as ANYARRAY or ANYENUM; so what we have to test is
10166 * whether the two actual column types can be concurrently cast to
10167 * that type. (Otherwise, we'd fail to reject combinations such
10168 * as int[] and point[].)
10169 */
10178 COERCION_IMPLICIT))
10179 {
10182 }
10183 }
10198 {
10199 /*
10200 * When a pfeqop changes, revalidate the constraint. We could
10201 * permit intra-opfamily changes, but that adds subtle complexity
10202 * without any concrete benefit for core types. We need not
10203 * assess ppeqop or ffeqop, which RI_Initial_Check() does not use.
10204 */
10207 old_pfeqop_item);
10208 }
10210 {
10211 Oid old_fktype;
10212 Oid new_fktype;
10213 CoercionPathType old_pathtype;
10214 CoercionPathType new_pathtype;
10215 Oid old_castfunc;
10216 Oid new_castfunc;
10220 /*
10221 * Identify coercion pathways from each of the old and new FK-side
10222 * column types to the right (foreign) operand type of the pfeqop.
10223 * We may assume that pg_constraint.conkey is not changing.
10224 */
10232 /*
10233 * Upon a change to the cast from the FK column to its pfeqop
10234 * operand, revalidate the constraint. For this evaluation, a
10235 * binary coercion cast is equivalent to no cast at all. While
10236 * type implementors should design implicit casts with an eye
10237 * toward consistency of operations like equality, we cannot
10238 * assume here that they have done so.
10239 *
10240 * A function with a polymorphic argument could change behavior
10241 * arbitrarily in response to get_fn_expr_argtype(). Therefore,
10242 * when the cast destination is polymorphic, we only avoid
10243 * revalidation if the input type has not changed at all. Given
10244 * just the core data types and operator classes, this requirement
10245 * prevents no would-be optimizations.
10246 *
10247 * If the cast converts from a base type to a domain thereon, then
10248 * that domain type must be the opcintype of the unique index.
10249 * Necessarily, the primary key column must then be of the domain
10250 * type. Since the constraint was previously valid, all values on
10251 * the foreign side necessarily exist on the primary side and in
10252 * turn conform to the domain. Consequently, we need not treat
10253 * domains specially here.
10254 *
10255 * Since we require that all collations share the same notion of
10256 * equality (which they do, because texteq reduces to bitwise
10257 * equality), we don't compare collation here.
10258 *
10259 * We need not directly consider the PK type. It's necessarily
10260 * binary coercible to the opcintype of the unique index column,
10261 * and ri_triggers.c will only deal with PK datums in terms of
10262 * that opcintype. Changing the opcintype also changes pfeqop.
10263 */
10268 }
10273 }
10275 /*
10276 * For FKs with PERIOD we need additional operators to check whether the
10277 * referencing row's range is contained by the aggregated ranges of the
10278 * referenced row(s). For rangetypes and multirangetypes this is
10279 * fk.periodatt <@ range_agg(pk.periodatt). Those are the only types we
10280 * support for now. FKs will look these up at "runtime", but we should
10281 * make sure the lookup works here, even if we don't use the values.
10282 */
10284 {
10285 Oid periodoperoid;
10286 Oid aggedperiodoperoid;
10289 }
10291 /*
10292 * Create all the constraint and trigger objects, recursing to partitions
10293 * as necessary. First handle the referenced side.
10294 */
10296 indexOid,
10298 numfks,
10299 pkattnum,
10300 fkattnum,
10301 pfeqoperators,
10302 ppeqoperators,
10303 ffeqoperators,
10304 numfkdelsetcols,
10305 fkdelsetcols,
10306 old_check_ok,
10308 with_period);
10310 /* Now handle the referencing side. */
10312 indexOid,
10314 numfks,
10315 pkattnum,
10316 fkattnum,
10317 pfeqoperators,
10318 ppeqoperators,
10319 ffeqoperators,
10320 numfkdelsetcols,
10321 fkdelsetcols,
10322 old_check_ok,
10323 lockmode,
10325 with_period);
10327 /*
10328 * Done. Close pk table, but keep lock until we've committed.
10329 */
10333 }
10335 /*
10336 * validateFkOnDeleteSetColumns
10337 * Verifies that columns used in ON DELETE SET NULL/DEFAULT (...)
10338 * column lists are valid.
10339 */
10340 void
10344 {
10346 {
10351 {
10353 {
10356 }
10357 }
10360 {
10365 errmsg("column \"%s\" referenced in ON DELETE SET action must be part of foreign key", col)));
10366 }
10367 }
10368 }
10370 /*
10371 * addFkRecurseReferenced
10372 * subroutine for ATAddForeignKeyConstraint; recurses on the referenced
10373 * side of the constraint
10374 *
10375 * Create pg_constraint rows for the referenced side of the constraint,
10376 * referencing the parent of the referencing side; also create action triggers
10377 * on leaf partitions. If the table is partitioned, recurse to handle each
10378 * partition.
10379 *
10380 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10381 * of an ALTER TABLE sequence.
10382 * fkconstraint is the constraint being added.
10383 * rel is the root referencing relation.
10384 * pkrel is the referenced relation; might be a partition, if recursing.
10385 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10386 * parentConstr is the OID of a parent constraint; InvalidOid if this is a
10387 * top-level constraint.
10388 * numfks is the number of columns in the foreign key
10389 * pkattnum is the attnum array of referenced attributes.
10390 * fkattnum is the attnum array of referencing attributes.
10391 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10392 * (...) clause
10393 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10394 * NULL/DEFAULT clause
10395 * pf/pp/ffeqoperators are OID array of operators between columns.
10396 * old_check_ok signals that this constraint replaces an existing one that
10397 * was already validated (thus this one doesn't need validation).
10398 * parentDelTrigger and parentUpdTrigger, when being recursively called on
10399 * a partition, are the OIDs of the parent action triggers for DELETE and
10400 * UPDATE respectively.
10401 */
10402 static ObjectAddress
10412 {
10413 ObjectAddress address;
10414 Oid constrOid;
10419 Oid deleteTriggerOid,
10420 updateTriggerOid;
10422 /*
10423 * Verify relkind for each referenced partition. At the top level, this
10424 * is redundant with a previous check, but we need it when recursing.
10425 */
10433 /*
10434 * Caller supplies us with a constraint name; however, it may be used in
10435 * this partition, so come up with a different one in that case.
10436 */
10444 else
10448 {
10452 }
10453 else
10454 {
10458 /*
10459 * always inherit for partitioned tables, never for legacy inheritance
10460 */
10462 }
10464 /*
10465 * Record the FK constraint in pg_constraint.
10466 */
10469 CONSTRAINT_FOREIGN,
10473 parentConstr,
10475 fkattnum,
10476 numfks,
10477 numfks,
10479 indexOid,
10481 pkattnum,
10482 pfeqoperators,
10483 ppeqoperators,
10484 ffeqoperators,
10485 numfks,
10488 fkdelsetcols,
10489 numfkdelsetcols,
10493 NULL,
10502 /*
10503 * Mark the child constraint as part of the parent constraint; it must not
10504 * be dropped on its own. (This constraint is deleted when the partition
10505 * is detached, but a special check needs to occur that the partition
10506 * contains no referenced values.)
10507 */
10509 {
10510 ObjectAddress referenced;
10514 }
10516 /* make new constraint visible, in case we add more */
10519 /*
10520 * Create the action triggers that enforce the constraint.
10521 */
10523 fkconstraint,
10528 /*
10529 * If the referenced table is partitioned, recurse on ourselves to handle
10530 * each partition. We need one pg_constraint row created for each
10531 * partition in addition to the pg_constraint row for the parent table.
10532 */
10534 {
10538 {
10539 Relation partRel;
10542 Oid partIndexId;
10546 /*
10547 * Map the attribute numbers in the referenced side of the FK
10548 * definition to match the partition's column layout.
10549 */
10554 {
10558 }
10559 else
10562 /* do the deed */
10572 old_check_ok,
10574 with_period);
10576 /* Done -- clean up (but keep the lock) */
10579 {
10582 }
10583 }
10584 }
10587 }
10589 /*
10590 * addFkRecurseReferencing
10591 * subroutine for ATAddForeignKeyConstraint and CloneFkReferencing
10592 *
10593 * If the referencing relation is a plain relation, create the necessary check
10594 * triggers that implement the constraint, and set up for Phase 3 constraint
10595 * verification. If the referencing relation is a partitioned table, then
10596 * we create a pg_constraint row for it and recurse on this routine for each
10597 * partition.
10598 *
10599 * We assume that the referenced relation is locked against concurrent
10600 * deletions. If it's a partitioned relation, every partition must be so
10601 * locked.
10602 *
10603 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10604 * of an ALTER TABLE sequence.
10605 * fkconstraint is the constraint being added.
10606 * rel is the referencing relation; might be a partition, if recursing.
10607 * pkrel is the root referenced relation.
10608 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10609 * parentConstr is the OID of the parent constraint (there is always one).
10610 * numfks is the number of columns in the foreign key
10611 * pkattnum is the attnum array of referenced attributes.
10612 * fkattnum is the attnum array of referencing attributes.
10613 * pf/pp/ffeqoperators are OID array of operators between columns.
10614 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10615 * (...) clause
10616 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10617 * NULL/DEFAULT clause
10618 * old_check_ok signals that this constraint replaces an existing one that
10619 * was already validated (thus this one doesn't need validation).
10620 * lockmode is the lockmode to acquire on partitions when recursing.
10621 * parentInsTrigger and parentUpdTrigger, when being recursively called on
10622 * a partition, are the OIDs of the parent check triggers for INSERT and
10623 * UPDATE respectively.
10624 */
10625 static void
10634 {
10635 Oid insertTriggerOid,
10636 updateTriggerOid;
10645 /*
10646 * Add the check triggers to it and, if necessary, schedule it to be
10647 * checked in Phase 3.
10648 *
10649 * If the relation is partitioned, drill down to do it to its partitions.
10650 */
10653 fkconstraint,
10654 parentConstr,
10655 indexOid,
10660 {
10661 /*
10662 * Tell Phase 3 to check that the constraint is satisfied by existing
10663 * rows. We can skip this during table creation, when requested
10664 * explicitly by specifying NOT VALID in an ADD FOREIGN KEY command,
10665 * and when we're recreating a constraint following a SET DATA TYPE
10666 * operation that did not impugn its validity.
10667 */
10669 {
10685 }
10686 }
10688 {
10690 Relation trigrel;
10692 /*
10693 * Triggers of the foreign keys will be manipulated a bunch of times
10694 * in the loop below. To avoid repeatedly opening/closing the trigger
10695 * catalog relation, we open it here and pass it to the subroutines
10696 * called below.
10697 */
10700 /*
10701 * Recurse to take appropriate action on each partition; either we
10702 * find an existing constraint to reparent to ours, or we create a new
10703 * one.
10704 */
10706 {
10714 Oid constrOid;
10715 ObjectAddress address,
10716 referenced;
10727 /* Check whether an existing constraint can be repurposed */
10731 {
10736 partitionId,
10737 parentConstr,
10738 numfks,
10739 mapped_fkattnum,
10740 pkattnum,
10741 pfeqoperators,
10742 insertTriggerOid,
10743 updateTriggerOid,
10744 trigrel))
10745 {
10748 }
10749 }
10751 {
10754 }
10756 /*
10757 * No luck finding a good constraint to reuse; create our own.
10758 */
10766 else
10768 constrOid =
10771 CONSTRAINT_FOREIGN,
10775 parentConstr,
10776 partitionId,
10777 mapped_fkattnum,
10778 numfks,
10779 numfks,
10780 InvalidOid,
10781 indexOid,
10783 pkattnum,
10784 pfeqoperators,
10785 ppeqoperators,
10786 ffeqoperators,
10787 numfks,
10790 fkdelsetcols,
10791 numfkdelsetcols,
10793 NULL,
10794 NULL,
10795 NULL,
10802 /*
10803 * Give this constraint partition-type dependencies on the parent
10804 * constraint as well as the table.
10805 */
10812 /* Make all this visible before recursing */
10815 /* call ourselves to finalize the creation and we're done */
10817 indexOid,
10818 constrOid,
10819 numfks,
10820 pkattnum,
10821 mapped_fkattnum,
10822 pfeqoperators,
10823 ppeqoperators,
10824 ffeqoperators,
10825 numfkdelsetcols,
10826 fkdelsetcols,
10827 old_check_ok,
10828 lockmode,
10829 insertTriggerOid,
10830 updateTriggerOid,
10831 with_period);
10834 }
10837 }
10838 }
10840 /*
10841 * CloneForeignKeyConstraints
10842 * Clone foreign keys from a partitioned table to a newly acquired
10843 * partition.
10844 *
10845 * partitionRel is a partition of parentRel, so we can be certain that it has
10846 * the same columns with the same datatypes. The columns may be in different
10847 * order, though.
10848 *
10849 * wqueue must be passed to set up phase 3 constraint checking, unless the
10850 * referencing-side partition is known to be empty (such as in CREATE TABLE /
10851 * PARTITION OF).
10852 */
10853 static void
10855 Relation partitionRel)
10856 {
10857 /* This only works for declarative partitioning */
10860 /*
10861 * Clone constraints for which the parent is on the referenced side.
10862 */
10865 /*
10866 * Now clone constraints where the parent is on the referencing side.
10867 */
10869 }
10871 /*
10872 * CloneFkReferenced
10873 * Subroutine for CloneForeignKeyConstraints
10874 *
10875 * Find all the FKs that have the parent relation on the referenced side;
10876 * clone those constraints to the given partition. This is to be called
10877 * when the partition is being created or attached.
10878 *
10879 * This ignores self-referencing FKs; those are handled by CloneFkReferencing.
10880 *
10881 * This recurses to partitions, if the relation being attached is partitioned.
10882 * Recursion is done by calling addFkRecurseReferenced.
10883 */
10884 static void
10886 {
10887 Relation pg_constraint;
10890 SysScanDesc scan;
10892 HeapTuple tuple;
10894 Relation trigrel;
10896 /*
10897 * Search for any constraints where this partition's parent is in the
10898 * referenced side. However, we must not clone any constraint whose
10899 * parent constraint is also going to be cloned, to avoid duplicates. So
10900 * do it in two steps: first construct the list of constraints to clone,
10901 * then go over that list cloning those whose parents are not in the list.
10902 * (We must not rely on the parent being seen first, since the catalog
10903 * scan could return children first.)
10904 */
10912 /* This is a seqscan, as we don't have a usable index ... */
10916 {
10920 }
10924 /*
10925 * Triggers of the foreign keys will be manipulated a bunch of times in
10926 * the loop below. To avoid repeatedly opening/closing the trigger
10927 * catalog relation, we open it here and pass it to the subroutines called
10928 * below.
10929 */
10936 {
10938 Form_pg_constraint constrForm;
10939 Relation fkRel;
10940 Oid indexOid;
10941 Oid partIndexId;
10952 Oid deleteTriggerOid,
10953 updateTriggerOid;
10960 /*
10961 * As explained above: don't try to clone a constraint for which we're
10962 * going to clone the parent.
10963 */
10965 {
10968 }
10970 /*
10971 * Don't clone self-referencing foreign keys, which can be in the
10972 * partitioned table or in the partition-to-be.
10973 */
10976 {
10979 }
10981 /*
10982 * Because we're only expanding the key space at the referenced side,
10983 * we don't need to prevent any operation in the referencing table, so
10984 * AccessShareLock suffices (assumes that dropping the constraint
10985 * acquires AEL).
10986 */
10992 conkey,
10993 confkey,
10994 conpfeqop,
10995 conppeqop,
10996 conffeqop,
10998 confdelsetcols);
11010 /* ->fk_attrs determined below */
11021 /* set up colnames that are used to generate the constraint name */
11023 {
11024 Form_pg_attribute att;
11030 }
11032 /*
11033 * Add the new foreign key constraint pointing to the new partition.
11034 * Because this new partition appears in the referenced side of the
11035 * constraint, we don't need to set up for Phase 3 check.
11036 */
11042 /*
11043 * Get the "action" triggers belonging to the constraint to pass as
11044 * parent OIDs for similar triggers that will be created on the
11045 * partition in addFkRecurseReferenced().
11046 */
11052 fkconstraint,
11053 fkRel,
11054 partitionRel,
11055 partIndexId,
11056 constrOid,
11057 numfks,
11058 mapped_confkey,
11059 conkey,
11060 conpfeqop,
11061 conppeqop,
11062 conffeqop,
11063 numfkdelsetcols,
11064 confdelsetcols,
11066 deleteTriggerOid,
11067 updateTriggerOid,
11072 }
11075 }
11077 /*
11078 * CloneFkReferencing
11079 * Subroutine for CloneForeignKeyConstraints
11080 *
11081 * For each FK constraint of the parent relation in the given list, find an
11082 * equivalent constraint in its partition relation that can be reparented;
11083 * if one cannot be found, create a new constraint in the partition as its
11084 * child.
11085 *
11086 * If wqueue is given, it is used to set up phase-3 verification for each
11087 * cloned constraint; if omitted, we assume that such verification is not
11088 * needed (example: the partition is being created anew).
11089 */
11090 static void
11092 {
11097 Relation trigrel;
11099 /* obtain a list of constraints that we need to clone */
11101 {
11105 }
11107 /*
11108 * Silently do nothing if there's nothing to do. In particular, this
11109 * avoids throwing a spurious error for foreign tables.
11110 */
11119 /*
11120 * Triggers of the foreign keys will be manipulated a bunch of times in
11121 * the loop below. To avoid repeatedly opening/closing the trigger
11122 * catalog relation, we open it here and pass it to the subroutines called
11123 * below.
11124 */
11127 /*
11128 * The constraint key may differ, if the columns in the partition are
11129 * different. This map is used to convert them.
11130 */
11138 {
11140 Form_pg_constraint constrForm;
11141 Relation pkrel;
11142 HeapTuple tuple;
11154 Oid indexOid;
11155 Oid constrOid;
11156 ObjectAddress address,
11157 referenced;
11159 Oid insertTriggerOid,
11160 updateTriggerOid;
11166 parentConstrOid);
11169 /* Don't clone constraints whose parents are being cloned */
11171 {
11174 }
11176 /*
11177 * Need to prevent concurrent deletions. If pkrel is a partitioned
11178 * relation, that means to lock all partitions.
11179 */
11191 /*
11192 * Get the "check" triggers belonging to the constraint to pass as
11193 * parent OIDs for similar triggers that will be created on the
11194 * partition in addFkRecurseReferencing(). They are also passed to
11195 * tryAttachPartitionForeignKey() below to simply assign as parents to
11196 * the partition's existing "check" triggers, that is, if the
11197 * corresponding constraints is deemed attachable to the parent
11198 * constraint.
11199 */
11204 /*
11205 * Before creating a new constraint, see whether any existing FKs are
11206 * fit for the purpose. If one is, attach the parent constraint to
11207 * it, and don't clone anything. This way we avoid the expensive
11208 * verification step and don't end up with a duplicate FK, and we
11209 * don't need to recurse to partitions for this constraint.
11210 */
11213 {
11218 parentConstrOid,
11219 numfks,
11220 mapped_conkey,
11221 confkey,
11222 conpfeqop,
11223 insertTriggerOid,
11224 updateTriggerOid,
11225 trigrel))
11226 {
11230 }
11231 }
11233 {
11236 }
11238 /* No dice. Set up to create our own constraint */
11241 /* ->conname determined below */
11246 /* ->fk_attrs determined below */
11257 {
11258 Form_pg_attribute att;
11264 }
11273 else
11278 constrOid =
11281 CONSTRAINT_FOREIGN,
11285 parentConstrOid,
11287 mapped_conkey,
11288 numfks,
11289 numfks,
11291 indexOid,
11293 confkey,
11294 conpfeqop,
11295 conppeqop,
11296 conffeqop,
11297 numfks,
11300 confdelsetcols,
11301 numfkdelsetcols,
11303 NULL,
11304 NULL,
11305 NULL,
11312 /* Set up partition dependencies for the new constraint */
11320 /* Done with the cloned constraint's tuple */
11323 /* Make all this visible before recursing */
11327 fkconstraint,
11328 partRel,
11329 pkrel,
11330 indexOid,
11331 constrOid,
11332 numfks,
11333 confkey,
11334 mapped_conkey,
11335 conpfeqop,
11336 conppeqop,
11337 conffeqop,
11338 numfkdelsetcols,
11339 confdelsetcols,
11341 AccessExclusiveLock,
11342 insertTriggerOid,
11343 updateTriggerOid,
11344 with_period);
11346 }
11349 }
11351 /*
11352 * When the parent of a partition receives [the referencing side of] a foreign
11353 * key, we must propagate that foreign key to the partition. However, the
11354 * partition might already have an equivalent foreign key; this routine
11355 * compares the given ForeignKeyCacheInfo (in the partition) to the FK defined
11356 * by the other parameters. If they are equivalent, create the link between
11357 * the two constraints and return true.
11358 *
11359 * If the given FK does not match the one defined by rest of the params,
11360 * return false.
11361 */
11362 static bool
11364 Oid partRelid,
11365 Oid parentConstrOid,
11370 Oid parentInsTrigger,
11371 Oid parentUpdTrigger,
11372 Relation trigrel)
11373 {
11374 HeapTuple parentConstrTup;
11375 Form_pg_constraint parentConstr;
11376 HeapTuple partcontup;
11377 Form_pg_constraint partConstr;
11378 ScanKeyData key;
11379 SysScanDesc scan;
11380 HeapTuple trigtup;
11381 Oid insertTriggerOid,
11382 updateTriggerOid;
11390 /*
11391 * Do some quick & easy initial checks. If any of these fail, we cannot
11392 * use this constraint.
11393 */
11395 {
11398 }
11400 {
11404 {
11407 }
11408 }
11410 /*
11411 * Looks good so far; do some more extensive checks. Presumably the check
11412 * for 'convalidated' could be dropped, since we don't really care about
11413 * that, but let's be careful for now.
11414 */
11427 {
11431 }
11436 /*
11437 * Looks good! Attach this constraint. The action triggers in the new
11438 * partition become redundant -- the parent table already has equivalent
11439 * ones, and those will be able to reach the partition. Remove the ones
11440 * in the partition. We identify them because they have our constraint
11441 * OID, as well as being on the referenced rel.
11442 */
11444 Anum_pg_trigger_tgconstraint,
11450 {
11452 ObjectAddress trigger;
11459 /*
11460 * The constraint is originally set up to contain this trigger as an
11461 * implementation object, so there's a dependency record that links
11462 * the two; however, since the trigger is no longer needed, we remove
11463 * the dependency link in order to be able to drop the trigger while
11464 * keeping the constraint intact.
11465 */
11469 /* make dependency deletion visible to performDeletion */
11474 /* make trigger drop visible, in case the loop iterates */
11476 }
11482 /*
11483 * Like the constraint, attach partition's "check" triggers to the
11484 * corresponding parent triggers.
11485 */
11491 partRelid);
11494 partRelid);
11498 }
11500 /*
11501 * GetForeignKeyActionTriggers
11502 * Returns delete and update "action" triggers of the given relation
11503 * belonging to the given constraint
11504 */
11505 static void
11510 {
11511 ScanKeyData key;
11512 SysScanDesc scan;
11513 HeapTuple trigtup;
11517 Anum_pg_trigger_tgconstraint,
11524 {
11531 /* Only ever look at "action" triggers on the PK side. */
11535 {
11538 }
11540 {
11543 }
11544 #ifndef USE_ASSERT_CHECKING
11545 /* In an assert-enabled build, continue looking to find duplicates */
11548 #endif
11549 }
11553 conoid);
11556 conoid);
11559 }
11561 /*
11562 * GetForeignKeyCheckTriggers
11563 * Returns insert and update "check" triggers of the given relation
11564 * belonging to the given constraint
11565 */
11566 static void
11571 {
11572 ScanKeyData key;
11573 SysScanDesc scan;
11574 HeapTuple trigtup;
11578 Anum_pg_trigger_tgconstraint,
11585 {
11592 /* Only ever look at "check" triggers on the FK side. */
11596 {
11599 }
11601 {
11604 }
11605 #ifndef USE_ASSERT_CHECKING
11606 /* In an assert-enabled build, continue looking to find duplicates. */
11609 #endif
11610 }
11614 conoid);
11617 conoid);
11620 }
11622 /*
11623 * ALTER TABLE ALTER CONSTRAINT
11624 *
11625 * Update the attributes of a constraint.
11626 *
11627 * Currently only works for Foreign Key constraints.
11628 *
11629 * If the constraint is modified, returns its address; otherwise, return
11630 * InvalidObjectAddress.
11631 */
11632 static ObjectAddress
11635 {
11637 Relation conrel;
11638 Relation tgrel;
11639 SysScanDesc scan;
11641 HeapTuple contuple;
11642 Form_pg_constraint currcon;
11643 ObjectAddress address;
11652 /*
11653 * Find and check the target constraint
11654 */
11656 Anum_pg_constraint_conrelid,
11660 Anum_pg_constraint_contypid,
11664 Anum_pg_constraint_conname,
11670 /* There can be at most one matching row */
11684 /*
11685 * If it's not the topmost constraint, raise an error.
11686 *
11687 * Altering a non-topmost constraint leaves some triggers untouched, since
11688 * they are not directly connected to this constraint; also, pg_dump would
11689 * ignore the deferrability status of the individual constraint, since it
11690 * only dumps topmost constraints. Avoid these problems by refusing this
11691 * operation and telling the user to alter the parent constraint instead.
11692 */
11694 {
11695 HeapTuple tp;
11700 /* Loop to find the topmost constraint */
11702 {
11705 /* If no parent, this is the constraint we want */
11707 {
11712 }
11716 }
11725 }
11727 /*
11728 * Do the actual catalog work. We can skip changing if already in the
11729 * desired state, but not if a partitioned table: partitions need to be
11730 * processed regardless, in case they had the constraint locally changed.
11731 */
11736 {
11740 }
11742 /*
11743 * ATExecAlterConstrRecurse already invalidated relcache for the relations
11744 * having the constraint itself; here we also invalidate for relations
11745 * that have any triggers that are part of the constraint.
11746 */
11756 }
11758 /*
11759 * Recursive subroutine of ATExecAlterConstraint. Returns true if the
11760 * constraint is altered.
11761 *
11762 * *otherrelids is appended OIDs of relations containing affected triggers.
11763 *
11764 * Note that we must recurse even when the values are correct, in case
11765 * indirect descendants have had their constraints altered locally.
11766 * (This could be avoided if we forbade altering constraints in partitions
11767 * but existing releases don't do that.)
11768 */
11769 static bool
11772 LOCKMODE lockmode)
11773 {
11774 Form_pg_constraint currcon;
11775 Oid conoid;
11776 Oid refrelid;
11779 /* since this function recurses, it could be driven to stack overflow */
11786 /*
11787 * Update pg_constraint with the flags from cmdcon.
11788 *
11789 * If called to modify a constraint that's already in the desired state,
11790 * silently do nothing.
11791 */
11794 {
11795 HeapTuple copyTuple;
11796 Form_pg_constraint copy_con;
11797 HeapTuple tgtuple;
11798 ScanKeyData tgkey;
11799 SysScanDesc tgscan;
11813 /* Make new constraint flags visible to others */
11816 /*
11817 * Now we need to update the multiple entries in pg_trigger that
11818 * implement the constraint.
11819 */
11821 Anum_pg_trigger_tgconstraint,
11827 {
11829 Form_pg_trigger copy_tg;
11830 HeapTuple tgCopyTuple;
11832 /*
11833 * Remember OIDs of other relation(s) involved in FK constraint.
11834 * (Note: it's likely that we could skip forcing a relcache inval
11835 * for other rels that don't have a trigger whose properties
11836 * change, but let's be conservative.)
11837 */
11842 /*
11843 * Update deferrability of RI_FKey_noaction_del,
11844 * RI_FKey_noaction_upd, RI_FKey_check_ins and RI_FKey_check_upd
11845 * triggers, but not others; see createForeignKeyActionTriggers
11846 * and CreateFKCheckTrigger.
11847 */
11864 }
11867 }
11869 /*
11870 * If the table at either end of the constraint is partitioned, we need to
11871 * recurse and handle every constraint that is a child of this one.
11872 *
11873 * (This assumes that the recurse flag is forcibly set for partitioned
11874 * tables, and not set for legacy inheritance, though we don't check for
11875 * that here.)
11876 */
11879 {
11880 ScanKeyData pkey;
11881 SysScanDesc pscan;
11882 HeapTuple childtup;
11885 Anum_pg_constraint_conparentid,
11893 {
11895 Relation childrel;
11901 }
11904 }
11907 }
11909 /*
11910 * ALTER TABLE VALIDATE CONSTRAINT
11911 *
11912 * XXX The reason we handle recursion here rather than at Phase 1 is because
11913 * there's no good way to skip recursing when handling foreign keys: there is
11914 * no need to lock children in that case, yet we wouldn't be able to avoid
11915 * doing so at that level.
11916 *
11917 * Return value is the address of the validated constraint. If the constraint
11918 * was already validated, InvalidObjectAddress is returned.
11919 */
11920 static ObjectAddress
11923 {
11924 Relation conrel;
11925 SysScanDesc scan;
11927 HeapTuple tuple;
11928 Form_pg_constraint con;
11929 ObjectAddress address;
11933 /*
11934 * Find and check the target constraint
11935 */
11937 Anum_pg_constraint_conrelid,
11941 Anum_pg_constraint_contypid,
11945 Anum_pg_constraint_conname,
11951 /* There can be at most one matching row */
11967 {
11969 HeapTuple copyTuple;
11970 Form_pg_constraint copy_con;
11973 {
11977 /* Queue validation for phase 3 */
11979 /* for now this is all we need */
11990 /* Find or create work queue entry for this table */
11994 /*
11995 * We disallow creating invalid foreign keys to or from
11996 * partitioned tables, so ignoring the recursion bit is okay.
11997 */
11998 }
12000 {
12004 Datum val;
12007 /*
12008 * If we're recursing, the parent has already done this, so skip
12009 * it. Also, if the constraint is a NO INHERIT constraint, we
12010 * shouldn't try to look for it in the children.
12011 */
12016 /*
12017 * For CHECK constraints, we must ensure that we only mark the
12018 * constraint as validated on the parent if it's already validated
12019 * on the children.
12020 *
12021 * We recurse before validating on the parent, to reduce risk of
12022 * deadlocks.
12023 */
12025 {
12027 Relation childrel;
12032 /*
12033 * If we are told not to recurse, there had better not be any
12034 * child tables, because we can't mark the constraint on the
12035 * parent valid unless it is valid for all child tables.
12036 */
12042 /* find_all_inheritors already got lock */
12048 }
12050 /* Queue validation for phase 3 */
12059 Anum_pg_constraint_conbin);
12063 /* Find or create work queue entry for this table */
12067 /*
12068 * Invalidate relcache so that others see the new validated
12069 * constraint.
12070 */
12072 }
12074 /*
12075 * Now update the catalog, while we have the door open.
12076 */
12087 }
12088 else
12096 }
12099 /*
12100 * transformColumnNameList - transform list of column names
12101 *
12102 * Lookup each name and return its attnum and, optionally, type OID
12103 *
12104 * Note: the name of this function suggests that it's general-purpose,
12105 * but actually it's only used to look up names appearing in foreign-key
12106 * clauses. The error messages would need work to use it in other cases,
12107 * and perhaps the validity checks as well.
12108 */
12109 static int
12112 {
12118 {
12120 HeapTuple atttuple;
12121 Form_pg_attribute attform;
12128 attname)));
12138 INDEX_MAX_KEYS)));
12143 attnum++;
12144 }
12147 }
12149 /*
12150 * transformFkeyGetPrimaryKey -
12151 *
12152 * Look up the names, attnums, and types of the primary key attributes
12153 * for the pkrel. Also return the index OID and index opclasses of the
12154 * index supporting the primary key. Also return whether the index has
12155 * WITHOUT OVERLAPS.
12156 *
12157 * All parameters except pkrel are output parameters. Also, the function
12158 * return value is the number of attributes in the primary key.
12159 *
12160 * Used when the column list in the REFERENCES specification is omitted.
12161 */
12162 static int
12167 {
12172 Datum indclassDatum;
12176 /*
12177 * Get the list of index OIDs for the table from the relcache, and look up
12178 * each one in the pg_index syscache until we find one marked primary key
12179 * (hopefully there isn't more than one such). Insist it's valid, too.
12180 */
12186 {
12194 {
12195 /*
12196 * Refuse to use a deferrable primary key. This is per SQL spec,
12197 * and there would be a lot of interesting semantic problems if we
12198 * tried to allow it.
12199 */
12208 }
12210 }
12214 /*
12215 * Check that we found it
12216 */
12223 /* Must get indclass the hard way */
12225 Anum_pg_index_indclass);
12228 /*
12229 * Now build the list of PK attributes from the indkey definition (we
12230 * assume a primary key cannot have expressional elements)
12231 */
12234 {
12242 }
12249 }
12251 /*
12252 * transformFkeyCheckAttrs -
12253 *
12254 * Validate that the 'attnums' columns in the 'pkrel' relation are valid to
12255 * reference as part of a foreign key constraint.
12256 *
12257 * Returns the OID of the unique index supporting the constraint and
12258 * populates the caller-provided 'opclasses' array with the opclasses
12259 * associated with the index columns. Also sets whether the index
12260 * uses WITHOUT OVERLAPS.
12261 *
12262 * Raises an ERROR on validation failure.
12263 */
12264 static Oid
12269 {
12276 j;
12278 /*
12279 * Reject duplicate appearances of columns in the referenced-columns list.
12280 * Such a case is forbidden by the SQL standard, and even if we thought it
12281 * useful to allow it, there would be ambiguity about how to match the
12282 * list to unique indexes (in particular, it'd be unclear which index
12283 * opclass goes with which FK column).
12284 */
12286 {
12288 {
12293 }
12294 }
12296 /*
12297 * Get the list of index OIDs for the table from the relcache, and look up
12298 * each one in the pg_index syscache, and match unique indexes to the list
12299 * of attnums we are given.
12300 */
12304 {
12305 HeapTuple indexTuple;
12306 Form_pg_index indexStruct;
12314 /*
12315 * Must have the right number of columns; must be unique (or if
12316 * temporal then exclusion instead) and not a partial index; forget it
12317 * if there are any expressions, too. Invalid indexes are out as well.
12318 */
12324 {
12325 Datum indclassDatum;
12328 /* Must get indclass the hard way */
12330 Anum_pg_index_indclass);
12333 /*
12334 * The given attnum list may match the index columns in any order.
12335 * Check for a match, and extract the appropriate opclasses while
12336 * we're at it.
12337 *
12338 * We know that attnums[] is duplicate-free per the test at the
12339 * start of this function, and we checked above that the number of
12340 * index columns agrees, so if we find a match for each attnums[]
12341 * entry then we must have a one-to-one match in some order.
12342 */
12344 {
12347 {
12349 {
12353 }
12354 }
12357 }
12358 /* The last attribute in the index must be the PERIOD FK part */
12360 {
12364 }
12366 /*
12367 * Refuse to use a deferrable unique/primary key. This is per SQL
12368 * spec, and there would be a lot of interesting semantic problems
12369 * if we tried to allow it.
12370 */
12372 {
12373 /*
12374 * Remember that we found an otherwise matching index, so that
12375 * we can generate a more appropriate error message.
12376 */
12379 }
12381 /* We need to know whether the index has WITHOUT OVERLAPS */
12384 }
12388 }
12391 {
12397 else
12402 }
12407 }
12409 /*
12410 * findFkeyCast -
12411 *
12412 * Wrapper around find_coercion_pathway() for ATAddForeignKeyConstraint().
12413 * Caller has equal regard for binary coercibility and for an exact match.
12414 */
12415 static CoercionPathType
12417 {
12418 CoercionPathType ret;
12421 {
12424 }
12425 else
12426 {
12430 /* A previously-relied-upon cast is now gone. */
12433 }
12436 }
12438 /*
12439 * Permissions checks on the referenced table for ADD FOREIGN KEY
12440 *
12441 * Note: we have already checked that the user owns the referencing table,
12442 * else we'd have failed much earlier; no additional checks are needed for it.
12443 */
12444 static void
12446 {
12448 AclResult aclresult;
12451 /* Okay if we have relation-level REFERENCES permission */
12453 ACL_REFERENCES);
12456 /* Else we must have REFERENCES on each column */
12458 {
12464 }
12465 }
12467 /*
12468 * Scan the existing rows in a table to verify they meet a proposed FK
12469 * constraint.
12470 *
12471 * Caller must have opened and locked both relations appropriately.
12472 */
12473 static void
12475 Relation rel,
12476 Relation pkrel,
12477 Oid pkindOid,
12478 Oid constraintOid,
12480 {
12482 TableScanDesc scan;
12484 Snapshot snapshot;
12485 MemoryContext oldcxt;
12486 MemoryContext perTupCxt;
12491 /*
12492 * Build a trigger call structure; we'll need it either way.
12493 */
12503 /* we needn't fill in remaining fields */
12505 /*
12506 * See if we can do it with a single LEFT JOIN query. A false result
12507 * indicates we must proceed with the fire-the-trigger method. We can't do
12508 * a LEFT JOIN for temporal FKs yet, but we can once we support temporal
12509 * left joins.
12510 */
12514 /*
12515 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
12516 * if that tuple had just been inserted. If any of those fail, it should
12517 * ereport(ERROR) and that's that.
12518 */
12525 ALLOCSET_SMALL_SIZES);
12529 {
12535 /*
12536 * Make a call to the trigger function
12537 *
12538 * No parameters are passed, but we do set a context
12539 */
12542 /*
12543 * We assume RI_FKey_check_ins won't look at flinfo...
12544 */
12557 }
12564 }
12566 /*
12567 * CreateFKCheckTrigger
12568 * Creates the insert (on_insert=true) or update "check" trigger that
12569 * implements a given foreign key
12570 *
12571 * Returns the OID of the so created trigger.
12572 */
12573 static Oid
12577 {
12578 ObjectAddress trigAddress;
12581 /*
12582 * Note: for a self-referential FK (referencing and referenced tables are
12583 * the same), it is important that the ON UPDATE action fires before the
12584 * CHECK action, since both triggers will fire on the same row during an
12585 * UPDATE event; otherwise the CHECK trigger will be checking a non-final
12586 * state of the row. Triggers fire in name order, so we ensure this by
12587 * using names like "RI_ConstraintTrigger_a_NNNN" for the action triggers
12588 * and "RI_ConstraintTrigger_c_NNNN" for the check triggers.
12589 */
12596 /* Either ON INSERT or ON UPDATE */
12598 {
12601 }
12602 else
12603 {
12606 }
12622 /* Make changes-so-far visible */
12626 }
12628 /*
12629 * createForeignKeyActionTriggers
12630 * Create the referenced-side "action" triggers that implement a foreign
12631 * key.
12632 *
12633 * Returns the OIDs of the so created triggers in *deleteTrigOid and
12634 * *updateTrigOid.
12635 */
12636 static void
12641 {
12643 ObjectAddress trigAddress;
12645 /*
12646 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12647 * DELETE action on the referenced table.
12648 */
12664 {
12694 }
12703 /* Make changes-so-far visible */
12706 /*
12707 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12708 * UPDATE action on the referenced table.
12709 */
12725 {
12755 }
12763 }
12765 /*
12766 * createForeignKeyCheckTriggers
12767 * Create the referencing-side "check" triggers that implement a foreign
12768 * key.
12769 *
12770 * Returns the OIDs of the so created triggers in *insertTrigOid and
12771 * *updateTrigOid.
12772 */
12773 static void
12776 Oid indexOid,
12779 {
12786 }
12788 /*
12789 * ALTER TABLE DROP CONSTRAINT
12790 *
12791 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
12792 */
12793 static void
12797 {
12798 Relation conrel;
12799 SysScanDesc scan;
12801 HeapTuple tuple;
12806 /*
12807 * Find and drop the target constraint
12808 */
12810 Anum_pg_constraint_conrelid,
12814 Anum_pg_constraint_contypid,
12818 Anum_pg_constraint_conname,
12824 /* There can be at most one matching row */
12826 {
12832 }
12837 {
12843 else
12847 }
12850 }
12852 /*
12853 * Remove a constraint, using its pg_constraint tuple
12854 *
12855 * Implementation for ALTER TABLE DROP CONSTRAINT and ALTER TABLE ALTER COLUMN
12856 * DROP NOT NULL.
12857 *
12858 * Returns the address of the constraint being removed.
12859 */
12860 static ObjectAddress
12863 LOCKMODE lockmode)
12864 {
12865 Relation conrel;
12866 Form_pg_constraint con;
12867 ObjectAddress conobj;
12880 /* Guard against stack overflow due to overly deep inheritance tree. */
12883 /* At top level, permission check was done in ATPrepCmd, else do it */
12892 /* Don't allow drop of inherited constraints */
12899 /*
12900 * See if we have a not-null constraint or a PRIMARY KEY. If so, we have
12901 * more checks and actions below, so obtain the list of columns that are
12902 * constrained by the constraint being dropped.
12903 */
12905 {
12910 }
12912 {
12913 Datum adatum;
12936 }
12940 /*
12941 * If it's a foreign-key constraint, we'd better lock the referenced table
12942 * and check that that's not in use, just as we've already done for the
12943 * constrained table (else we might, eg, be dropping a trigger that has
12944 * unfired events). But we can/must skip that in the self-referential
12945 * case.
12946 */
12949 {
12950 Relation frel;
12952 /* Must match lock taken by RemoveTriggerById: */
12956 }
12958 /*
12959 * Perform the actual constraint deletion
12960 */
12964 /*
12965 * If this was a NOT NULL or the primary key, the constrained columns must
12966 * have had pg_attribute.attnotnull set. See if we need to reset it, and
12967 * do so.
12968 */
12970 {
12971 Relation attrel;
12976 /* Make the above deletion visible */
12981 /*
12982 * We want to test columns for their presence in the primary key, but
12983 * only if we're not dropping it.
12984 */
12987 INDEX_ATTR_BITMAP_PRIMARY_KEY);
12991 {
12993 HeapTuple atttup;
12994 HeapTuple contup;
12995 Form_pg_attribute attForm;
12997 /*
12998 * Obtain pg_attribute tuple and verify conditions on it. We use
12999 * a copy we can scribble on.
13000 */
13007 /*
13008 * Since the above deletion has been made visible, we can now
13009 * search for any remaining constraints on this column (or these
13010 * columns, in the case we're dropping a multicol primary key.)
13011 * Then, verify whether any further NOT NULL or primary key
13012 * exists, and reset attnotnull if none.
13013 *
13014 * However, if this is a generated identity column, abort the
13015 * whole thing with a specific error message, because the
13016 * constraint is required in that case.
13017 */
13021 pkcols))
13024 /*
13025 * It's not valid to drop the not-null constraint for a GENERATED
13026 * AS IDENTITY column.
13027 */
13036 /*
13037 * It's not valid to drop the not-null constraint for a column in
13038 * the replica identity index, either. (FULL is not affected.)
13039 */
13046 /* Reset attnotnull */
13048 {
13051 }
13052 }
13054 }
13056 /*
13057 * For partitioned tables, non-CHECK, non-NOT-NULL inherited constraints
13058 * are dropped via the dependency mechanism, so we're done here.
13059 */
13063 {
13066 }
13068 /*
13069 * Propagate to children as appropriate. Unlike most other ALTER
13070 * routines, we have to do this one level of recursion at a time; we can't
13071 * use find_all_inheritors to do it in one pass.
13072 */
13075 else
13078 /*
13079 * For a partitioned table, if partitions exist and we are told not to
13080 * recurse, it's a user error. It doesn't make sense to have a constraint
13081 * be defined only on the parent, especially if it's a partitioned table.
13082 */
13090 /* For not-null constraints we recurse by column name */
13094 else
13098 {
13100 Relation childrel;
13101 HeapTuple tuple;
13102 Form_pg_constraint childcon;
13107 /* find_inheritance_children already got lock */
13111 /*
13112 * We search for not-null constraint by column number, and other
13113 * constraints by name.
13114 */
13116 {
13121 }
13122 else
13123 {
13124 SysScanDesc scan;
13128 Anum_pg_constraint_conrelid,
13132 Anum_pg_constraint_contypid,
13136 Anum_pg_constraint_conname,
13141 /* There can only be one, so no need to loop */
13147 constrName,
13151 }
13155 /* Right now only CHECK and not-null constraints can be inherited */
13165 {
13166 /*
13167 * If the child constraint has other definition sources, just
13168 * decrement its inheritance count; if not, recurse to delete it.
13169 */
13171 {
13172 /* Time to delete this child constraint, too */
13175 lockmode);
13176 }
13177 else
13178 {
13179 /* Child constraint must survive my deletion */
13183 /* Make update visible */
13185 }
13186 }
13187 else
13188 {
13189 /*
13190 * If we were told to drop ONLY in this table (no recursion) and
13191 * there are no further parents for this constraint, we need to
13192 * mark the inheritors' constraints as locally defined rather than
13193 * inherited.
13194 */
13201 /* Make update visible */
13203 }
13208 }
13210 /*
13211 * In addition, when dropping a primary key from a legacy-inheritance
13212 * parent table, we must recurse to children to mark the corresponding NOT
13213 * NULL constraint as no longer inherited, or drop it if this its last
13214 * reference.
13215 */
13219 {
13224 /*
13225 * Because primary keys are always marked as NO INHERIT, we don't have
13226 * a list of children yet, so obtain one now.
13227 */
13230 /*
13231 * Find out the list of column names to process. Fortunately, we
13232 * already have the list of column numbers.
13233 */
13235 {
13238 }
13241 {
13243 Relation childrel;
13248 /* find_inheritance_children already got lock */
13253 {
13254 HeapTuple contup;
13265 lockmode);
13267 }
13272 }
13273 }
13278 }
13280 /*
13281 * ALTER COLUMN TYPE
13282 *
13283 * Unlike other subcommand types, we do parse transformation for ALTER COLUMN
13284 * TYPE during phase 1 --- the AlterTableCmd passed in here is already
13285 * transformed (and must be, because we rely on some transformed fields).
13286 *
13287 * The point of this is that the execution of all ALTER COLUMN TYPEs for a
13288 * table will be done "in parallel" during phase 3, so all the USING
13289 * expressions should be parsed assuming the original column types. Also,
13290 * this allows a USING expression to refer to a field that will be dropped.
13291 *
13292 * To make this work safely, AT_PASS_DROP then AT_PASS_ALTER_TYPE must be
13293 * the first two execution steps in phase 2; they must not see the effects
13294 * of any other subcommand types, since the USING expressions are parsed
13295 * against the unmodified table's state.
13296 */
13297 static void
13303 {
13308 HeapTuple tuple;
13309 Form_pg_attribute attTup;
13310 AttrNumber attnum;
13311 Oid targettype;
13312 int32 targettypmod;
13313 Oid targetcollid;
13316 AclResult aclresult;
13324 /* lookup the attribute so we can check inheritance status */
13334 /* Can't alter a system attribute */
13339 colName)));
13341 /*
13342 * Don't alter inherited columns. At outer level, there had better not be
13343 * any inherited definition; when recursing, we assume this was checked at
13344 * the parent level (see below).
13345 */
13350 colName)));
13352 /* Don't alter columns used in the partition key */
13358 errmsg("cannot alter column \"%s\" because it is part of the partition key of relation \"%s\"",
13361 /* Look up the target type */
13368 /* And the collation */
13371 /* make sure datatype is legal for a column */
13378 {
13379 /*
13380 * Set up an expression to transform the old data value to the new
13381 * type. If a USING option was given, use the expression as
13382 * transformed by transformAlterTableStmt, else just take the old
13383 * value and try to coerce it. We do this first so that type
13384 * incompatibility can be detected before we waste effort, and because
13385 * we need the expression to be parsed against the original table row
13386 * type.
13387 */
13389 {
13394 }
13399 COERCION_ASSIGNMENT,
13400 COERCE_IMPLICIT_CAST,
13403 {
13404 /* error text depends on whether USING was specified or not */
13412 else
13417 /* translator: USING is SQL, don't translate it */
13421 targettypmod))));
13422 }
13424 /* Fix collations after all else */
13427 /* Plan the expr now so we can accurately assess the need to rewrite. */
13430 /*
13431 * Add a work queue item to make ATRewriteTable update the column
13432 * contents.
13433 */
13442 }
13450 {
13451 /*
13452 * For relations without storage, do this check now. Regular tables
13453 * will check it later when the table is being rewritten.
13454 */
13456 }
13460 /*
13461 * Recurse manually by queueing a new command for each child, if
13462 * necessary. We cannot apply ATSimpleRecursion here because we need to
13463 * remap attribute numbers in the USING expression, if any.
13464 *
13465 * If we are told not to recurse, there had better not be any child
13466 * tables; else the alter would put them out of step.
13467 */
13469 {
13479 /*
13480 * find_all_inheritors does the recursive search of the inheritance
13481 * hierarchy, so all we have to do is process all of the relids in the
13482 * list that it returns.
13483 */
13485 {
13488 Relation childrel;
13489 HeapTuple childtuple;
13490 Form_pg_attribute childattTup;
13495 /* find_all_inheritors already got lock */
13499 /*
13500 * Verify that the child doesn't have any inherited definitions of
13501 * this column that came from outside this inheritance hierarchy.
13502 * (renameatt makes a similar test, though in a different way
13503 * because of its different recursion mechanism.)
13504 */
13506 colName);
13522 /*
13523 * Remap the attribute numbers. If no USING expression was
13524 * specified, there is no need for this step.
13525 */
13527 {
13531 /* create a copy to scribble on */
13540 attmap,
13548 }
13551 }
13552 }
13558 colName)));
13562 }
13564 /*
13565 * When the data type of a column is changed, a rewrite might not be required
13566 * if the new type is sufficiently identical to the old one, and the USING
13567 * clause isn't trying to insert some other value. It's safe to skip the
13568 * rewrite in these cases:
13569 *
13570 * - the old type is binary coercible to the new type
13571 * - the new type is an unconstrained domain over the old type
13572 * - {NEW,OLD} or {OLD,NEW} is {timestamptz,timestamp} and the timezone is UTC
13573 *
13574 * In the case of a constrained domain, we could get by with scanning the
13575 * table and checking the constraint rather than actually rewriting it, but we
13576 * don't currently try to do that.
13577 */
13578 static bool
13580 {
13584 {
13585 /* only one varno, so no need to check that */
13591 {
13597 }
13599 {
13603 {
13608 else
13613 }
13614 }
13615 else
13617 }
13618 }
13620 /*
13621 * ALTER COLUMN .. SET DATA TYPE
13622 *
13623 * Return the address of the modified column.
13624 */
13625 static ObjectAddress
13628 {
13632 HeapTuple heapTup;
13633 Form_pg_attribute attTup,
13634 attOldTup;
13635 AttrNumber attnum;
13636 HeapTuple typeTuple;
13637 Form_pg_type tform;
13638 Oid targettype;
13639 int32 targettypmod;
13640 Oid targetcollid;
13642 Relation attrelation;
13643 Relation depRel;
13645 SysScanDesc scan;
13646 HeapTuple depTup;
13647 ObjectAddress address;
13649 /*
13650 * Clear all the missing values if we're rewriting the table, since this
13651 * renders them pointless.
13652 */
13654 {
13655 Relation newrel;
13660 /* make sure we don't conflict with later attribute modifications */
13662 }
13666 /* Look up the target column */
13677 /* Check for multiple ALTER TYPE on same column --- can't cope */
13683 colName)));
13685 /* Look up the target type (should not fail, since prep found it) */
13689 /* And the collation */
13692 /*
13693 * If there is a default expression for the column, get it and ensure we
13694 * can coerce it to the new datatype. (We must do this before changing
13695 * the column type, because build_column_default itself will try to
13696 * coerce, and will not issue the error message we want if it fails.)
13697 *
13698 * We remove any implicit coercion steps at the top level of the old
13699 * default expression; this has been agreed to satisfy the principle of
13700 * least surprise. (The conversion to the new column type should act like
13701 * it started from what the user sees as the stored expression, and the
13702 * implicit coercions aren't going to be shown.)
13703 */
13705 {
13712 COERCION_ASSIGNMENT,
13713 COERCE_IMPLICIT_CAST,
13716 {
13722 else
13727 }
13728 }
13729 else
13732 /*
13733 * Find everything that depends on the column (constraints, indexes, etc),
13734 * and record enough information to let us recreate the objects.
13735 *
13736 * The actual recreation does not happen here, but only after we have
13737 * performed all the individual ALTER TYPE operations. We have to save
13738 * the info before executing ALTER TYPE, though, else the deparser will
13739 * get confused.
13740 */
13743 /*
13744 * Now scan for dependencies of this column on other things. The only
13745 * things we should find are the dependency on the column datatype and
13746 * possibly a collation dependency. Those can be removed.
13747 */
13751 Anum_pg_depend_classid,
13755 Anum_pg_depend_objid,
13759 Anum_pg_depend_objsubid,
13767 {
13769 ObjectAddress foundObject;
13786 }
13792 /*
13793 * Here we go --- change the recorded column type and collation. (Note
13794 * heapTup is a copy of the syscache entry, so okay to scribble on.) First
13795 * fix up the missing value if any.
13796 */
13798 {
13799 Datum missingval;
13802 /* if rewrite is true the missing value should already be cleared */
13805 /* Get the missing value datum */
13807 Anum_pg_attribute_attmissingval,
13811 /* if it's a null array there is nothing to do */
13814 {
13815 /*
13816 * Get the datum out of the array and repack it in a new array
13817 * built with the new type data. We assume that since the table
13818 * doesn't need rewriting, the actual Datum doesn't need to be
13819 * changed, only the array metadata.
13820 */
13827 HeapTuple newTup;
13839 targettype,
13853 }
13854 }
13876 /* Install dependencies on new datatype and collation */
13880 /*
13881 * Drop any pg_statistic entry for the column, since it's now wrong type
13882 */
13888 /*
13889 * Update the default, if present, by brute force --- remove and re-add
13890 * the default. Probably unsafe to take shortcuts, since the new version
13891 * may well have additional dependencies. (It's okay to do this now,
13892 * rather than after other ALTER TYPE commands, since the default won't
13893 * depend on other column types.)
13894 */
13896 {
13897 /*
13898 * If it's a GENERATED default, drop its dependency records, in
13899 * particular its INTERNAL dependency on the column, which would
13900 * otherwise cause dependency.c to refuse to perform the deletion.
13901 */
13903 {
13910 }
13912 /*
13913 * Make updates-so-far visible, particularly the new pg_attribute row
13914 * which will be updated again.
13915 */
13918 /*
13919 * We use RESTRICT here for safety, but at present we do not expect
13920 * anything to depend on the default.
13921 */
13926 }
13931 /* Cleanup */
13935 }
13937 /*
13938 * Subroutine for ATExecAlterColumnType and ATExecSetExpression: Find everything
13939 * that depends on the column (constraints, indexes, etc), and record enough
13940 * information to let us recreate the objects.
13941 */
13942 static void
13945 {
13946 Relation depRel;
13948 SysScanDesc scan;
13949 HeapTuple depTup;
13956 Anum_pg_depend_refclassid,
13960 Anum_pg_depend_refobjid,
13964 Anum_pg_depend_refobjsubid,
13972 {
13974 ObjectAddress foundObject;
13981 {
13983 {
13988 {
13991 }
13993 {
13994 /*
13995 * This must be a SERIAL column's sequence. We need
13996 * not do anything to it.
13997 */
13999 }
14000 else
14001 {
14002 /* Not expecting any other direct dependencies... */
14005 }
14007 }
14015 /* XXX someday see if we can cope with revising views */
14022 colName)));
14027 /*
14028 * A trigger can depend on a column because the column is
14029 * specified as an update target, or because the column is
14030 * used in the trigger's WHEN condition. The first case would
14031 * not require any extra work, but the second case would
14032 * require updating the WHEN expression, which will take a
14033 * significant amount of new code. Since we can't easily tell
14034 * which case applies, we punt for both. FIXME someday.
14035 */
14042 colName)));
14047 /*
14048 * A policy can depend on a column because the column is
14049 * specified in the policy's USING or WITH CHECK qual
14050 * expressions. It might be possible to rewrite and recheck
14051 * the policy expression, but punt for now. It's certainly
14052 * easy enough to remove and recreate the policy; still, FIXME
14053 * someday.
14054 */
14061 colName)));
14065 {
14070 {
14071 /*
14072 * Ignore the column's own default expression. The
14073 * caller deals with it.
14074 */
14075 }
14076 else
14077 {
14078 /*
14079 * This must be a reference from the expression of a
14080 * generated column elsewhere in the same table.
14081 * Changing the type/generated expression of a column
14082 * that is used by a generated column is not allowed
14083 * by SQL standard, so just punt for now. It might be
14084 * doable with some thinking and effort.
14085 */
14091 colName,
14095 }
14097 }
14101 /*
14102 * Give the extended-stats machinery a chance to fix anything
14103 * that this column type change would break.
14104 */
14143 /*
14144 * We don't expect any of these sorts of objects to depend on
14145 * a column.
14146 */
14151 /*
14152 * There's intentionally no default: case here; we want the
14153 * compiler to warn if a new OCLASS hasn't been handled above.
14154 */
14155 }
14156 }
14160 }
14162 /*
14163 * Subroutine for ATExecAlterColumnType: remember that a replica identity
14164 * needs to be reset.
14165 */
14166 static void
14168 {
14176 }
14178 /*
14179 * Subroutine for ATExecAlterColumnType: remember any clustered index.
14180 */
14181 static void
14183 {
14191 }
14193 /*
14194 * Subroutine for ATExecAlterColumnType: remember that a constraint needs
14195 * to be rebuilt (which we might already know).
14196 */
14197 static void
14199 {
14200 /*
14201 * This de-duplication check is critical for two independent reasons: we
14202 * mustn't try to recreate the same constraint twice, and if a constraint
14203 * depends on more than one column whose type is to be altered, we must
14204 * capture its definition string before applying any of the column type
14205 * changes. ruleutils.c will get confused if we ask again later.
14206 */
14208 {
14209 /* OK, capture the constraint's existing definition string */
14211 Oid indoid;
14214 conoid);
14216 defstring);
14218 /*
14219 * For the index of a constraint, if any, remember if it is used for
14220 * the table's replica identity or if it is a clustered index, so that
14221 * ATPostAlterTypeCleanup() can queue up commands necessary to restore
14222 * those properties.
14223 */
14226 {
14229 }
14230 }
14231 }
14233 /*
14234 * Subroutine for ATExecAlterColumnType: remember that an index needs
14235 * to be rebuilt (which we might already know).
14236 */
14237 static void
14239 {
14240 /*
14241 * This de-duplication check is critical for two independent reasons: we
14242 * mustn't try to recreate the same index twice, and if an index depends
14243 * on more than one column whose type is to be altered, we must capture
14244 * its definition string before applying any of the column type changes.
14245 * ruleutils.c will get confused if we ask again later.
14246 */
14248 {
14249 /*
14250 * Before adding it as an index-to-rebuild, we'd better see if it
14251 * belongs to a constraint, and if so rebuild the constraint instead.
14252 * Typically this check fails, because constraint indexes normally
14253 * have only dependencies on their constraint. But it's possible for
14254 * such an index to also have direct dependencies on table columns,
14255 * for example with a partial exclusion constraint.
14256 */
14260 {
14262 }
14263 else
14264 {
14265 /* OK, capture the index's existing definition string */
14269 indoid);
14271 defstring);
14273 /*
14274 * Remember if this index is used for the table's replica identity
14275 * or if it is a clustered index, so that ATPostAlterTypeCleanup()
14276 * can queue up commands necessary to restore those properties.
14277 */
14280 }
14281 }
14282 }
14284 /*
14285 * Subroutine for ATExecAlterColumnType: remember that a statistics object
14286 * needs to be rebuilt (which we might already know).
14287 */
14288 static void
14290 {
14291 /*
14292 * This de-duplication check is critical for two independent reasons: we
14293 * mustn't try to recreate the same statistics object twice, and if the
14294 * statistics object depends on more than one column whose type is to be
14295 * altered, we must capture its definition string before applying any of
14296 * the type changes. ruleutils.c will get confused if we ask again later.
14297 */
14299 {
14300 /* OK, capture the statistics object's existing definition string */
14304 stxoid);
14306 defstring);
14307 }
14308 }
14310 /*
14311 * Cleanup after we've finished all the ALTER TYPE or SET EXPRESSION
14312 * operations for a particular relation. We have to drop and recreate all the
14313 * indexes and constraints that depend on the altered columns. We do the
14314 * actual dropping here, but re-creation is managed by adding work queue
14315 * entries to do those steps later.
14316 */
14317 static void
14319 {
14320 ObjectAddress obj;
14325 /*
14326 * Collect all the constraints and indexes to drop so we can process them
14327 * in a single call. That way we don't have to worry about dependencies
14328 * among them.
14329 */
14332 /*
14333 * Re-parse the index and constraint definitions, and attach them to the
14334 * appropriate work queue entries. We do this before dropping because in
14335 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
14336 * lock on the table the constraint is attached to, and we need to get
14337 * that before reparsing/dropping.
14338 *
14339 * We can't rely on the output of deparsing to tell us which relation to
14340 * operate on, because concurrent activity might have made the name
14341 * resolve differently. Instead, we've got to use the OID of the
14342 * constraint or index we're processing to figure out which relation to
14343 * operate on.
14344 */
14347 {
14349 HeapTuple tup;
14350 Form_pg_constraint con;
14351 Oid relid;
14352 Oid confrelid;
14362 else
14363 {
14364 /* must be a domain constraint */
14368 }
14377 /*
14378 * If the constraint is inherited (only), we don't want to inject a
14379 * new definition here; it'll get recreated when
14380 * ATAddCheckNNConstraint recurses from adding the parent table's
14381 * constraint. But we had to carry the info this far so that we can
14382 * drop the constraint below.
14383 */
14387 /*
14388 * When rebuilding an FK constraint that references the table we're
14389 * modifying, we might not yet have any lock on the FK's table, so get
14390 * one now. We'll need AccessExclusiveLock for the DROP CONSTRAINT
14391 * step, so there's no value in asking for anything weaker.
14392 */
14399 }
14402 {
14404 Oid relid;
14413 }
14415 /* add dependencies for new statistics */
14418 {
14420 Oid relid;
14429 }
14431 /*
14432 * Queue up command to restore replica identity index marking
14433 */
14435 {
14444 /* do it after indexes and constraints */
14447 }
14449 /*
14450 * Queue up command to restore marking of index used for cluster.
14451 */
14453 {
14459 /* do it after indexes and constraints */
14462 }
14464 /*
14465 * It should be okay to use DROP_RESTRICT here, since nothing else should
14466 * be depending on these objects.
14467 */
14472 /*
14473 * The objects will get recreated during subsequent passes over the work
14474 * queue.
14475 */
14476 }
14478 /*
14479 * Parse the previously-saved definition string for a constraint, index or
14480 * statistics object against the newly-established column data type(s), and
14481 * queue up the resulting command parsetrees for execution.
14482 *
14483 * This might fail if, for example, you have a WHERE clause that uses an
14484 * operator that's not available for the new column type.
14485 */
14486 static void
14489 {
14493 Relation rel;
14495 /*
14496 * We expect that we will get only ALTER TABLE and CREATE INDEX
14497 * statements. Hence, there is no need to pass them through
14498 * parse_analyze_*() or the rewriter, but instead we need to pass them
14499 * through parse_utilcmd.c to make them ready for execution.
14500 */
14504 {
14512 cmd));
14514 {
14520 cmd,
14526 }
14531 cmd));
14532 else
14534 }
14536 /* Caller should already have acquired whatever lock we need. */
14539 /*
14540 * Attach each generated command to the proper place in the work queue.
14541 * Note this could result in creation of entirely new work-queue entries.
14542 *
14543 * Also note that we have to tweak the command subtypes, because it turns
14544 * out that re-creation of indexes and constraints has to act a bit
14545 * differently from initial creation.
14546 */
14548 {
14555 {
14562 /* keep the index's comment */
14570 }
14572 {
14577 {
14581 {
14583 Oid indoid;
14590 /* keep any comment on the index */
14599 /* recreate any comment on the constraint */
14601 AT_PASS_OLD_INDEX,
14602 oldId,
14603 rel,
14604 NIL,
14606 }
14608 {
14612 /* rewriting neither side of a FK */
14621 /* recreate any comment on the constraint */
14623 AT_PASS_OLD_CONSTR,
14624 oldId,
14625 rel,
14626 NIL,
14628 }
14630 {
14631 /*
14632 * The parser will create AT_AttSetNotNull subcommands for
14633 * columns of PRIMARY KEY indexes/constraints, but we need
14634 * not do anything with them here, because the columns'
14635 * NOT NULL marks will already have been propagated into
14636 * the new table definition.
14637 */
14638 }
14639 else
14642 }
14643 }
14645 {
14649 {
14658 /* recreate any comment on the constraint */
14660 AT_PASS_OLD_CONSTR,
14661 oldId,
14662 NULL,
14665 }
14666 else
14669 }
14671 {
14675 /* keep the statistics object's comment */
14683 }
14684 else
14687 }
14690 }
14692 /*
14693 * Subroutine for ATPostAlterTypeParse() to recreate any existing comment
14694 * for a table or domain constraint that is being rebuilt.
14695 *
14696 * objid is the OID of the constraint.
14697 * Pass "rel" for a table constraint, or "domname" (domain's qualified name
14698 * as a string list) for a domain constraint.
14699 * (We could dig that info, as well as the conname, out of the pg_constraint
14700 * entry; but callers already have them so might as well pass them.)
14701 */
14702 static void
14706 {
14711 /* Look for comment for object wanted, and leave if none */
14716 /* Build CommentStmt node, copying all input data for safety */
14719 {
14725 }
14726 else
14727 {
14732 }
14735 /* Append it to list of commands */
14740 }
14742 /*
14743 * Subroutine for ATPostAlterTypeParse(). Calls out to CheckIndexCompatible()
14744 * for the real analysis, then mutates the IndexStmt based on that verdict.
14745 */
14746 static void
14748 {
14754 {
14757 /* If it's a partitioned index, there is no storage to share. */
14759 {
14763 }
14765 }
14766 }
14768 /*
14769 * Subroutine for ATPostAlterTypeParse().
14770 *
14771 * Stash the old P-F equality operator into the Constraint node, for possible
14772 * use by ATAddForeignKeyConstraint() in determining whether revalidation of
14773 * this constraint can be skipped.
14774 */
14775 static void
14777 {
14778 HeapTuple tup;
14779 Datum adatum;
14793 Anum_pg_constraint_conpfeqop);
14796 /* test follows the one in ri_FetchConstraintInfo() */
14803 /* stash a List of the operator Oids in our Constraint node */
14808 }
14810 /*
14811 * ALTER COLUMN .. OPTIONS ( ... )
14812 *
14813 * Returns the address of the modified column
14814 */
14815 static ObjectAddress
14819 LOCKMODE lockmode)
14820 {
14821 Relation ftrel;
14822 Relation attrel;
14825 HeapTuple tuple;
14826 HeapTuple newtuple;
14831 Datum datum;
14832 Form_pg_foreign_table fttableform;
14833 Form_pg_attribute atttableform;
14834 AttrNumber attnum;
14835 ObjectAddress address;
14840 /* First, determine FDW validator associated to the foreign table. */
14863 /* Prevent them from altering a system attribute */
14872 /* Initialize buffers for new tuple values */
14877 /* Extract the current options */
14879 tuple,
14880 Anum_pg_attribute_attfdwoptions,
14885 /* Transform the options */
14887 datum,
14888 options,
14893 else
14898 /* Everything looks good - update the tuple */
14918 }
14920 /*
14921 * ALTER TABLE OWNER
14922 *
14923 * recursing is true if we are recursing from a table to its indexes,
14924 * sequences, or toast table. We don't allow the ownership of those things to
14925 * be changed separately from the parent table. Also, we can skip permission
14926 * checks (this is necessary not just an optimization, else we'd fail to
14927 * handle toast tables properly).
14928 *
14929 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
14930 * free-standing composite type.
14931 */
14932 void
14934 {
14935 Relation target_rel;
14936 Relation class_rel;
14937 HeapTuple tuple;
14938 Form_pg_class tuple_class;
14940 /*
14941 * Get exclusive lock till end of transaction on the target table. Use
14942 * relation_open so that we can work on indexes and sequences.
14943 */
14946 /* Get its pg_class tuple, too */
14954 /* Can we change the ownership of this tuple? */
14956 {
14962 /* ok to change owner */
14966 {
14967 /*
14968 * Because ALTER INDEX OWNER used to be allowed, and in fact
14969 * is generated by old versions of pg_dump, we give a warning
14970 * and do nothing rather than erroring out. Also, to avoid
14971 * unnecessary chatter while restoring those old dumps, say
14972 * nothing at all if the command would be a no-op anyway.
14973 */
14980 /* quick hack to exit via the no-op path */
14982 }
14996 {
14997 /* if it's an owned sequence, disallow changing it by itself */
14998 Oid tableId;
14999 int32 colId;
15010 }
15019 /* translator: %s is an SQL ALTER command */
15026 /* FALL THRU */
15033 }
15035 /*
15036 * If the new owner is the same as the existing owner, consider the
15037 * command to have succeeded. This is for dump restoration purposes.
15038 */
15040 {
15045 Datum aclDatum;
15047 HeapTuple newtuple;
15049 /* skip permission checks when recursing to index or toast table */
15051 {
15052 /* Superusers can always do it */
15054 {
15056 AclResult aclresult;
15058 /* Otherwise, must be owner of the existing object */
15063 /* Must be able to become new owner */
15066 /* New owner must have CREATE privilege on namespace */
15068 ACL_CREATE);
15072 }
15073 }
15081 /*
15082 * Determine the modified ACL for the new owner. This is only
15083 * necessary when the ACL is non-null.
15084 */
15086 Anum_pg_class_relacl,
15089 {
15094 }
15096 newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
15102 /*
15103 * We must similarly update any per-column ACLs to reflect the new
15104 * owner; for neatness reasons that's split out as a subroutine.
15105 */
15108 newOwnerId);
15110 /*
15111 * Update owner dependency reference, if any. A composite type has
15112 * none, because it's tracked for the pg_type entry instead of here;
15113 * indexes and TOAST tables don't have their own entries either.
15114 */
15120 newOwnerId);
15122 /*
15123 * Also change the ownership of the table's row type, if it has one
15124 */
15128 /*
15129 * If we are operating on a table or materialized view, also change
15130 * the ownership of any indexes and sequences that belong to the
15131 * relation, as well as its toast table (if it has one).
15132 */
15137 {
15141 /* Find all the indexes belonging to this relation */
15144 /* For each index, recursively change its ownership */
15149 }
15151 /* If it has a toast table, recurse to change its ownership */
15156 /* If it has dependent sequences, recurse to change them too */
15158 }
15165 }
15167 /*
15168 * change_owner_fix_column_acls
15169 *
15170 * Helper function for ATExecChangeOwner. Scan the columns of the table
15171 * and fix any non-null column ACLs to reflect the new owner.
15172 */
15173 static void
15175 {
15176 Relation attRelation;
15177 SysScanDesc scan;
15179 HeapTuple attributeTuple;
15183 Anum_pg_attribute_attrelid,
15189 {
15195 Datum aclDatum;
15197 HeapTuple newtuple;
15199 /* Ignore dropped columns */
15204 Anum_pg_attribute_attacl,
15207 /* Null ACLs do not require changes */
15226 }
15229 }
15231 /*
15232 * change_owner_recurse_to_sequences
15233 *
15234 * Helper function for ATExecChangeOwner. Examines pg_depend searching
15235 * for sequences that are dependent on serial columns, and changes their
15236 * ownership.
15237 */
15238 static void
15240 {
15241 Relation depRel;
15242 SysScanDesc scan;
15244 HeapTuple tup;
15246 /*
15247 * SERIAL sequences are those having an auto dependency on one of the
15248 * table's columns (we don't care *which* column, exactly).
15249 */
15253 Anum_pg_depend_refclassid,
15257 Anum_pg_depend_refobjid,
15260 /* we leave refobjsubid unspecified */
15266 {
15268 Relation seqRel;
15270 /* skip dependencies other than auto dependencies on columns */
15277 /* Use relation_open just in case it's an index */
15280 /* skip non-sequence relations */
15282 {
15283 /* No need to keep the lock */
15286 }
15288 /* We don't need to close the sequence while we alter it. */
15291 /* Now we can close it. Keep the lock till end of transaction. */
15293 }
15298 }
15300 /*
15301 * ALTER TABLE CLUSTER ON
15302 *
15303 * The only thing we have to do is to change the indisclustered bits.
15304 *
15305 * Return the address of the new clustering index.
15306 */
15307 static ObjectAddress
15309 {
15310 Oid indexOid;
15311 ObjectAddress address;
15321 /* Check index is valid to cluster on */
15324 /* And do the work */
15331 }
15333 /*
15334 * ALTER TABLE SET WITHOUT CLUSTER
15335 *
15336 * We have to find any indexes on the table that have indisclustered bit
15337 * set and turn it off.
15338 */
15339 static void
15341 {
15343 }
15345 /*
15346 * Preparation phase for SET ACCESS METHOD
15347 *
15348 * Check that the access method exists and determine whether a change is
15349 * actually needed.
15350 */
15351 static void
15353 {
15354 Oid amoid;
15356 /*
15357 * Look up the access method name and check that it differs from the
15358 * table's current AM. If DEFAULT was specified for a partitioned table
15359 * (amname is NULL), set it to InvalidOid to reset the catalogued AM.
15360 */
15365 else
15368 /* if it's a match, phase 3 doesn't need to do anything */
15372 /* Save info for Phase 3 to do the real work */
15376 }
15378 /*
15379 * Special handling of ALTER TABLE SET ACCESS METHOD for relations with no
15380 * storage that have an interest in preserving AM.
15381 *
15382 * Since these have no storage, setting the access method is a catalog only
15383 * operation.
15384 */
15385 static void
15387 {
15388 Relation pg_class;
15389 Oid oldAccessMethodId;
15390 HeapTuple tuple;
15391 Form_pg_class rd_rel;
15394 /*
15395 * Shouldn't be called on relations having storage; these are processed in
15396 * phase 3.
15397 */
15400 /* Get a modifiable copy of the relation's pg_class row. */
15408 /* Update the pg_class row. */
15412 /* Leave if no update required */
15414 {
15418 }
15422 /*
15423 * Update the dependency on the new access method. No dependency is added
15424 * if the new access method is InvalidOid (default case). Be very careful
15425 * that this has to compare the previous value stored in pg_class with the
15426 * new one.
15427 */
15429 {
15430 ObjectAddress relobj,
15431 referenced;
15433 /*
15434 * New access method is defined and there was no dependency
15435 * previously, so record a new one.
15436 */
15440 }
15443 {
15444 /*
15445 * There was an access method defined, and no new one, so just remove
15446 * the existing dependency.
15447 */
15449 AccessMethodRelationId,
15450 DEPENDENCY_NORMAL);
15451 }
15452 else
15453 {
15457 /* Both are valid, so update the dependency */
15459 AccessMethodRelationId,
15461 }
15463 /* make the relam and dependency changes visible */
15470 }
15472 /*
15473 * ALTER TABLE SET TABLESPACE
15474 */
15475 static void
15476 ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, const char *tablespacename, LOCKMODE lockmode)
15477 {
15478 Oid tablespaceId;
15480 /* Check that the tablespace exists */
15483 /* Check permissions except when moving to database's default */
15485 {
15486 AclResult aclresult;
15491 }
15493 /* Save info for Phase 3 to do the real work */
15500 }
15502 /*
15503 * Set, reset, or replace reloptions.
15504 */
15505 static void
15507 LOCKMODE lockmode)
15508 {
15509 Oid relid;
15510 Relation pgclass;
15511 HeapTuple tuple;
15512 HeapTuple newtuple;
15513 Datum datum;
15515 Datum newOptions;
15526 /* Fetch heap tuple */
15533 {
15534 /*
15535 * If we're supposed to replace the reloptions list, we just pretend
15536 * there were none before.
15537 */
15540 }
15541 else
15542 {
15543 /* Get the old reloptions */
15546 }
15548 /* Generate new proposed reloptions (text array) */
15553 /* Validate */
15555 {
15578 }
15580 /* Special-case validation of view options */
15582 {
15589 {
15594 }
15596 /*
15597 * If the check option is specified, look to see if the view is
15598 * actually auto-updatable or not.
15599 */
15601 {
15610 }
15611 }
15613 /*
15614 * All we need do here is update the pg_class row; the new options will be
15615 * propagated into relcaches during post-commit cache inval.
15616 */
15623 else
15639 /* repeat the whole exercise for the toast table, if there's one */
15641 {
15642 Relation toastrel;
15647 /* Fetch heap tuple */
15653 {
15654 /*
15655 * If we're supposed to replace the reloptions list, we just
15656 * pretend there were none before.
15657 */
15660 }
15661 else
15662 {
15663 /* Get the old reloptions */
15666 }
15680 else
15699 }
15702 }
15704 /*
15705 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
15706 * rewriting to be done, so we just want to copy the data as fast as possible.
15707 */
15708 static void
15710 {
15711 Relation rel;
15712 Oid reltoastrelid;
15713 RelFileNumber newrelfilenumber;
15714 RelFileLocator newrlocator;
15718 /*
15719 * Need lock here in case we are recursing to toast table or index
15720 */
15723 /* Check first if relation can be moved to new tablespace */
15725 {
15730 }
15733 /* Fetch the list of indexes on toast relation if necessary */
15735 {
15740 }
15742 /*
15743 * Relfilenumbers are not unique in databases across tablespaces, so we
15744 * need to allocate a new one in the new tablespace.
15745 */
15749 /* Open old and new relation */
15754 /* hand off to AM to actually create new rel storage and copy the data */
15756 {
15758 }
15759 else
15760 {
15763 }
15765 /*
15766 * Update the pg_class row.
15767 *
15768 * NB: This wouldn't work if ATExecSetTableSpace() were allowed to be
15769 * executed on pg_class or its indexes (the above copy wouldn't contain
15770 * the updated pg_class entry), but that's forbidden with
15771 * CheckRelationTableSpaceMove().
15772 */
15781 /* Make sure the reltablespace change is visible */
15784 /* Move associated toast relation and/or indexes, too */
15790 /* Clean up */
15792 }
15794 /*
15795 * Special handling of ALTER TABLE SET TABLESPACE for relations with no
15796 * storage that have an interest in preserving tablespace.
15797 *
15798 * Since these have no storage the tablespace can be updated with a simple
15799 * metadata only operation to update the tablespace.
15800 */
15801 static void
15803 {
15804 /*
15805 * Shouldn't be called on relations having storage; these are processed in
15806 * phase 3.
15807 */
15810 /* check if relation can be moved to its new tablespace */
15812 {
15817 }
15819 /* Update can be done, so change reltablespace */
15824 /* Make sure the reltablespace change is visible */
15826 }
15828 /*
15829 * Alter Table ALL ... SET TABLESPACE
15830 *
15831 * Allows a user to move all objects of some type in a given tablespace in the
15832 * current database to another tablespace. Objects can be chosen based on the
15833 * owner of the object also, to allow users to move only their objects.
15834 * The user must have CREATE rights on the new tablespace, as usual. The main
15835 * permissions handling is done by the lower-level table move function.
15836 *
15837 * All to-be-moved objects are locked first. If NOWAIT is specified and the
15838 * lock can't be acquired then we ereport(ERROR).
15839 */
15840 Oid
15842 {
15846 Relation rel;
15847 TableScanDesc scan;
15848 HeapTuple tuple;
15849 Oid orig_tablespaceoid;
15850 Oid new_tablespaceoid;
15853 /* Ensure we were not asked to move something we can't */
15860 /* Get the orig and new tablespace OIDs */
15864 /* Can't move shared relations in to or out of pg_global */
15865 /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
15872 /*
15873 * Must have CREATE rights on the new tablespace, unless it is the
15874 * database default tablespace (which all users implicitly have CREATE
15875 * rights on).
15876 */
15878 {
15879 AclResult aclresult;
15882 ACL_CREATE);
15886 }
15888 /*
15889 * Now that the checks are done, check if we should set either to
15890 * InvalidOid because it is our database's default tablespace.
15891 */
15898 /* no-op */
15902 /*
15903 * Walk the list of objects in the tablespace and move them. This will
15904 * only find objects in our database, of course.
15905 */
15907 Anum_pg_class_reltablespace,
15914 {
15918 /*
15919 * Do not move objects in pg_catalog as part of this, if an admin
15920 * really wishes to do so, they can issue the individual ALTER
15921 * commands directly.
15922 *
15923 * Also, explicitly avoid any shared tables, temp tables, or TOAST
15924 * (TOAST will be moved with the main table).
15925 */
15932 /* Only move the object type requested */
15943 /* Check if we are only moving objects owned by certain roles */
15947 /*
15948 * Handle permissions-checking here since we are locking the tables
15949 * and also to avoid doing a bunch of work only to fail part-way. Note
15950 * that permissions will also be checked by AlterTableInternal().
15951 *
15952 * Caller must be considered an owner on the table to move it.
15953 */
15965 else
15968 /* Add to our list of objects to move */
15970 }
15982 /* Everything is locked, loop through and move all of the relations. */
15984 {
15994 /* OID is set by AlterTableInternal */
15997 }
16000 }
16002 static void
16004 {
16005 SMgrRelation dstrel;
16007 /*
16008 * Since we copy the file directly without looking at the shared buffers,
16009 * we'd better first flush out any pages of the source relation that are
16010 * in shared buffers. We assume no new changes will be made while we are
16011 * holding exclusive lock on the rel.
16012 */
16015 /*
16016 * Create and copy all forks of the relation, and schedule unlinking of
16017 * old physical files.
16018 *
16019 * NOTE: any conflict in relfilenumber value will be caught in
16020 * RelationCreateStorage().
16021 */
16024 /* copy main fork */
16028 /* copy those extra forks that exist */
16031 {
16033 {
16036 /*
16037 * WAL log creation if the relation is persistent, or this is the
16038 * init fork of an unlogged relation.
16039 */
16046 }
16047 }
16049 /* drop old relation, and close new one */
16052 }
16054 /*
16055 * ALTER TABLE ENABLE/DISABLE TRIGGER
16056 *
16057 * We just pass this off to trigger.c.
16058 */
16059 static void
16062 LOCKMODE lockmode)
16063 {
16066 lockmode);
16070 }
16072 /*
16073 * ALTER TABLE ENABLE/DISABLE RULE
16074 *
16075 * We just pass this off to rewriteDefine.c.
16076 */
16077 static void
16080 {
16085 }
16087 /*
16088 * ALTER TABLE INHERIT
16089 *
16090 * Add a parent to the child's parents. This verifies that all the columns and
16091 * check constraints of the parent appear in the child and that they have the
16092 * same data types and expressions.
16093 */
16094 static void
16096 {
16111 }
16113 /*
16114 * Return the address of the new parent relation.
16115 */
16116 static ObjectAddress
16118 {
16119 Relation parent_rel;
16121 ObjectAddress address;
16124 /*
16125 * A self-exclusive lock is needed here. See the similar case in
16126 * MergeAttributes() for a full explanation.
16127 */
16130 /*
16131 * Must be owner of both parent and child -- child was checked by
16132 * ATSimplePermissions call in ATPrepCmd
16133 */
16136 /* Permanent rels cannot inherit from temporary ones */
16144 /* If parent rel is temp, it must belong to this session */
16151 /* Ditto for the child */
16158 /* Prevent partitioned tables from becoming inheritance parents */
16165 /* Likewise for partitions */
16171 /*
16172 * Prevent circularity by seeing if proposed parent inherits from child.
16173 * (In particular, this disallows making a rel inherit from itself.)
16174 *
16175 * This is not completely bulletproof because of race conditions: in
16176 * multi-level inheritance trees, someone else could concurrently be
16177 * making another inheritance link that closes the loop but does not join
16178 * either of the rels we have locked. Preventing that seems to require
16179 * exclusive locks on the entire inheritance tree, which is a cure worse
16180 * than the disease. find_all_inheritors() will cope with circularity
16181 * anyway, so don't sweat it too much.
16182 *
16183 * We use weakest lock we can on child's children, namely AccessShareLock.
16184 */
16196 /*
16197 * If child_rel has row-level triggers with transition tables, we
16198 * currently don't allow it to become an inheritance child. See also
16199 * prohibitions in ATExecAttachPartition() and CreateTrigger().
16200 */
16207 errdetail("ROW triggers with transition tables are not supported in inheritance hierarchies.")));
16209 /* OK to create inheritance */
16212 /*
16213 * If parent_rel has a primary key, then child_rel has not-null
16214 * constraints that make these columns as non nullable. Make those
16215 * constraints as inherited.
16216 */
16222 /* keep our lock on the parent relation until commit */
16226 }
16228 /*
16229 * CreateInheritance
16230 * Catalog manipulation portion of creating inheritance between a child
16231 * table and a parent table.
16232 *
16233 * Common to ATExecAddInherit() and ATExecAttachPartition().
16234 */
16235 static void
16237 {
16238 Relation catalogRelation;
16239 SysScanDesc scan;
16240 ScanKeyData key;
16241 HeapTuple inheritsTuple;
16242 int32 inhseqno;
16244 /* Note: get RowExclusiveLock because we will write pg_inherits below. */
16247 /*
16248 * Check for duplicates in the list of parents, and determine the highest
16249 * inhseqno already present; we'll use the next one for the new parent.
16250 * Also, if proposed child is a partition, it cannot already be
16251 * inheriting.
16252 *
16253 * Note: we do not reject the case where the child already inherits from
16254 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
16255 */
16257 Anum_pg_inherits_inhrelid,
16263 /* inhseqno sequences start at 1 */
16266 {
16277 }
16280 /* Match up the columns and bump attinhcount as needed */
16283 /* Match up the constraints and bump coninhcount as needed */
16286 /*
16287 * OK, it looks valid. Make the catalog entries that show inheritance.
16288 */
16292 catalogRelation,
16294 RELKIND_PARTITIONED_TABLE);
16296 /* Now we're done with pg_inherits */
16298 }
16300 /*
16301 * Obtain the source-text form of the constraint expression for a check
16302 * constraint, given its pg_constraint tuple
16303 */
16306 {
16307 Form_pg_constraint con;
16309 Datum attr;
16310 Datum expr;
16320 }
16322 /*
16323 * Determine whether two check constraints are functionally equivalent
16324 *
16325 * The test we apply is to see whether they reverse-compile to the same
16326 * source string. This insulates us from issues like whether attributes
16327 * have the same physical column numbers in parent and child relations.
16328 */
16329 static bool
16331 {
16340 else
16342 }
16344 /*
16345 * Check columns in child table match up with columns in parent, and increment
16346 * their attinhcount.
16347 *
16348 * Called by CreateInheritance
16349 *
16350 * Currently all parent columns must be found in child. Missing columns are an
16351 * error. One day we might consider creating new columns like CREATE TABLE
16352 * does. However, that is widely unpopular --- in the common use case of
16353 * partitioned tables it's a foot-gun.
16354 *
16355 * The data type must match exactly. If the parent column is NOT NULL then
16356 * the child must be as well. Defaults are not compared, however.
16357 */
16358 static void
16360 {
16361 Relation attrrel;
16362 TupleDesc parent_desc;
16368 {
16371 HeapTuple tuple;
16373 /* Ignore dropped columns in the parent. */
16377 /* Find same column in child (matching on column name). */
16380 {
16396 /*
16397 * If the parent has a not-null constraint that's not NO INHERIT,
16398 * make sure the child has one too.
16399 *
16400 * Other constraints are checked elsewhere.
16401 */
16403 {
16404 HeapTuple contup;
16413 parent_attname));
16414 }
16416 /*
16417 * Child column must be generated if and only if parent column is.
16418 */
16428 /*
16429 * Regular inheritance children are independent enough not to
16430 * inherit identity columns. But partitions are integral part of
16431 * a partitioned table and inherit identity column.
16432 */
16436 /*
16437 * OK, bump the child column's inheritance count. (If we fail
16438 * later on, this change will just roll back.)
16439 */
16446 /*
16447 * In case of partitions, we must enforce that value of attislocal
16448 * is same in all partitions. (Note: there are only inherited
16449 * attributes in partitions)
16450 */
16452 {
16455 }
16459 }
16460 else
16461 {
16465 }
16466 }
16469 }
16471 /*
16472 * Check constraints in child table match up with constraints in parent,
16473 * and increment their coninhcount.
16474 *
16475 * Constraints that are marked ONLY in the parent are ignored.
16476 *
16477 * Called by CreateInheritance
16478 *
16479 * Currently all constraints in parent must be present in the child. One day we
16480 * may consider adding new constraints like CREATE TABLE does.
16481 *
16482 * XXX This is O(N^2) which may be an issue with tables with hundreds of
16483 * constraints. As long as tables have more like 10 constraints it shouldn't be
16484 * a problem though. Even 100 constraints ought not be the end of the world.
16485 *
16486 * XXX See MergeWithExistingConstraint too if you change this code.
16487 */
16488 static void
16490 {
16491 Relation constraintrel;
16492 SysScanDesc parent_scan;
16493 ScanKeyData parent_key;
16494 HeapTuple parent_tuple;
16499 /* Outer loop scans through the parent's constraint definitions */
16501 Anum_pg_constraint_conrelid,
16508 {
16510 SysScanDesc child_scan;
16511 ScanKeyData child_key;
16512 HeapTuple child_tuple;
16519 /* if the parent's constraint is marked NO INHERIT, it's not inherited */
16523 /* Search for a child constraint matching this one */
16525 Anum_pg_constraint_conrelid,
16532 {
16534 HeapTuple child_copy;
16539 /*
16540 * CHECK constraint are matched by name, NOT NULL ones by
16541 * attribute number
16542 */
16544 {
16548 }
16550 {
16558 }
16567 /*
16568 * If the CHECK child constraint is "no inherit" then cannot
16569 * merge.
16570 *
16571 * This is not desirable for not-null constraints, mostly because
16572 * it breaks our pg_upgrade strategy, but it also makes sense on
16573 * its own: if a child has its own not-null constraint and then
16574 * acquires a parent with the same constraint, then we start to
16575 * enforce that constraint for all the descendants of that child
16576 * too, if any.
16577 */
16585 /*
16586 * If the child constraint is "not valid" then cannot merge with a
16587 * valid parent constraint
16588 */
16595 /*
16596 * OK, bump the child constraint's inheritance count. (If we fail
16597 * later on, this change will just roll back.)
16598 */
16610 /*
16611 * In case of partitions, an inherited constraint must be
16612 * inherited only once since it cannot have multiple parents and
16613 * it is never considered local.
16614 */
16616 {
16619 }
16626 }
16631 {
16644 }
16645 }
16649 }
16651 /*
16652 * ALTER TABLE NO INHERIT
16653 *
16654 * Return value is the address of the relation that is no longer parent.
16655 */
16656 static ObjectAddress
16658 {
16659 ObjectAddress address;
16660 Relation parent_rel;
16667 /*
16668 * AccessShareLock on the parent is probably enough, seeing that DROP
16669 * TABLE doesn't lock parent tables at all. We need some lock since we'll
16670 * be inspecting the parent's schema.
16671 */
16674 /*
16675 * We don't bother to check ownership of the parent table --- ownership of
16676 * the child is presumed enough rights.
16677 */
16679 /* Off to RemoveInheritance() where most of the work happens */
16682 /*
16683 * If parent_rel has a primary key, then child_rel has not-null
16684 * constraints that make these columns as non nullable. Mark those
16685 * constraints as no longer inherited by this parent.
16686 */
16689 /*
16690 * If the parent has a primary key, then we decrement counts for all NOT
16691 * NULL constraints
16692 */
16697 /* keep our lock on the parent relation until commit */
16701 }
16703 /*
16704 * MarkInheritDetached
16705 *
16706 * Set inhdetachpending for a partition, for ATExecDetachPartition
16707 * in concurrent mode. While at it, verify that no other partition is
16708 * already pending detach.
16709 */
16710 static void
16712 {
16713 Relation catalogRelation;
16714 SysScanDesc scan;
16715 ScanKeyData key;
16716 HeapTuple inheritsTuple;
16721 /*
16722 * Find pg_inherits entries by inhparent. (We need to scan them all in
16723 * order to verify that no other partition is pending detach.)
16724 */
16727 Anum_pg_inherits_inhparent,
16734 {
16735 Form_pg_inherits inhForm;
16745 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
16748 {
16749 HeapTuple newtup;
16756 newtup);
16759 /* keep looking, to ensure we catch others pending detach */
16760 }
16761 }
16763 /* Done */
16773 }
16775 /*
16776 * RemoveInheritance
16777 *
16778 * Drop a parent from the child's parents. This just adjusts the attinhcount
16779 * and attislocal of the columns and removes the pg_inherit and pg_depend
16780 * entries. expect_detached is passed down to DeleteInheritsTuple, q.v..
16781 *
16782 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
16783 * up attislocal stays true, which means if a child is ever removed from a
16784 * parent then its columns will never be automatically dropped which may
16785 * surprise. But at least we'll never surprise by dropping columns someone
16786 * isn't expecting to be dropped which would actually mean data loss.
16787 *
16788 * coninhcount and conislocal for inherited constraints are adjusted in
16789 * exactly the same way.
16790 *
16791 * Common to ATExecDropInherit() and ATExecDetachPartition().
16792 */
16793 static void
16795 {
16796 Relation catalogRelation;
16797 SysScanDesc scan;
16799 HeapTuple attributeTuple,
16800 constraintTuple;
16810 expect_detached,
16813 {
16820 else
16826 }
16828 /*
16829 * Search through child columns looking for ones matching parent rel
16830 */
16833 Anum_pg_attribute_attrelid,
16839 {
16842 /* Ignore if dropped or not inherited */
16850 {
16851 /* Decrement inhcount and possibly set islocal to true */
16861 }
16862 }
16866 /*
16867 * Likewise, find inherited check constraints and disinherit them. To do
16868 * this, we first need a list of the names of the parent's check
16869 * constraints. (We cheat a bit by only checking for name matches,
16870 * assuming that the expressions will match.)
16871 *
16872 * For NOT NULL columns, we store column numbers to match.
16873 */
16876 Anum_pg_constraint_conrelid,
16886 {
16893 }
16897 /* Now scan the child's constraints */
16899 Anum_pg_constraint_conrelid,
16906 {
16911 /*
16912 * Match CHECK constraints by name, not-null constraints by column
16913 * number, and ignore all others.
16914 */
16916 {
16918 {
16921 {
16924 }
16925 }
16926 }
16928 {
16932 {
16934 {
16937 }
16938 }
16939 }
16940 else
16944 {
16945 /* Decrement inhcount and possibly set islocal to true */
16959 }
16960 }
16966 RelationRelationId,
16970 /*
16971 * Post alter hook of this inherits. Since object_access_hook doesn't take
16972 * multiple object identifiers, we relay oid of parent relation using
16973 * auxiliary_id argument.
16974 */
16978 }
16980 /*
16981 * Adjust coninhcount of not-null constraints upwards or downwards when a
16982 * table is marked as inheriting or no longer doing so a table with a primary
16983 * key.
16984 *
16985 * Note: these constraints are not dropped, even if their inhcount goes to zero
16986 * and conislocal is false. Instead we mark the constraints as locally defined.
16987 * This is seen as more useful behavior, with no downsides. The user can always
16988 * drop them afterwards.
16989 */
16990 static void
16992 {
16995 /* Quick exit when parent has no PK */
17000 INDEX_ATTR_BITMAP_PRIMARY_KEY);
17002 {
17012 {
17015 }
17017 /*
17018 * CCI is needed in case there's a NOT NULL PRIMARY KEY column in the
17019 * parent: the relevant not-null constraint in the child already had
17020 * its inhcount modified earlier.
17021 */
17024 inhcount);
17025 }
17026 }
17028 /*
17029 * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE
17030 * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or
17031 * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will
17032 * be TypeRelationId). There's no convenient way to do this, so go trawling
17033 * through pg_depend.
17034 */
17035 static void
17037 DependencyType deptype)
17038 {
17039 Relation catalogRelation;
17040 SysScanDesc scan;
17042 HeapTuple depTuple;
17047 Anum_pg_depend_classid,
17051 Anum_pg_depend_objid,
17055 Anum_pg_depend_objsubid,
17063 {
17071 }
17075 }
17077 /*
17078 * ALTER TABLE OF
17079 *
17080 * Attach a table to a composite type, as though it had been created with CREATE
17081 * TABLE OF. All attname, atttypid, atttypmod and attcollation must match. The
17082 * subject table must not have inheritance parents. These restrictions ensure
17083 * that you cannot create a configuration impossible with CREATE TABLE OF alone.
17084 *
17085 * The address of the type is returned.
17086 */
17087 static ObjectAddress
17089 {
17091 Type typetuple;
17092 Form_pg_type typeform;
17094 Relation inheritsRelation,
17095 relationRelation;
17096 SysScanDesc scan;
17097 ScanKeyData key;
17098 AttrNumber table_attno,
17099 type_attno;
17100 TupleDesc typeTupleDesc,
17101 tableTupleDesc;
17102 ObjectAddress tableobj,
17103 typeobj;
17104 HeapTuple classtuple;
17106 /* Validate the type. */
17112 /* Fail if the table has any inheritance parents. */
17115 Anum_pg_inherits_inhrelid,
17127 /*
17128 * Check the tuple descriptors for compatibility. Unlike inheritance, we
17129 * require that the order also match. However, attnotnull need not match.
17130 */
17135 {
17136 Form_pg_attribute type_attr,
17137 table_attr;
17141 /* Get the next non-dropped type attribute. */
17147 /* Get the next non-dropped table attribute. */
17148 do
17149 {
17154 type_attname)));
17156 table_attno++;
17160 /* Compare name. */
17167 /* Compare type. */
17175 }
17178 /* Any remaining columns at the end of the table had better be dropped. */
17180 {
17189 }
17191 /* If the table was already typed, drop the existing dependency. */
17194 DEPENDENCY_NORMAL);
17196 /* Record a dependency on the new type. */
17205 /* Update pg_class.reloftype */
17221 }
17223 /*
17224 * ALTER TABLE NOT OF
17225 *
17226 * Detach a typed table from its originating type. Just clear reloftype and
17227 * remove the dependency.
17228 */
17229 static void
17231 {
17233 Relation relationRelation;
17234 HeapTuple tuple;
17242 /*
17243 * We don't bother to check ownership of the type --- ownership of the
17244 * table is presumed enough rights. No lock required on the type, either.
17245 */
17248 DEPENDENCY_NORMAL);
17250 /* Clear pg_class.reloftype */
17262 }
17264 /*
17265 * relation_mark_replica_identity: Update a table's replica identity
17266 *
17267 * Iff ri_type = REPLICA_IDENTITY_INDEX, indexOid must be the Oid of a suitable
17268 * index. Otherwise, it must be InvalidOid.
17269 *
17270 * Caller had better hold an exclusive lock on the relation, as the results
17271 * of running two of these concurrently wouldn't be pretty.
17272 */
17273 static void
17276 {
17277 Relation pg_index;
17278 Relation pg_class;
17279 HeapTuple pg_class_tuple;
17280 HeapTuple pg_index_tuple;
17281 Form_pg_class pg_class_form;
17282 Form_pg_index pg_index_form;
17285 /*
17286 * Check whether relreplident has changed, and update it if so.
17287 */
17296 {
17299 }
17303 /*
17304 * Update the per-index indisreplident flags correctly.
17305 */
17308 {
17319 {
17320 /* Set the bit if not already set. */
17322 {
17325 }
17326 }
17327 else
17328 {
17329 /* Unset the bit if set. */
17331 {
17334 }
17335 }
17338 {
17343 /*
17344 * Invalidate the relcache for the table, so that after we commit
17345 * all sessions will refresh the table's replica identity index
17346 * before attempting any UPDATE or DELETE on the table. (If we
17347 * changed the table's pg_class row above, then a relcache inval
17348 * is already queued due to that; but we might not have.)
17349 */
17351 }
17353 }
17356 }
17358 /*
17359 * ALTER TABLE <name> REPLICA IDENTITY ...
17360 */
17361 static void
17363 {
17364 Oid indexOid;
17365 Relation indexRel;
17369 {
17372 }
17374 {
17377 }
17379 {
17382 }
17384 {
17386 }
17387 else
17390 /* Check that the index exists */
17400 /* Check that the index is on the relation we're altering. */
17408 /* The AM must support uniqueness, and the index must in fact be unique. */
17415 /* Deferred indexes are not guaranteed to be always unique. */
17421 /* Expression indexes aren't supported. */
17427 /* Predicate indexes aren't supported. */
17434 /* Check index for nullable columns. */
17436 {
17438 Form_pg_attribute attr;
17440 /*
17441 * Reject any other system columns. (Going forward, we'll disallow
17442 * indexes containing such columns in the first place, but they might
17443 * exist in older branches.)
17444 */
17448 errmsg("index \"%s\" cannot be used as replica identity because column %d is a system column",
17458 }
17460 /* This index is suitable for use as a replica identity. Mark it. */
17464 }
17466 /*
17467 * ALTER TABLE ENABLE/DISABLE ROW LEVEL SECURITY
17468 */
17469 static void
17471 {
17472 Relation pg_class;
17473 Oid relid;
17474 HeapTuple tuple;
17478 /* Pull the record for this relation and update it */
17494 }
17496 /*
17497 * ALTER TABLE FORCE/NO FORCE ROW LEVEL SECURITY
17498 */
17499 static void
17501 {
17502 Relation pg_class;
17503 Oid relid;
17504 HeapTuple tuple;
17523 }
17525 /*
17526 * ALTER FOREIGN TABLE <name> OPTIONS (...)
17527 */
17528 static void
17530 {
17531 Relation ftrel;
17534 HeapTuple tuple;
17539 Datum datum;
17540 Form_pg_foreign_table tableform;
17562 /* Extract the current options */
17564 tuple,
17565 Anum_pg_foreign_table_ftoptions,
17570 /* Transform the options */
17572 datum,
17573 options,
17578 else
17583 /* Everything looks good - update the tuple */
17590 /*
17591 * Invalidate relcache so that all sessions will refresh any cached plans
17592 * that might depend on the old options.
17593 */
17602 }
17604 /*
17605 * ALTER TABLE ALTER COLUMN SET COMPRESSION
17606 *
17607 * Return value is the address of the modified column
17608 */
17609 static ObjectAddress
17613 LOCKMODE lockmode)
17614 {
17615 Relation attrel;
17616 HeapTuple tuple;
17617 Form_pg_attribute atttableform;
17618 AttrNumber attnum;
17621 ObjectAddress address;
17627 /* copy the cache entry so we can scribble on it below */
17635 /* prevent them from altering a system attribute */
17643 /*
17644 * Check that column type is compressible, then get the attribute
17645 * compression method code
17646 */
17649 /* update pg_attribute entry */
17655 attnum);
17657 /*
17658 * Apply the change to indexes as well (only for simple index columns,
17659 * matching behavior of index.c ConstructTupleDescriptor()).
17660 */
17664 lockmode);
17670 /* make changes visible */
17676 }
17679 /*
17680 * Preparation phase for SET LOGGED/UNLOGGED
17681 *
17682 * This verifies that we're not trying to change a temp table. Also,
17683 * existing foreign key constraints are checked to avoid ending up with
17684 * permanent tables referencing unlogged tables.
17685 *
17686 * Return value is false if the operation is a no-op (in which case the
17687 * checks are skipped), otherwise true.
17688 */
17689 static bool
17691 {
17692 Relation pg_constraint;
17693 HeapTuple tuple;
17694 SysScanDesc scan;
17697 /*
17698 * Disallow changing status for a temp table. Also verify whether we can
17699 * get away with doing nothing; in such cases we don't need to run the
17700 * checks below, either.
17701 */
17703 {
17713 /* nothing to do */
17718 /* nothing to do */
17721 }
17723 /*
17724 * Check that the table is not part of any publication when changing to
17725 * UNLOGGED, as UNLOGGED tables can't be published.
17726 */
17735 /*
17736 * Check existing foreign key constraints to preserve the invariant that
17737 * permanent tables cannot reference unlogged ones. Self-referencing
17738 * foreign keys can safely be ignored.
17739 */
17742 /*
17743 * Scan conrelid if changing to permanent, else confrelid. This also
17744 * determines whether a useful index exists.
17745 */
17748 Anum_pg_constraint_confrelid,
17756 {
17760 {
17761 Oid foreignrelid;
17762 Relation foreignrel;
17764 /* the opposite end of what we used as scankey */
17767 /* ignore if self-referencing */
17774 {
17782 }
17783 else
17784 {
17792 }
17795 }
17796 }
17803 }
17805 /*
17806 * Execute ALTER TABLE SET SCHEMA
17807 */
17808 ObjectAddress
17810 {
17811 Relation rel;
17812 Oid relid;
17813 Oid oldNspOid;
17814 Oid nspOid;
17817 ObjectAddress myself;
17821 RangeVarCallbackForAlterRelation,
17825 {
17830 }
17836 /* If it's an owned sequence, disallow moving it by itself. */
17838 {
17839 Oid tableId;
17840 int32 colId;
17850 }
17852 /* Get and lock schema OID and check its permissions. */
17856 /* common checks on switching namespaces */
17868 /* close rel, but keep lock until commit */
17872 }
17874 /*
17875 * The guts of relocating a table or materialized view to another namespace:
17876 * besides moving the relation itself, its dependent objects are relocated to
17877 * the new schema.
17878 */
17879 void
17882 {
17883 Relation classRel;
17887 /* OK, modify the pg_class row and pg_depend entry */
17893 /* Fix the table's row type too, if it has one */
17898 /* Fix other dependent stuff */
17902 {
17908 }
17911 }
17913 /*
17914 * The guts of relocating a relation to another namespace: fix the pg_class
17915 * entry, and the pg_depend entry if any. Caller must already have
17916 * opened and write-locked pg_class.
17917 */
17918 void
17923 {
17924 HeapTuple classTup;
17925 Form_pg_class classForm;
17926 ObjectAddress thisobj;
17940 /*
17941 * If the object has already been moved, don't move it again. If it's
17942 * already in the right place, don't move it, but still fire the object
17943 * access hook.
17944 */
17947 {
17948 /* check for duplicate name (more friendly than unique-index failure) */
17957 /* classTup is a copy, so OK to scribble on */
17962 /* Update dependency on schema if caller said so */
17965 relOid,
17966 NamespaceRelationId,
17967 oldNspOid,
17971 }
17973 {
17977 }
17980 }
17982 /*
17983 * Move all indexes for the specified relation to another namespace.
17984 *
17985 * Note: we assume adequate permission checking was done by the caller,
17986 * and that the caller has a suitable lock on the owning relation.
17987 */
17988 static void
17991 {
17998 {
18000 ObjectAddress thisobj;
18006 /*
18007 * Note: currently, the index will not have its own dependency on the
18008 * namespace, so we don't need to do changeDependencyFor(). There's no
18009 * row type in pg_type, either.
18010 *
18011 * XXX this objsMoved test may be pointless -- surely we have a single
18012 * dependency link from a relation to each index?
18013 */
18015 {
18020 }
18021 }
18024 }
18026 /*
18027 * Move all identity and SERIAL-column sequences of the specified relation to another
18028 * namespace.
18029 *
18030 * Note: we assume adequate permission checking was done by the caller,
18031 * and that the caller has a suitable lock on the owning relation.
18032 */
18033 static void
18036 LOCKMODE lockmode)
18037 {
18038 Relation depRel;
18039 SysScanDesc scan;
18041 HeapTuple tup;
18043 /*
18044 * SERIAL sequences are those having an auto dependency on one of the
18045 * table's columns (we don't care *which* column, exactly).
18046 */
18050 Anum_pg_depend_refclassid,
18054 Anum_pg_depend_refobjid,
18057 /* we leave refobjsubid unspecified */
18063 {
18065 Relation seqRel;
18067 /* skip dependencies other than auto dependencies on columns */
18074 /* Use relation_open just in case it's an index */
18077 /* skip non-sequence relations */
18079 {
18080 /* No need to keep the lock */
18083 }
18085 /* Fix the pg_class and pg_depend entries */
18090 /*
18091 * Sequences used to have entries in pg_type, but no longer do. If we
18092 * ever re-instate that, we'll need to move the pg_type entry to the
18093 * new namespace, too (using AlterTypeNamespaceInternal).
18094 */
18097 /* Now we can close it. Keep the lock till end of transaction. */
18099 }
18104 }
18107 /*
18108 * This code supports
18109 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
18110 *
18111 * Because we only support this for TEMP tables, it's sufficient to remember
18112 * the state in a backend-local data structure.
18113 */
18115 /*
18116 * Register a newly-created relation's ON COMMIT action.
18117 */
18118 void
18120 {
18122 MemoryContext oldcxt;
18124 /*
18125 * We needn't bother registering the relation unless there is an ON COMMIT
18126 * action we need to take.
18127 */
18139 /*
18140 * We use lcons() here so that ON COMMIT actions are processed in reverse
18141 * order of registration. That might not be essential but it seems
18142 * reasonable.
18143 */
18147 }
18149 /*
18150 * Unregister any ON COMMIT action when a relation is deleted.
18151 *
18152 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
18153 */
18154 void
18156 {
18160 {
18164 {
18167 }
18168 }
18169 }
18171 /*
18172 * Perform ON COMMIT actions.
18173 *
18174 * This is invoked just before actually committing, since it's possible
18175 * to encounter errors.
18176 */
18177 void
18179 {
18185 {
18188 /* Ignore entry if already dropped in this xact */
18193 {
18196 /* Do nothing (there shouldn't be such entries, actually) */
18200 /*
18201 * If this transaction hasn't accessed any temporary
18202 * relations, we can skip truncating ON COMMIT DELETE ROWS
18203 * tables, as they must still be empty.
18204 */
18211 }
18212 }
18214 /*
18215 * Truncate relations before dropping so that all dependencies between
18216 * relations are removed after they are worked on. Doing it like this
18217 * might be a waste as it is possible that a relation being truncated will
18218 * be dropped anyway due to its parent being dropped, but this makes the
18219 * code more robust because of not having to re-check that the relation
18220 * exists at truncation time.
18221 */
18226 {
18230 {
18231 ObjectAddress object;
18240 }
18242 /*
18243 * Object deletion might involve toast table access (to clean up
18244 * toasted catalog entries), so ensure we have a valid snapshot.
18245 */
18248 /*
18249 * Since this is an automatic drop, rather than one directly initiated
18250 * by the user, we pass the PERFORM_DELETION_INTERNAL flag.
18251 */
18257 #ifdef USE_ASSERT_CHECKING
18259 /*
18260 * Note that table deletion will call remove_on_commit_action, so the
18261 * entry should get marked as deleted.
18262 */
18264 {
18271 }
18272 #endif
18273 }
18274 }
18276 /*
18277 * Post-commit or post-abort cleanup for ON COMMIT management.
18278 *
18279 * All we do here is remove no-longer-needed OnCommitItem entries.
18280 *
18281 * During commit, remove entries that were deleted during this transaction;
18282 * during abort, remove those created during this transaction.
18283 */
18284 void
18286 {
18290 {
18295 {
18296 /* cur_item must be removed */
18299 }
18300 else
18301 {
18302 /* cur_item must be preserved */
18305 }
18306 }
18307 }
18309 /*
18310 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
18311 *
18312 * During subabort, we can immediately remove entries created during this
18313 * subtransaction. During subcommit, just relabel entries marked during
18314 * this subtransaction as being the parent's responsibility.
18315 */
18316 void
18318 SubTransactionId parentSubid)
18319 {
18323 {
18327 {
18328 /* cur_item must be removed */
18331 }
18332 else
18333 {
18334 /* cur_item must be preserved */
18339 }
18340 }
18341 }
18343 /*
18344 * This is intended as a callback for RangeVarGetRelidExtended(). It allows
18345 * the relation to be locked only if (1) it's a plain or partitioned table,
18346 * materialized view, or TOAST table and (2) the current user is the owner (or
18347 * the superuser) or has been granted MAINTAIN. This meets the
18348 * permission-checking needs of CLUSTER, REINDEX TABLE, and REFRESH
18349 * MATERIALIZED VIEW; we expose it here so that it can be used by all.
18350 */
18351 void
18354 {
18356 AclResult aclresult;
18358 /* Nothing to do if the relation was not found. */
18362 /*
18363 * If the relation does exist, check whether it's an index. But note that
18364 * the relation might have been dropped between the time we did the name
18365 * lookup and now. In that case, there's nothing to do.
18366 */
18376 /* Check permissions */
18382 }
18384 /*
18385 * Callback to RangeVarGetRelidExtended() for TRUNCATE processing.
18386 */
18387 static void
18390 {
18391 HeapTuple tuple;
18393 /* Nothing to do if the relation was not found. */
18405 }
18407 /*
18408 * Callback for RangeVarGetRelidExtended(). Checks that the current user is
18409 * the owner of the relation, or superuser.
18410 */
18411 void
18414 {
18415 HeapTuple tuple;
18417 /* Nothing to do if the relation was not found. */
18437 }
18439 /*
18440 * Common RangeVarGetRelid callback for rename, set schema, and alter table
18441 * processing.
18442 */
18443 static void
18446 {
18448 ObjectType reltype;
18449 HeapTuple tuple;
18450 Form_pg_class classform;
18451 AclResult aclresult;
18460 /* Must own relation. */
18464 /* No system table modifications unless explicitly allowed. */
18471 /*
18472 * Extract the specified relation type from the statement parse tree.
18473 *
18474 * Also, for ALTER .. RENAME, check permissions: the user must (still)
18475 * have CREATE rights on the containing namespace.
18476 */
18478 {
18485 }
18491 else
18492 {
18495 }
18497 /*
18498 * For compatibility with prior releases, we allow ALTER TABLE to be used
18499 * with most other types of relations (but not composite types). We allow
18500 * similar flexibility for ALTER INDEX in the case of RENAME, but not
18501 * otherwise. Otherwise, the user must select the correct form of the
18502 * command for the relation at issue.
18503 */
18530 relkind != RELKIND_PARTITIONED_INDEX
18536 /*
18537 * Don't allow ALTER TABLE on composite types. We want people to use ALTER
18538 * TYPE for that.
18539 */
18544 /* translator: %s is an SQL ALTER command */
18548 /*
18549 * Don't allow ALTER TABLE .. SET SCHEMA on relations that can't be moved
18550 * to a different schema, such as indexes and TOAST tables.
18551 */
18553 {
18565 /* translator: %s is an SQL ALTER command */
18574 }
18577 }
18579 /*
18580 * Transform any expressions present in the partition key
18581 *
18582 * Returns a transformed PartitionSpec.
18583 */
18586 {
18598 /* Check valid number of columns for strategy */
18605 /*
18606 * Create a dummy ParseState and insert the target relation as its sole
18607 * rangetable entry. We need a ParseState for transformExpr.
18608 */
18614 /* take care of any partition expressions */
18616 {
18620 {
18621 /* Copy, to avoid scribbling on the input */
18624 /* Now do parse transformation of the expression */
18626 EXPR_KIND_PARTITION_EXPRESSION);
18628 /* we have to fix its collations too */
18630 }
18633 }
18636 }
18638 /*
18639 * Compute per-partition-column information from a list of PartitionElems.
18640 * Expressions in the PartitionElems must be parse-analyzed already.
18641 */
18642 static void
18643 ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
18645 PartitionStrategy strategy)
18646 {
18649 Oid am_oid;
18653 {
18655 Oid atttype;
18656 Oid attcollation;
18659 {
18660 /* Simple attribute reference */
18661 HeapTuple atttuple;
18662 Form_pg_attribute attform;
18681 /*
18682 * Generated columns cannot work: They are computed after BEFORE
18683 * triggers, but partition routing is done before all triggers.
18684 */
18697 }
18698 else
18699 {
18700 /* Expression */
18708 /*
18709 * The expression must be of a storable type (e.g., not RECORD).
18710 * The test is the same as for whether a table column is of a safe
18711 * type (which is why we needn't check for the non-expression
18712 * case).
18713 */
18719 /*
18720 * Strip any top-level COLLATE clause. This ensures that we treat
18721 * "x COLLATE y" and "(x COLLATE y)" alike.
18722 */
18728 {
18729 /*
18730 * User wrote "(column)" or "(column COLLATE something)".
18731 * Treat it like simple attribute anyway.
18732 */
18734 }
18735 else
18736 {
18743 /*
18744 * transformPartitionSpec() should have already rejected
18745 * subqueries, aggregates, window functions, and SRFs, based
18746 * on the EXPR_KIND_ for partition expressions.
18747 */
18749 /*
18750 * Cannot allow system column references, since that would
18751 * make partition routing impossible: their values won't be
18752 * known yet when we need to do that.
18753 */
18756 {
18758 expr_attrs))
18762 }
18764 /*
18765 * Generated columns cannot work: They are computed after
18766 * BEFORE triggers, but partition routing is done before all
18767 * triggers.
18768 */
18771 {
18782 }
18784 /*
18785 * Preprocess the expression before checking for mutability.
18786 * This is essential for the reasons described in
18787 * contain_mutable_functions_after_planning. However, we call
18788 * expression_planner for ourselves rather than using that
18789 * function, because if constant-folding reduces the
18790 * expression to a constant, we'd like to know that so we can
18791 * complain below.
18792 *
18793 * Like contain_mutable_functions_after_planning, assume that
18794 * expression_planner won't scribble on its input, so this
18795 * won't affect the partexprs entry we saved above.
18796 */
18799 /*
18800 * Partition expressions cannot contain mutable functions,
18801 * because a given row must always map to the same partition
18802 * as long as there is no change in the partition boundary
18803 * structure.
18804 */
18810 /*
18811 * While it is not exactly *wrong* for a partition expression
18812 * to be a constant, it seems better to reject such keys.
18813 */
18818 }
18819 }
18821 /*
18822 * Apply collation override if any
18823 */
18827 /*
18828 * Check we have a collation iff it's a collatable type. The only
18829 * expected failures here are (1) COLLATE applied to a noncollatable
18830 * type, or (2) partition expression had an unresolved collation. But
18831 * we might as well code this to be a complete consistency check.
18832 */
18834 {
18840 }
18841 else
18842 {
18848 }
18852 /*
18853 * Identify the appropriate operator class. For list and range
18854 * partitioning, we use a btree operator class; hash partitioning uses
18855 * a hash operator class.
18856 */
18859 else
18863 {
18867 {
18873 errhint("You must specify a hash operator class or define a default hash operator class for the data type.")));
18874 else
18879 errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
18880 }
18881 }
18882 else
18884 atttype,
18886 am_oid);
18888 attn++;
18889 }
18890 }
18892 /*
18893 * PartConstraintImpliedByRelConstraint
18894 * Do scanrel's existing constraints imply the partition constraint?
18895 *
18896 * "Existing constraints" include its check constraints and column-level
18897 * not-null constraints. partConstraint describes the partition constraint,
18898 * in implicit-AND form.
18899 */
18900 bool
18903 {
18909 {
18913 {
18917 {
18921 i,
18928 /*
18929 * argisrow=false is correct even for a composite column,
18930 * because attnotnull does not represent a SQL-spec IS NOT
18931 * NULL test in such a case, just IS DISTINCT FROM NULL.
18932 */
18936 }
18937 }
18938 }
18941 }
18943 /*
18944 * ConstraintImpliedByRelConstraint
18945 * Do scanrel's existing constraints imply the given constraint?
18946 *
18947 * testConstraint is the constraint to validate. provenConstraint is a
18948 * caller-provided list of conditions which this function may assume
18949 * to be true. Both provenConstraint and testConstraint must be in
18950 * implicit-AND form, must only contain immutable clauses, and must
18951 * contain only Vars with varno = 1.
18952 */
18953 bool
18954 ConstraintImpliedByRelConstraint(Relation scanrel, List *testConstraint, List *provenConstraint)
18955 {
18959 i;
18963 {
18966 /*
18967 * If this constraint hasn't been fully validated yet, we must ignore
18968 * it here.
18969 */
18975 /*
18976 * Run each expression through const-simplification and
18977 * canonicalization. It is necessary, because we will be comparing it
18978 * to similarly-processed partition constraint expressions, and may
18979 * fail to detect valid matches without this.
18980 */
18986 }
18988 /*
18989 * Try to make the proof. Since we are comparing CHECK constraints, we
18990 * need to use weak implication, i.e., we assume existConstraint is
18991 * not-false and try to prove the same for testConstraint.
18992 *
18993 * Note that predicate_implied_by assumes its first argument is known
18994 * immutable. That should always be true for both NOT NULL and partition
18995 * constraints, so we don't test it here.
18996 */
18998 }
19000 /*
19001 * QueuePartitionConstraintValidation
19002 *
19003 * Add an entry to wqueue to have the given partition constraint validated by
19004 * Phase 3, for the given relation, and all its children.
19005 *
19006 * We first verify whether the given constraint is implied by pre-existing
19007 * relation constraints; if it is, there's no need to scan the table to
19008 * validate, so don't queue in that case.
19009 */
19010 static void
19014 {
19015 /*
19016 * Based on the table's existing constraints, determine whether or not we
19017 * may skip scanning the table.
19018 */
19020 {
19025 else
19027 (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
19030 }
19032 /*
19033 * Constraints proved insufficient. For plain relations, queue a
19034 * validation item now; for partitioned tables, recurse to process each
19035 * partition.
19036 */
19038 {
19041 /* Grab a work queue entry. */
19046 }
19048 {
19053 {
19054 Relation part_rel;
19057 /*
19058 * This is the minimum lock we need to prevent deadlocks.
19059 */
19062 /*
19063 * Adjust the constraint for scanrel so that it matches this
19064 * partition's attribute numbers.
19065 */
19066 thisPartConstraint =
19071 thisPartConstraint,
19072 validate_default);
19074 }
19075 }
19076 }
19078 /*
19079 * ALTER TABLE <name> ATTACH PARTITION <partition-name> FOR VALUES
19080 *
19081 * Return the address of the newly attached partition.
19082 */
19083 static ObjectAddress
19086 {
19087 Relation attachrel,
19088 catalog;
19091 SysScanDesc scan;
19092 ScanKeyData skey;
19093 AttrNumber attno;
19095 TupleDesc tupleDesc;
19096 ObjectAddress address;
19098 Oid defaultPartOid;
19104 /*
19105 * We must lock the default partition if one exists, because attaching a
19106 * new partition will change its partition constraint.
19107 */
19108 defaultPartOid =
19115 /*
19116 * XXX I think it'd be a good idea to grab locks on all tables referenced
19117 * by FKs at this point also.
19118 */
19120 /*
19121 * Must be owner of both parent and source table -- parent was checked by
19122 * ATSimplePermissions call in ATPrepCmd
19123 */
19126 /* A partition can only have one parent */
19138 /*
19139 * Table being attached should not already be part of inheritance; either
19140 * as a child table...
19141 */
19144 Anum_pg_inherits_inhrelid,
19155 /* ...or as a parent table (except the case when it is partitioned) */
19157 Anum_pg_inherits_inhparent,
19170 /*
19171 * Prevent circularity by seeing if rel is a partition of attachrel. (In
19172 * particular, this disallows making a rel a partition of itself.)
19173 *
19174 * We do that by checking if rel is a member of the list of attachrel's
19175 * partitions provided the latter is partitioned at all. We want to avoid
19176 * having to construct this list again, so we request the strongest lock
19177 * on all partitions. We need the strongest lock, because we may decide
19178 * to scan them if we find out that the table being attached (or its leaf
19179 * partitions) may contain rows that violate the partition constraint. If
19180 * the table has a constraint that would prevent such rows, which by
19181 * definition is present in all the partitions, we need not scan the
19182 * table, nor its partitions. But we cannot risk a deadlock by taking a
19183 * weaker lock now and the stronger one only when needed.
19184 */
19195 /* If the parent is permanent, so must be all of its partitions. */
19203 /* Temp parent cannot have a partition that is itself not a temp */
19211 /* If the parent is temp, it must belong to this session */
19218 /* Ditto for the partition */
19225 /*
19226 * Check if attachrel has any identity columns or any columns that aren't
19227 * in the parent.
19228 */
19232 {
19236 /* Ignore dropped */
19247 /* Try to find the column in parent (matching on column name) */
19257 }
19259 /*
19260 * If child_rel has row-level triggers with transition tables, we
19261 * currently don't allow it to become a partition. See also prohibitions
19262 * in ATExecAddInherit() and CreateTrigger().
19263 */
19272 /*
19273 * Check that the new partition's bound is valid and does not overlap any
19274 * of existing partitions of the parent - note that it does not return on
19275 * error.
19276 */
19280 /* OK to create inheritance. Rest of the checks performed there */
19283 /* Update the pg_class entry. */
19286 /* Ensure there exists a correct set of indexes in the partition. */
19289 /* and triggers */
19292 /*
19293 * Clone foreign key constraints. Callee is responsible for setting up
19294 * for phase 3 constraint verification.
19295 */
19298 /*
19299 * Generate partition constraint from the partition bound specification.
19300 * If the parent itself is a partition, make sure to include its
19301 * constraint as well.
19302 */
19307 /* Skip validation if there are no constraints to validate. */
19309 {
19310 /*
19311 * Run the partition quals through const-simplification similar to
19312 * check constraints. We skip canonicalize_qual, though, because
19313 * partition quals should be in canonical form already.
19314 */
19315 partConstraint =
19319 /* XXX this sure looks wrong */
19322 /*
19323 * Adjust the generated constraint to match this partition's attribute
19324 * numbers.
19325 */
19327 rel);
19329 /* Validate partition constraints against the table being attached. */
19332 }
19334 /*
19335 * If we're attaching a partition other than the default partition and a
19336 * default one exists, then that partition's partition constraint changes,
19337 * so add an entry to the work queue to validate it, too. (We must not do
19338 * this when the partition being attached is the default one; we already
19339 * did it above!)
19340 */
19342 {
19343 Relation defaultrel;
19348 /* we already hold a lock on the default partition */
19350 defPartConstraint =
19353 /*
19354 * Map the Vars in the constraint expression from rel's attnos to
19355 * defaultrel's.
19356 */
19357 defPartConstraint =
19363 /* keep our lock until commit. */
19365 }
19369 /*
19370 * If the partition we just attached is partitioned itself, invalidate
19371 * relcache for all descendent partitions too to ensure that their
19372 * rd_partcheck expression trees are rebuilt; partitions already locked at
19373 * the beginning of this function.
19374 */
19376 {
19380 {
19382 }
19383 }
19385 /* keep our lock until commit */
19389 }
19391 /*
19392 * AttachPartitionEnsureIndexes
19393 * subroutine for ATExecAttachPartition to create/match indexes
19394 *
19395 * Enforce the indexing rule for partitioned tables during ALTER TABLE / ATTACH
19396 * PARTITION: every partition must have an index attached to each index on the
19397 * partitioned table.
19398 */
19399 static void
19401 {
19407 MemoryContext cxt;
19408 MemoryContext oldcxt;
19412 ALLOCSET_DEFAULT_SIZES);
19420 /* Build arrays of all existing indexes and their IndexInfos */
19422 {
19428 }
19430 /*
19431 * If we're attaching a foreign table, we must fail if any of the indexes
19432 * is a constraint index; otherwise, there's nothing to do here. Do this
19433 * before starting work, to avoid wasting the effort of building a few
19434 * non-unique indexes before coming across a unique one.
19435 */
19437 {
19439 {
19453 }
19456 }
19458 /*
19459 * For each index on the partitioned table, find a matching one in the
19460 * partition-to-be; if one is not found, create one.
19461 */
19463 {
19469 Oid constraintOid;
19471 /*
19472 * Ignore indexes in the partitioned table other than partitioned
19473 * indexes.
19474 */
19476 {
19479 }
19481 /* construct an indexinfo to compare existing indexes against */
19488 /*
19489 * Scan the list of existing indexes in the partition-to-be, and mark
19490 * the first matching, valid, unattached one we find, if any, as
19491 * partition of the parent index. If we find one, we're done.
19492 */
19494 {
19498 /* does this index have a parent? if so, can't use it */
19502 /* If this index is invalid, can't use it */
19511 attmap))
19512 {
19513 /*
19514 * If this index is being created in the parent because of a
19515 * constraint, then the child needs to have a constraint also,
19516 * so look for one. If there is no such constraint, this
19517 * index is no good, so keep looking.
19518 */
19520 {
19521 cldConstrOid =
19523 cldIdxId);
19524 /* no dice */
19527 }
19529 /* bingo. */
19538 }
19539 }
19541 /*
19542 * If no suitable index was found in the partition-to-be, create one
19543 * now.
19544 */
19546 {
19548 Oid conOid;
19554 /*
19555 * If the index is a primary key, mark all columns as NOT NULL if
19556 * they aren't already.
19557 */
19559 {
19562 {
19563 AttrNumber childattno;
19571 }
19573 }
19577 conOid,
19580 }
19583 }
19585 out:
19586 /* Clean up. */
19591 }
19593 /*
19594 * CloneRowTriggersToPartition
19595 * subroutine for ATExecAttachPartition/DefineRelation to create row
19596 * triggers on partitions
19597 */
19598 static void
19600 {
19601 Relation pg_trigger;
19602 ScanKeyData key;
19603 SysScanDesc scan;
19604 HeapTuple tuple;
19605 MemoryContext perTupCxt;
19617 {
19621 Datum value;
19625 MemoryContext oldcxt;
19627 /*
19628 * Ignore statement-level triggers; those are not cloned.
19629 */
19633 /*
19634 * Don't clone internal triggers, because the constraint cloning code
19635 * will.
19636 */
19640 /*
19641 * Complain if we find an unexpected trigger type.
19642 */
19648 /* Use short-lived context for CREATE TRIGGER */
19651 /*
19652 * If there is a WHEN clause, generate a 'cooked' version of it that's
19653 * appropriate for the partition.
19654 */
19658 {
19664 }
19666 /*
19667 * If there is a column list, transform it to a list of column names.
19668 * Note we don't need to map this list in any way ...
19669 */
19671 {
19675 {
19676 Form_pg_attribute col;
19682 }
19683 }
19685 /* Reconstruct trigger arguments list. */
19687 {
19699 {
19702 }
19703 }
19729 }
19735 }
19737 /*
19738 * ALTER TABLE DETACH PARTITION
19739 *
19740 * Return the address of the relation that is no longer a partition of rel.
19741 *
19742 * If concurrent mode is requested, we run in two transactions. A side-
19743 * effect is that this command cannot run in a multi-part ALTER TABLE.
19744 * Currently, that's enforced by the grammar.
19745 *
19746 * The strategy for concurrency is to first modify the partition's
19747 * pg_inherit catalog row to make it visible to everyone that the
19748 * partition is detached, lock the partition against writes, and commit
19749 * the transaction; anyone who requests the partition descriptor from
19750 * that point onwards has to ignore such a partition. In a second
19751 * transaction, we wait until all transactions that could have seen the
19752 * partition as attached are gone, then we remove the rest of partition
19753 * metadata (pg_inherits and pg_class.relpartbounds).
19754 */
19755 static ObjectAddress
19758 {
19759 Relation partRel;
19760 ObjectAddress address;
19761 Oid defaultPartOid;
19763 /*
19764 * We must lock the default partition, because detaching this partition
19765 * will change its partition constraint.
19766 */
19767 defaultPartOid =
19770 {
19771 /*
19772 * Concurrent detaching when a default partition exists is not
19773 * supported. The main problem is that the default partition
19774 * constraint would change. And there's a definitional problem: what
19775 * should happen to the tuples that are being inserted that belong to
19776 * the partition being detached? Putting them on the partition being
19777 * detached would be wrong, since they'd become "lost" after the
19778 * detaching completes but we cannot put them in the default partition
19779 * either until we alter its partition constraint.
19780 *
19781 * I think we could solve this problem if we effected the constraint
19782 * change before committing the first transaction. But the lock would
19783 * have to remain AEL and it would cause concurrent query planning to
19784 * be blocked, so changing it that way would be even worse.
19785 */
19791 }
19793 /*
19794 * In concurrent mode, the partition is locked with share-update-exclusive
19795 * in the first transaction. This allows concurrent transactions to be
19796 * doing DML to the partition.
19797 */
19799 AccessExclusiveLock);
19801 /*
19802 * Check inheritance conditions and either delete the pg_inherits row (in
19803 * non-concurrent mode) or just set the inhdetachpending flag.
19804 */
19807 else
19810 /*
19811 * Ensure that foreign keys still hold after this detach. This keeps
19812 * locks on the referencing tables, which prevents concurrent transactions
19813 * from adding rows that we wouldn't see. For this to work in concurrent
19814 * mode, it is critical that the partition appears as no longer attached
19815 * for the RI queries as soon as the first transaction commits.
19816 */
19819 /*
19820 * Concurrent mode has to work harder; first we add a new constraint to
19821 * the partition that matches the partition constraint. Then we close our
19822 * existing transaction, and in a new one wait for all processes to catch
19823 * up on the catalog updates we've done so far; at that point we can
19824 * complete the operation.
19825 */
19827 {
19828 Oid partrelid,
19829 parentrelid;
19830 LOCKTAG tag;
19834 /*
19835 * Add a new constraint to the partition being detached, which
19836 * supplants the partition constraint (unless there is one already).
19837 */
19840 /*
19841 * We're almost done now; the only traces that remain are the
19842 * pg_inherits tuple and the partition's relpartbounds. Before we can
19843 * remove those, we need to wait until all transactions that know that
19844 * this is a partition are gone.
19845 */
19847 /*
19848 * Remember relation OIDs to re-acquire them later; and relation names
19849 * too, for error messages if something is dropped in between.
19850 */
19858 /* Invalidate relcache entries for the parent -- must be before close */
19865 /* Make updated catalog entry visible */
19871 /*
19872 * Now wait. This ensures that all queries that were planned
19873 * including the partition are finished before we remove the rest of
19874 * catalog entries. We don't need or indeed want to acquire this
19875 * lock, though -- that would block later queries.
19876 *
19877 * We don't need to concern ourselves with waiting for a lock on the
19878 * partition itself, since we will acquire AccessExclusiveLock below.
19879 */
19883 /*
19884 * Now acquire locks in both relations again. Note they may have been
19885 * removed in the meantime, so care is required.
19886 */
19890 /* If the relations aren't there, something bad happened; bail out */
19892 {
19895 partrelname);
19899 parentrelname)));
19900 }
19907 }
19909 /* Do the final part of detaching */
19914 /* keep our lock until commit */
19918 }
19920 /*
19921 * Second part of ALTER TABLE .. DETACH.
19922 *
19923 * This is separate so that it can be run independently when the second
19924 * transaction of the concurrent algorithm fails (crash or abort).
19925 */
19926 static void
19928 Oid defaultPartOid)
19929 {
19930 Relation classRel;
19937 HeapTuple tuple,
19938 newtuple;
19942 {
19943 /*
19944 * We can remove the pg_inherits row now. (In the non-concurrent case,
19945 * this was already done).
19946 */
19948 }
19950 /* Drop any triggers that were cloned on creation/attach. */
19953 /*
19954 * Detach any foreign keys that are inherited. This includes creating
19955 * additional action triggers.
19956 */
19961 {
19963 HeapTuple contup;
19964 Form_pg_constraint conform;
19966 Oid insertTriggerOid,
19967 updateTriggerOid;
19974 /* consider only the inherited foreign keys */
19977 {
19980 }
19982 /* unset conparentid and adjust conislocal, coninhcount, etc. */
19985 /*
19986 * Also, look up the partition's "check" triggers corresponding to the
19987 * constraint being detached and detach them from the parent triggers.
19988 */
19999 /*
20000 * Make the action triggers on the referenced relation. When this was
20001 * a partition the action triggers pointed to the parent rel (they
20002 * still do), but now we need separate ones of our own.
20003 */
20029 }
20034 /*
20035 * Any sub-constraints that are in the referenced-side of a larger
20036 * constraint have to be removed. This partition is no longer part of the
20037 * key space of the constraint.
20038 */
20040 {
20042 ObjectAddress constraint;
20046 constrOid,
20047 ConstraintRelationId,
20048 DEPENDENCY_INTERNAL);
20053 }
20055 /* Now we can detach indexes */
20058 {
20060 Relation idx;
20061 Oid constrOid;
20072 /* If there's a constraint associated with the index, detach it too */
20074 idxid);
20079 }
20081 /* Update pg_class tuple */
20090 /* Clear relpartbound and reset relispartition */
20105 /*
20106 * Drop identity property from all identity columns of partition.
20107 */
20109 {
20115 }
20118 {
20119 /*
20120 * If the relation being detached is the default partition itself,
20121 * remove it from the parent's pg_partitioned_table entry.
20122 *
20123 * If not, we must invalidate default partition's relcache entry, as
20124 * in StorePartitionBound: its partition constraint depends on every
20125 * other partition's partition constraint.
20126 */
20129 else
20131 }
20133 /*
20134 * Invalidate the parent's relcache so that the partition is no longer
20135 * included in its partition descriptor.
20136 */
20139 /*
20140 * If the partition we just detached is partitioned itself, invalidate
20141 * relcache for all descendent partitions too to ensure that their
20142 * rd_partcheck expression trees are rebuilt; must lock partitions before
20143 * doing so, using the same lockmode as what partRel has been locked with
20144 * by the caller.
20145 */
20147 {
20153 {
20155 }
20156 }
20157 }
20159 /*
20160 * ALTER TABLE ... DETACH PARTITION ... FINALIZE
20161 *
20162 * To use when a DETACH PARTITION command previously did not run to
20163 * completion; this completes the detaching process.
20164 */
20165 static ObjectAddress
20167 {
20168 Relation partRel;
20169 ObjectAddress address;
20174 /*
20175 * Wait until existing snapshots are gone. This is important if the
20176 * second transaction of DETACH PARTITION CONCURRENTLY is canceled: the
20177 * user could immediately run DETACH FINALIZE without actually waiting for
20178 * existing transactions. We must not complete the detach action until
20179 * all such queries are complete (otherwise we would present them with an
20180 * inconsistent view of catalogs).
20181 */
20191 }
20193 /*
20194 * DetachAddConstraintIfNeeded
20195 * Subroutine for ATExecDetachPartition. Create a constraint that
20196 * takes the place of the partition constraint, but avoid creating
20197 * a dupe if an constraint already exists which implies the needed
20198 * constraint.
20199 */
20200 static void
20202 {
20208 /*
20209 * Avoid adding a new constraint if the needed constraint is implied by an
20210 * existing constraint
20211 */
20213 {
20219 /* Add constraint on partition, equivalent to the partition constraint */
20229 /* It's a re-add, since it nominally already exists */
20232 }
20233 }
20235 /*
20236 * DropClonedTriggersFromPartition
20237 * subroutine for ATExecDetachPartition to remove any triggers that were
20238 * cloned to the partition when it was created-as-partition or attached.
20239 * This undoes what CloneRowTriggersToPartition did.
20240 */
20241 static void
20243 {
20244 ScanKeyData skey;
20245 SysScanDesc scan;
20246 HeapTuple trigtup;
20247 Relation tgrel;
20252 /*
20253 * Scan pg_trigger to search for all triggers on this rel.
20254 */
20261 {
20263 ObjectAddress trig;
20265 /* Ignore triggers that weren't cloned */
20269 /*
20270 * Ignore internal triggers that are implementation objects of foreign
20271 * keys, because these will be detached when the foreign keys
20272 * themselves are.
20273 */
20277 /*
20278 * This is ugly, but necessary: remove the dependency markings on the
20279 * trigger so that it can be removed.
20280 */
20282 TriggerRelationId,
20283 DEPENDENCY_PARTITION_PRI);
20285 RelationRelationId,
20286 DEPENDENCY_PARTITION_SEC);
20288 /* remember this trigger to remove it below */
20291 }
20293 /* make the dependency removal visible to the deletion below */
20297 /* done */
20301 }
20303 /*
20304 * Before acquiring lock on an index, acquire the same lock on the owning
20305 * table.
20306 */
20307 struct AttachIndexCallbackState
20308 {
20309 Oid partitionOid;
20310 Oid parentTblOid;
20312 };
20314 static void
20317 {
20319 Form_pg_class classform;
20320 HeapTuple tuple;
20325 {
20328 }
20330 /*
20331 * If we previously locked some other heap, and the name we're looking up
20332 * no longer refers to an index on that relation, release the now-useless
20333 * lock. XXX maybe we should do *after* we verify whether the index does
20334 * not actually belong to the same relation ...
20335 */
20337 {
20340 }
20342 /* Didn't find a relation, so no need for locking or permission checks. */
20357 /*
20358 * Since we need only examine the heap's tupledesc, an access share lock
20359 * on it (preventing any DDL) is sufficient.
20360 */
20363 }
20365 /*
20366 * ALTER INDEX i1 ATTACH PARTITION i2
20367 */
20368 static ObjectAddress
20370 {
20371 Relation partIdx;
20372 Relation partTbl;
20373 Relation parentTbl;
20374 ObjectAddress address;
20375 Oid partIdxId;
20376 Oid currParent;
20379 /*
20380 * We need to obtain lock on the index 'name' to modify it, but we also
20381 * need to read its owning table's tuple descriptor -- so we need to lock
20382 * both. To avoid deadlocks, obtain lock on the table before doing so on
20383 * the index. Furthermore, we need to examine the parent table of the
20384 * partition, so lock that one too.
20385 */
20389 partIdxId =
20391 RangeVarCallbackForAttachIndex,
20393 /* Not there? */
20399 /* no deadlock risk: RangeVarGetRelidExtended already acquired the lock */
20402 /* we already hold locks on both tables, so this is safe: */
20408 /* Silently do nothing if already in the right state */
20412 {
20418 PartitionDesc partDesc;
20419 Oid constraintOid,
20422 /*
20423 * If this partition already has an index attached, refuse the
20424 * operation.
20425 */
20437 /* Make sure it indexes a partition of the other index's table */
20441 {
20443 {
20446 }
20447 }
20458 /* Ensure the indexes are compatible */
20469 attmap))
20477 /*
20478 * If there is a constraint in the parent, make sure there is one in
20479 * the child too.
20480 */
20485 {
20487 partIdxId);
20494 errdetail("The index \"%s\" belongs to a constraint in table \"%s\" but no constraint exists for index \"%s\".",
20498 }
20500 /*
20501 * If it's a primary key, make sure the columns in the partition are
20502 * NOT NULL.
20503 */
20507 /* All good -- do it */
20516 }
20519 /* keep these locks till commit */
20524 }
20526 /*
20527 * Verify whether the given partition already contains an index attached
20528 * to the given partitioned index. If so, raise an error.
20529 */
20530 static void
20532 {
20533 Oid existingIdx;
20545 }
20547 /*
20548 * Verify whether the set of attached partition indexes to a parent index on
20549 * a partitioned table is complete. If it is, mark the parent index valid.
20550 *
20551 * This should be called each time a partition index is attached.
20552 */
20553 static void
20555 {
20556 Relation inheritsRel;
20557 SysScanDesc scan;
20558 ScanKeyData key;
20560 HeapTuple inhTup;
20565 /*
20566 * Scan pg_inherits for this parent index. Count each valid index we find
20567 * (verifying the pg_index entry for each), and if we reach the total
20568 * amount we expect, we can mark this parent index as valid.
20569 */
20577 {
20579 HeapTuple indTup;
20580 Form_pg_index indexForm;
20590 }
20592 /* Done with pg_inherits */
20596 /*
20597 * If we found as many inherited indexes as the partitioned table has
20598 * partitions, we're good; update pg_index to set indisvalid.
20599 */
20601 {
20602 Relation idxRel;
20603 HeapTuple indTup;
20604 Form_pg_index indexForm;
20621 }
20623 /*
20624 * If this index is in turn a partition of a larger index, validating it
20625 * might cause the parent to become valid also. Try that.
20626 */
20628 {
20629 Oid parentIdxId,
20630 parentTblId;
20631 Relation parentIdx,
20632 parentTbl;
20634 /* make sure we see the validation we just did */
20647 }
20648 }
20650 /*
20651 * When attaching an index as a partition of a partitioned index which is a
20652 * primary key, verify that all the columns in the partition are marked NOT
20653 * NULL.
20654 */
20655 static void
20657 {
20659 {
20670 }
20671 }
20673 /*
20674 * Return an OID list of constraints that reference the given relation
20675 * that are marked as having a parent constraints.
20676 */
20679 {
20680 Relation pg_constraint;
20681 HeapTuple tuple;
20682 SysScanDesc scan;
20686 /*
20687 * If no indexes, or no columns are referenceable by FKs, we can avoid the
20688 * scan.
20689 */
20692 INDEX_ATTR_BITMAP_KEY)))
20695 /* Search for constraints referencing this table */
20704 /* XXX This is a seqscan, as we don't have a usable index */
20707 {
20710 /*
20711 * We only need to process constraints that are part of larger ones.
20712 */
20717 }
20723 }
20725 /*
20726 * During DETACH PARTITION, verify that any foreign keys pointing to the
20727 * partitioned table would not become invalid. An error is raised if any
20728 * referenced values exist.
20729 */
20730 static void
20732 {
20739 {
20741 HeapTuple tuple;
20742 Form_pg_constraint constrForm;
20743 Relation rel;
20754 /* prevent data changes into the referencing table until commit */
20766 /* we needn't fill in remaining fields */
20773 }
20774 }
20776 /*
20777 * resolve column compression specification to compression method.
20778 */
20779 static char
20781 {
20787 /*
20788 * To specify a nondefault method, the column data type must be toastable.
20789 * Note this says nothing about whether the column's attstorage setting
20790 * permits compression; we intentionally allow attstorage and
20791 * attcompression to be independent. But with a non-toastable type,
20792 * attstorage could not be set to a value that would permit compression.
20793 *
20794 * We don't actually need to enforce this, since nothing bad would happen
20795 * if attcompression were non-default; it would never be consulted. But
20796 * it seems more user-friendly to complain about a certainly-useless
20797 * attempt to set the property.
20798 */
20812 }
20814 /*
20815 * resolve column storage specification
20816 */
20817 static char
20819 {
20832 else
20836 storagemode)));
20838 /*
20839 * safety check: do not allow toasted storage modes unless column datatype
20840 * is TOAST-aware.
20841 */
20849 }