| blob | f77de4e7c99a20aba5f5caeaceadab18dc16740e |
1 /*-------------------------------------------------------------------------
2 *
3 * tablecmds.c
4 * Commands for creating and altering table structures and settings
5 *
6 * Portions Copyright (c) 1996-2023, 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 */
109 /*
110 * ON COMMIT action list
111 */
113 {
117 /*
118 * If this entry was created during the current transaction,
119 * creating_subid is the ID of the creating subxact; if created in a prior
120 * transaction, creating_subid is zero. If deleted during the current
121 * transaction, deleting_subid is the ID of the deleting subxact; if no
122 * deletion request is pending, deleting_subid is zero.
123 */
124 SubTransactionId creating_subid;
125 SubTransactionId deleting_subid;
131 /*
132 * State information for ALTER TABLE
133 *
134 * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
135 * structs, one for each table modified by the operation (the named table
136 * plus any child tables that are affected). We save lists of subcommands
137 * to apply to this table (possibly modified by parse transformation steps);
138 * these lists will be executed in Phase 2. If a Phase 3 step is needed,
139 * necessary information is stored in the constraints and newvals lists.
140 *
141 * Phase 2 is divided into multiple passes; subcommands are executed in
142 * a pass determined by subcommand type.
143 */
150 /* We could support a RENAME COLUMN pass here, but not currently used */
158 #define AT_NUM_PASSES 11
161 {
162 /* Information saved before any work commences: */
167 /*
168 * Transiently set during Phase 2, normally set to NULL.
169 *
170 * ATRewriteCatalogs sets this when it starts, and closes when ATExecCmd
171 * returns control. This can be exploited by ATExecCmd subroutines to
172 * close/reopen across transaction boundaries.
173 */
174 Relation rel;
176 /* Information saved by Phase 1 for Phase 2: */
178 /* Information saved by Phases 1/2 for Phase 3: */
189 /* true, if validating default due to some other attach/detach */
191 /* Objects to rebuild after completing ALTER TYPE operations */
202 /* Struct describing one new constraint to check in Phase 3 scan */
203 /* Note: new NOT NULL constraints are handled elsewhere */
205 {
215 /*
216 * Struct describing one new column value that needs to be computed during
217 * Phase 3 copy (this could be either a new column with a non-null default, or
218 * a column that we're changing the type of). Columns without such an entry
219 * are just copied from the old table during ATRewriteTable. Note that the
220 * expr is an expression over *old* table values, except when is_generated
221 * is true; then it is an expression over columns of the *new* tuple.
222 */
224 {
231 /*
232 * Error-reporting support for RemoveRelations
233 */
234 struct dropmsgstrings
235 {
242 };
246 ERRCODE_UNDEFINED_TABLE,
252 ERRCODE_UNDEFINED_TABLE,
258 ERRCODE_UNDEFINED_TABLE,
264 ERRCODE_UNDEFINED_TABLE,
270 ERRCODE_UNDEFINED_OBJECT,
276 ERRCODE_UNDEFINED_OBJECT,
282 ERRCODE_UNDEFINED_OBJECT,
288 ERRCODE_UNDEFINED_TABLE,
294 ERRCODE_UNDEFINED_OBJECT,
300 };
302 /* communication between RemoveRelations and RangeVarCallbackForDropRelation */
303 struct DropRelationCallbackState
304 {
305 /* These fields are set by RemoveRelations: */
307 LOCKMODE heap_lockmode;
308 /* These fields are state to track which subsidiary locks are held: */
309 Oid heapOid;
310 Oid partParentOid;
311 /* These fields are passed back by RangeVarCallbackForDropRelation: */
314 };
316 /* Alter table target-type flags for ATSimplePermissions */
317 #define ATT_TABLE 0x0001
318 #define ATT_VIEW 0x0002
319 #define ATT_MATVIEW 0x0004
320 #define ATT_INDEX 0x0008
321 #define ATT_COMPOSITE_TYPE 0x0010
322 #define ATT_FOREIGN_TABLE 0x0020
323 #define ATT_PARTITIONED_INDEX 0x0040
324 #define ATT_SEQUENCE 0x0080
326 /*
327 * ForeignTruncateInfo
328 *
329 * Information related to truncation of foreign tables. This is used for
330 * the elements in a hash table. It uses the server OID as lookup key,
331 * and includes a per-server list of all foreign tables involved in the
332 * truncation.
333 */
335 {
336 Oid serverid;
340 /*
341 * Partition tables are expected to be dropped when the parent partitioned
342 * table gets dropped. Hence for partitioning we use AUTO dependency.
343 * Otherwise, for regular inheritance use NORMAL dependency.
344 */
345 #define child_dependency_type(child_is_partition) \
346 ((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)
368 LOCKMODE lockmode);
373 LOCKMODE lockmode);
419 LOCKMODE lockmode,
422 DropBehavior behavior);
439 LOCKMODE lockmode,
456 static ObjectAddress ATExecDropIdentity(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
457 static void ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode);
458 static ObjectAddress ATExecDropExpression(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
469 DropBehavior behavior,
480 LOCKMODE lockmode);
488 LOCKMODE lockmode);
492 LOCKMODE lockmode);
511 Relation partitionRel);
514 Relation partRel);
517 Oid indexOid,
522 Oid indexOid,
526 Oid partRelid,
530 Oid parentInsTrigger,
531 Oid parentUpdTrigger,
532 Relation trigrel);
542 DropBehavior behavior,
557 LOCKMODE lockmode);
573 LOCKMODE lockmode);
582 AlterTableType operation,
583 LOCKMODE lockmode);
586 LOCKMODE lockmode);
593 DependencyType deptype);
611 static void ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
613 PartitionStrategy strategy);
637 Relation partitionTbl);
644 /* ----------------------------------------------------------------
645 * DefineRelation
646 * Creates a new relation.
647 *
648 * stmt carries parsetree information from an ordinary CREATE TABLE statement.
649 * The other arguments are used to extend the behavior for other cases:
650 * relkind: relkind to assign to the new relation
651 * ownerId: if not InvalidOid, use this as the new relation's owner.
652 * typaddress: if not null, it's set to the pg_type entry's address.
653 * queryString: for error reporting
654 *
655 * Note that permissions checks are done against current user regardless of
656 * ownerId. A nonzero ownerId is used when someone is creating a relation
657 * "on behalf of" someone else, so we still want to see that the current user
658 * has permissions to do it.
659 *
660 * If successful, returns the address of the new relation.
661 * ----------------------------------------------------------------
662 */
663 ObjectAddress
666 {
668 Oid namespaceId;
669 Oid relationId;
670 Oid tablespaceId;
671 Relation rel;
672 TupleDesc descriptor;
677 Datum reloptions;
679 AttrNumber attnum;
682 Oid ofTypeId;
683 ObjectAddress address;
684 LOCKMODE parentLockmode;
688 /*
689 * Truncate relname to appropriate length (probably a waste of time, as
690 * parser should have done this already).
691 */
694 /*
695 * Check consistency of arguments
696 */
704 {
710 }
711 else
714 /*
715 * Look up the namespace in which we are supposed to create the relation,
716 * check we have permission to create there, lock it against concurrent
717 * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
718 * namespace is selected.
719 */
720 namespaceId =
723 /*
724 * Security check: disallow creating temp tables from security-restricted
725 * code. This is needed because calling code might not expect untrusted
726 * tables to appear in pg_temp at the front of its search path.
727 */
734 /*
735 * Determine the lockmode to use when scanning parents. A self-exclusive
736 * lock is needed here.
737 *
738 * For regular inheritance, if two backends attempt to add children to the
739 * same parent simultaneously, and that parent has no pre-existing
740 * children, then both will attempt to update the parent's relhassubclass
741 * field, leading to a "tuple concurrently updated" error. Also, this
742 * interlocks against a concurrent ANALYZE on the parent table, which
743 * might otherwise be attempting to clear the parent's relhassubclass
744 * field, if its previous children were recently dropped.
745 *
746 * If the child table is a partition, then we instead grab an exclusive
747 * lock on the parent because its partition descriptor will be changed by
748 * addition of the new partition.
749 */
751 ShareUpdateExclusiveLock);
753 /* Determine the list of OIDs of the parents. */
756 {
758 Oid parentOid;
762 /*
763 * Reject duplications in the list of parents.
764 */
772 }
774 /*
775 * Select tablespace to use: an explicitly indicated one, or (in the case
776 * of a partitioned table) the parent's, if it has one.
777 */
779 {
786 }
788 {
789 /*
790 * For partitions, when no other tablespace is specified, we default
791 * the tablespace to the parent partitioned table's.
792 */
795 }
796 else
799 /* still nothing? use the default */
802 partitioned);
804 /* Check permissions except when using database's default */
806 {
807 AclResult aclresult;
810 ACL_CREATE);
814 }
816 /* In all cases disallow placing user relations in pg_global */
822 /* Identify user ID that will own the table */
826 /*
827 * Parse and validate reloptions, if any.
828 */
833 {
842 }
845 {
846 AclResult aclresult;
853 }
854 else
857 /*
858 * Look up inheritance ancestors and generate relation schema, including
859 * inherited attributes. (Note that stmt->tableElts is destructively
860 * modified by MergeAttributes.)
861 */
868 /*
869 * Create a tuple descriptor from the relation schema. Note that this
870 * deals with column names, types, and NOT NULL constraints, but not
871 * default values or CHECK constraints; we handle those below.
872 */
875 /*
876 * Find columns with default values and prepare for insertion of the
877 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
878 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
879 * while raw defaults go into a list of RawColumnDefault structs that will
880 * be processed by AddRelationNewConstraints. (We can't deal with raw
881 * expressions until we can do transformExpr.)
882 *
883 * We can set the atthasdef flags now in the tuple descriptor; this just
884 * saves StoreAttrDefault from having to do an immediate update of the
885 * pg_attribute rows.
886 */
892 {
894 Form_pg_attribute attr;
896 attnum++;
900 {
912 }
914 {
929 }
943 }
945 /*
946 * If the statement hasn't specified an access method, but we're defining
947 * a type of relation that needs one, use the default.
948 */
950 {
957 }
961 /* look up the access method, verify it is for a table */
965 /*
966 * Create the relation. Inherited defaults and constraints are passed in
967 * for immediate handling --- since they don't need parsing, they can be
968 * stored immediately.
969 */
971 namespaceId,
972 tablespaceId,
973 InvalidOid,
974 InvalidOid,
975 ofTypeId,
976 ownerId,
977 accessMethodId,
978 descriptor,
980 old_constraints),
981 relkind,
986 reloptions,
988 allowSystemTableMods,
990 InvalidOid,
991 typaddress);
993 /*
994 * We must bump the command counter to make the newly-created relation
995 * tuple visible for opening.
996 */
999 /*
1000 * Open the new relation and acquire exclusive lock on it. This isn't
1001 * really necessary for locking out other backends (since they can't see
1002 * the new rel anyway until we commit), but it keeps the lock manager from
1003 * complaining about deadlock risks.
1004 */
1007 /*
1008 * Now add any newly specified column default and generation expressions
1009 * to the new relation. These are passed to us in the form of raw
1010 * parsetrees; we need to transform them to executable expression trees
1011 * before they can be added. The most convenient way to do that is to
1012 * apply the parser's transformExpr routine, but transformExpr doesn't
1013 * work unless we have a pre-existing relation. So, the transformation has
1014 * to be postponed to this final step of CREATE TABLE.
1015 *
1016 * This needs to be before processing the partitioning clauses because
1017 * those could refer to generated columns.
1018 */
1023 /*
1024 * Make column generation expressions visible for use by partitioning.
1025 */
1028 /* Process and store partition bound, if any. */
1030 {
1034 defaultPartOid;
1035 Relation parent,
1039 /* Already have strong enough lock on the parent */
1042 /*
1043 * We are going to try to validate the partition bound specification
1044 * against the partition key of parentRel, so it better have one.
1045 */
1052 /*
1053 * The partition constraint of the default partition depends on the
1054 * partition bounds of every other partition. It is possible that
1055 * another backend might be about to execute a query on the default
1056 * partition table, and that the query relies on previously cached
1057 * default partition constraints. We must therefore take a table lock
1058 * strong enough to prevent all queries on the default partition from
1059 * proceeding until we commit and send out a shared-cache-inval notice
1060 * that will make them update their index lists.
1061 *
1062 * Order of locking: The relation being added won't be visible to
1063 * other backends until it is committed, hence here in
1064 * DefineRelation() the order of locking the default partition and the
1065 * relation being added does not matter. But at all other places we
1066 * need to lock the default relation before we lock the relation being
1067 * added or removed i.e. we should take the lock in same order at all
1068 * the places such that lock parent, lock default partition and then
1069 * lock the partition so as to avoid a deadlock.
1070 */
1071 defaultPartOid =
1077 /* Transform the bound values */
1081 /*
1082 * Add an nsitem containing this relation, so that transformExpr
1083 * called on partition bound expressions is able to report errors
1084 * using a proper context.
1085 */
1092 /*
1093 * Check first that the new partition's bound is valid and does not
1094 * overlap with any of existing partitions of the parent.
1095 */
1098 /*
1099 * If the default partition exists, its partition constraints will
1100 * change after the addition of this new partition such that it won't
1101 * allow any row that qualifies for this new partition. So, check that
1102 * the existing data in the default partition satisfies the constraint
1103 * as it will exist after adding this partition.
1104 */
1106 {
1108 /* Keep the lock until commit. */
1110 }
1112 /* Update the pg_class entry. */
1116 }
1118 /* Store inheritance information for new rel. */
1121 /*
1122 * Process the partitioning specification (if any) and store the partition
1123 * key information into the catalog.
1124 */
1126 {
1139 /* Protect fixed-size arrays here and in executor */
1144 PARTITION_MAX_KEYS)));
1146 /*
1147 * We need to transform the raw parsetrees corresponding to partition
1148 * expressions into executable expression trees. Like column defaults
1149 * and CHECK constraints, we could not have done the transformation
1150 * earlier.
1151 */
1159 partexprs,
1162 /* make it all visible */
1164 }
1166 /*
1167 * If we're creating a partition, create now all the indexes, triggers,
1168 * FKs defined in the parent.
1169 *
1170 * We can't do it earlier, because DefineIndex wants to know the partition
1171 * key which we just stored.
1172 */
1174 {
1176 Relation parent;
1180 /* Already have strong enough lock on the parent */
1184 /*
1185 * For each index in the parent table, create one in the partition
1186 */
1188 {
1192 Oid constraintOid;
1195 {
1203 else
1204 {
1207 }
1208 }
1213 idxstmt =
1217 idxstmt,
1218 InvalidOid,
1220 constraintOid,
1225 }
1229 /*
1230 * If there are any row-level triggers, clone them to the new
1231 * partition.
1232 */
1236 /*
1237 * And foreign keys too. Note that because we're freshly creating the
1238 * table, there is no need to verify these new constraints.
1239 */
1243 }
1245 /*
1246 * Now add any newly specified CHECK constraints to the new relation. Same
1247 * as for defaults above, but these need to come after partitioning is set
1248 * up.
1249 */
1256 /*
1257 * Clean up. We keep lock on new relation (although it shouldn't be
1258 * visible to anyone else anyway, until commit).
1259 */
1263 }
1265 /*
1266 * Emit the right error or warning message for a "DROP" command issued on a
1267 * non-existent relation
1268 */
1269 static void
1271 {
1276 {
1278 {
1282 }
1283 else
1284 {
1288 }
1290 }
1293 {
1295 {
1297 {
1301 }
1302 else
1303 {
1306 }
1307 }
1308 }
1311 }
1313 /*
1314 * Emit the right error message for a "DROP" command issued on a
1315 * relation of the wrong type
1316 */
1317 static void
1319 {
1331 /* wrongkind could be something we don't have in our table... */
1337 }
1339 /*
1340 * RemoveRelations
1341 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW,
1342 * DROP MATERIALIZED VIEW, DROP FOREIGN TABLE
1343 */
1344 void
1346 {
1353 /* DROP CONCURRENTLY uses a weaker lock, and has some restrictions */
1355 {
1356 /*
1357 * Note that for temporary relations this lock may get upgraded later
1358 * on, but as no other session can access a temporary relation, this
1359 * is actually fine.
1360 */
1371 }
1373 /*
1374 * First we identify all the relations, then we delete them in a single
1375 * performMultipleDeletions() call. This is to avoid unwanted DROP
1376 * RESTRICT errors if one of the relations depends on another.
1377 */
1379 /* Determine required relkind */
1381 {
1411 }
1413 /* Lock and validate each relation; build a list of object addresses */
1417 {
1419 Oid relOid;
1420 ObjectAddress obj;
1423 /*
1424 * These next few steps are a great deal like relation_openrv, but we
1425 * don't bother building a relcache entry since we don't need it.
1426 *
1427 * Check for shared-cache-inval messages before trying to access the
1428 * relation. This is needed to cover the case where the name
1429 * identifies a rel that has been dropped and recreated since the
1430 * start of our transaction: if we don't flush the old syscache entry,
1431 * then we'll latch onto that entry and suffer an error later.
1432 */
1435 /* Look up the appropriate relation using namespace search. */
1439 /* We must initialize these fields to show that no locks are held: */
1444 RangeVarCallbackForDropRelation,
1447 /* Not there? */
1449 {
1452 }
1454 /*
1455 * Decide if concurrent mode needs to be used here or not. The
1456 * callback retrieved the rel's persistence for us.
1457 */
1460 {
1464 }
1466 /*
1467 * Concurrent index drop cannot be used with partitioned indexes,
1468 * either.
1469 */
1477 /*
1478 * If we're told to drop a partitioned index, we must acquire lock on
1479 * all the children of its parent partitioned table before proceeding.
1480 * Otherwise we'd try to lock the child index partitions before their
1481 * tables, leading to potential deadlock against other sessions that
1482 * will lock those objects in the other order.
1483 */
1487 NULL);
1489 /* OK, we're ready to delete this one */
1495 }
1500 }
1502 /*
1503 * Before acquiring a table lock, check whether we have sufficient rights.
1504 * In the case of DROP INDEX, also try to lock the table before the index.
1505 * Also, if the table to be dropped is a partition, we try to lock the parent
1506 * first.
1507 */
1508 static void
1511 {
1512 HeapTuple tuple;
1516 Form_pg_class classform;
1517 LOCKMODE heap_lockmode;
1523 /*
1524 * If we previously locked some other index's heap, and the name we're
1525 * looking up no longer refers to that relation, release the now-useless
1526 * lock.
1527 */
1529 {
1532 }
1534 /*
1535 * Similarly, if we previously locked some other partition's heap, and the
1536 * name we're looking up no longer refers to that relation, release the
1537 * now-useless lock.
1538 */
1540 {
1543 }
1545 /* Didn't find a relation, so no need for locking or permission checks. */
1555 /* Pass back some data to save lookups in RemoveRelations */
1559 /*
1560 * Both RELKIND_RELATION and RELKIND_PARTITIONED_TABLE are OBJECT_TABLE,
1561 * but RemoveRelations() can only pass one relkind for a given relation.
1562 * It chooses RELKIND_RELATION for both regular and partitioned tables.
1563 * That means we must be careful before giving the wrong type error when
1564 * the relation is RELKIND_PARTITIONED_TABLE. An equivalent problem
1565 * exists with indexes.
1566 */
1571 else
1578 /* Allow DROP to either table owner or schema owner */
1585 /*
1586 * Check the case of a system index that might have been invalidated by a
1587 * failed concurrent process and allow its drop. For the time being, this
1588 * only concerns indexes of toast relations that became invalid during a
1589 * REINDEX CONCURRENTLY process.
1590 */
1592 {
1593 HeapTuple locTuple;
1594 Form_pg_index indexform;
1599 {
1602 }
1608 /* Mark object as being an invalid index of system catalogs */
1611 }
1613 /* In the case of an invalid index, it is fine to bypass this check */
1622 /*
1623 * In DROP INDEX, attempt to acquire lock on the parent table before
1624 * locking the index. index_drop() will need this anyway, and since
1625 * regular queries lock tables before their indexes, we risk deadlock if
1626 * we do it the other way around. No error if we don't find a pg_index
1627 * entry, though --- the relation may have been dropped. Note that this
1628 * code will execute for either plain or partitioned indexes.
1629 */
1632 {
1636 }
1638 /*
1639 * Similarly, if the relation is a partition, we must acquire lock on its
1640 * parent before locking the partition. That's because queries lock the
1641 * parent before its partitions, so we risk deadlock if we do it the other
1642 * way around.
1643 */
1645 {
1649 }
1650 }
1652 /*
1653 * ExecuteTruncate
1654 * Executes a TRUNCATE command.
1655 *
1656 * This is a multi-relation truncate. We first open and grab exclusive
1657 * lock on all relations involved, checking permissions and otherwise
1658 * verifying that the relation is OK for truncation. Note that if relations
1659 * are foreign tables, at this stage, we have not yet checked that their
1660 * foreign data in external data sources are OK for truncation. These are
1661 * checked when foreign data are actually truncated later. In CASCADE mode,
1662 * relations having FK references to the targeted relations are automatically
1663 * added to the group; in RESTRICT mode, we check that all FK references are
1664 * internal to the group that's being truncated. Finally all the relations
1665 * are truncated and reindexed.
1666 */
1667 void
1669 {
1675 /*
1676 * Open, exclusive-lock, and check all the explicitly-specified relations
1677 */
1679 {
1681 Relation rel;
1683 Oid myrelid;
1688 NULL);
1690 /* don't throw error for "TRUNCATE foo, foo" */
1694 /* open the relation, we already hold a lock on it */
1697 /*
1698 * RangeVarGetRelidExtended() has done most checks with its callback,
1699 * but other checks with the now-opened Relation remain.
1700 */
1706 /* Log this relation only if needed for logical decoding */
1711 {
1718 {
1724 /* find_all_inheritors already got lock */
1727 /*
1728 * It is possible that the parent table has children that are
1729 * temp tables of other backends. We cannot safely access
1730 * such tables (because of buffering issues), and the best
1731 * thing to do is to silently ignore them. Note that this
1732 * check is the same as one of the checks done in
1733 * truncate_check_activity() called below, still it is kept
1734 * here for simplicity.
1735 */
1737 {
1740 }
1742 /*
1743 * Inherited TRUNCATE commands perform access permission
1744 * checks on the parent table only. So we skip checking the
1745 * children's permissions and don't call
1746 * truncate_check_perms() here.
1747 */
1754 /* Log this relation only if needed for logical decoding */
1757 }
1758 }
1763 errhint("Do not specify the ONLY keyword, or use TRUNCATE ONLY on the partitions directly.")));
1764 }
1769 /* And close the rels */
1771 {
1775 }
1776 }
1778 /*
1779 * ExecuteTruncateGuts
1780 *
1781 * Internal implementation of TRUNCATE. This is called by the actual TRUNCATE
1782 * command (see above) as well as replication subscribers that execute a
1783 * replicated TRUNCATE action.
1784 *
1785 * explicit_rels is the list of Relations to truncate that the command
1786 * specified. relids is the list of Oids corresponding to explicit_rels.
1787 * relids_logged is the list of Oids (a subset of relids) that require
1788 * WAL-logging. This is all a bit redundant, but the existing callers have
1789 * this information handy in this form.
1790 */
1791 void
1797 {
1804 SubTransactionId mySubid;
1808 /*
1809 * Check the explicitly-specified relations.
1810 *
1811 * In CASCADE mode, suck in all referencing relations as well. This
1812 * requires multiple iterations to find indirectly-dependent relations. At
1813 * each phase, we need to exclusive-lock new rels before looking for their
1814 * dependencies, else we might miss something. Also, we check each rel as
1815 * soon as we open it, to avoid a faux pas such as holding lock for a long
1816 * time on a rel we have no permissions for.
1817 */
1820 {
1822 {
1830 {
1832 Relation rel;
1844 /* Log this relation only if needed for logical decoding */
1847 }
1848 }
1849 }
1851 /*
1852 * Check foreign key references. In CASCADE mode, this should be
1853 * unnecessary since we just pulled in all the references; but as a
1854 * cross-check, do it anyway if in an Assert-enabled build.
1855 */
1856 #ifdef USE_ASSERT_CHECKING
1858 #else
1861 #endif
1863 /*
1864 * If we are asked to restart sequences, find all the sequences, lock them
1865 * (we need AccessExclusiveLock for ResetSequence), and check permissions.
1866 * We want to do this early since it's pointless to do all the truncation
1867 * work only to fail on sequence permissions.
1868 */
1870 {
1872 {
1878 {
1880 Relation seq_rel;
1884 /* This check must match AlterSequence! */
1892 }
1893 }
1894 }
1896 /* Prepare to catch AFTER triggers. */
1899 /*
1900 * To fire triggers, we'll need an EState as well as a ResultRelInfo for
1901 * each relation. We don't need to call ExecOpenIndices, though.
1902 *
1903 * We put the ResultRelInfos in the es_opened_result_relations list, even
1904 * though we don't have a range table and don't populate the
1905 * es_result_relations array. That's a bit bogus, but it's enough to make
1906 * ExecGetTriggerResultRel() find them.
1907 */
1913 {
1917 rel,
1919 NULL,
1923 resultRelInfo++;
1924 }
1926 /*
1927 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
1928 * truncating (this is because one of them might throw an error). Also, if
1929 * we were to allow them to prevent statement execution, that would need
1930 * to be handled here.
1931 */
1934 {
1935 UserContext ucxt;
1943 resultRelInfo++;
1944 }
1946 /*
1947 * OK, truncate each table.
1948 */
1952 {
1955 /* Skip partitioned tables as there is nothing to do */
1959 /*
1960 * Build the lists of foreign tables belonging to each foreign server
1961 * and pass each list to the foreign data wrapper's callback function,
1962 * so that each server can truncate its all foreign tables in bulk.
1963 * Each list is saved as a single entry in a hash table that uses the
1964 * server OID as lookup key.
1965 */
1967 {
1972 /* First time through, initialize hashtable for foreign tables */
1974 {
1975 HASHCTL hctl;
1986 }
1988 /* Find or create cached entry for the foreign table */
1991 {
1994 }
1996 /*
1997 * Save the foreign table in the entry of the server that the
1998 * foreign table belongs to.
1999 */
2002 }
2004 /*
2005 * Normally, we need a transaction-safe truncation here. However, if
2006 * the table was either created in the current (sub)transaction or has
2007 * a new relfilenumber in the current (sub)transaction, then we can
2008 * just truncate it in-place, because a rollback would cause the whole
2009 * table or the current physical file to be thrown away anyway.
2010 */
2013 {
2014 /* Immediate, non-rollbackable truncation is OK */
2016 }
2017 else
2018 {
2019 Oid heap_relid;
2020 Oid toast_relid;
2023 /*
2024 * This effectively deletes all rows in the table, and may be done
2025 * in a serializable transaction. In that case we must record a
2026 * rw-conflict in to this transaction from each transaction
2027 * holding a predicate lock on the table.
2028 */
2031 /*
2032 * Need the full transaction-safe pushups.
2033 *
2034 * Create a new empty storage file for the relation, and assign it
2035 * as the relfilenumber value. The old storage file is scheduled
2036 * for deletion at commit.
2037 */
2042 /*
2043 * The same for the toast table, if any.
2044 */
2047 {
2049 AccessExclusiveLock);
2054 }
2056 /*
2057 * Reconstruct the indexes to match, and we're done.
2058 */
2061 }
2064 }
2066 /* Now go through the hash table, and truncate foreign tables */
2068 {
2070 HASH_SEQ_STATUS seq;
2075 {
2077 {
2080 /* truncate_check_rel() has checked that already */
2084 behavior,
2085 restart_seqs);
2086 }
2087 }
2089 {
2091 }
2093 }
2095 /*
2096 * Restart owned sequences if we were asked to.
2097 */
2099 {
2103 }
2105 /*
2106 * Write a WAL record to allow this set of actions to be logically
2107 * decoded.
2108 *
2109 * Assemble an array of relids so we can write a single WAL record for the
2110 * whole action.
2111 */
2113 {
2114 xl_heap_truncate xlrec;
2117 /* should only get here if wal_level >= logical */
2139 }
2141 /*
2142 * Process all AFTER STATEMENT TRUNCATE triggers.
2143 */
2146 {
2147 UserContext ucxt;
2155 resultRelInfo++;
2156 }
2158 /* Handle queued AFTER triggers */
2161 /* We can clean up the EState now */
2164 /*
2165 * Close any rels opened by CASCADE (can't do this while EState still
2166 * holds refs)
2167 */
2170 {
2174 }
2175 }
2177 /*
2178 * Check that a given relation is safe to truncate. Subroutine for
2179 * ExecuteTruncate() and RangeVarCallbackForTruncate().
2180 */
2181 static void
2183 {
2186 /*
2187 * Only allow truncate on regular tables, foreign tables using foreign
2188 * data wrappers supporting TRUNCATE and partitioned tables (although, the
2189 * latter are only being included here for the following checks; no
2190 * physical truncation will occur in their case.).
2191 */
2193 {
2201 relname)));
2202 }
2209 /*
2210 * Most system catalogs can't be truncated at all, or at least not unless
2211 * allow_system_table_mods=on. As an exception, however, we allow
2212 * pg_largeobject to be truncated as part of pg_upgrade, because we need
2213 * to change its relfilenode to match the old cluster, and allowing a
2214 * TRUNCATE command to be executed is the easiest way of doing that.
2215 */
2221 relname)));
2224 }
2226 /*
2227 * Check that current user has the permission to truncate given relation.
2228 */
2229 static void
2231 {
2233 AclResult aclresult;
2235 /* Permissions checks */
2239 relname);
2240 }
2242 /*
2243 * Set of extra sanity checks to check if a given relation is safe to
2244 * truncate. This is split with truncate_check_rel() as
2245 * RangeVarCallbackForTruncate() cannot open a Relation yet.
2246 */
2247 static void
2249 {
2250 /*
2251 * Don't allow truncate on temp tables of other backends ... their local
2252 * buffer manager is not going to cope.
2253 */
2259 /*
2260 * Also check for active uses of the relation in the current transaction,
2261 * including open scans and pending AFTER trigger events.
2262 */
2264 }
2266 /*
2267 * storage_name
2268 * returns the name corresponding to a typstorage/attstorage enum value
2269 */
2272 {
2274 {
2285 }
2286 }
2288 /*----------
2289 * MergeAttributes
2290 * Returns new schema given initial schema and superclasses.
2291 *
2292 * Input arguments:
2293 * 'schema' is the column/attribute definition for the table. (It's a list
2294 * of ColumnDef's.) It is destructively changed.
2295 * 'supers' is a list of OIDs of parent relations, already locked by caller.
2296 * 'relpersistence' is the persistence type of the table.
2297 * 'is_partition' tells if the table is a partition.
2298 *
2299 * Output arguments:
2300 * 'supconstr' receives a list of constraints belonging to the parents,
2301 * updated as necessary to be valid for the child.
2302 *
2303 * Return value:
2304 * Completed schema list.
2305 *
2306 * Notes:
2307 * The order in which the attributes are inherited is very important.
2308 * Intuitively, the inherited attributes should come first. If a table
2309 * inherits from multiple parents, the order of those attributes are
2310 * according to the order of the parents specified in CREATE TABLE.
2311 *
2312 * Here's an example:
2313 *
2314 * create table person (name text, age int4, location point);
2315 * create table emp (salary int4, manager text) inherits(person);
2316 * create table student (gpa float8) inherits (person);
2317 * create table stud_emp (percent int4) inherits (emp, student);
2318 *
2319 * The order of the attributes of stud_emp is:
2320 *
2321 * person {1:name, 2:age, 3:location}
2322 * / \
2323 * {6:gpa} student emp {4:salary, 5:manager}
2324 * \ /
2325 * stud_emp {7:percent}
2326 *
2327 * If the same attribute name appears multiple times, then it appears
2328 * in the result table in the proper location for its first appearance.
2329 *
2330 * Constraints (including NOT NULL constraints) for the child table
2331 * are the union of all relevant constraints, from both the child schema
2332 * and parent tables.
2333 *
2334 * The default value for a child column is defined as:
2335 * (1) If the child schema specifies a default, that value is used.
2336 * (2) If neither the child nor any parent specifies a default, then
2337 * the column will not have a default.
2338 * (3) If conflicting defaults are inherited from different parents
2339 * (and not overridden by the child), an error is raised.
2340 * (4) Otherwise the inherited default is used.
2341 *
2342 * Note that the default-value infrastructure is used for generated
2343 * columns' expressions too, so most of the preceding paragraph applies
2344 * to generation expressions too. We insist that a child column be
2345 * generated if and only if its parent(s) are, but it need not have
2346 * the same generation expression.
2347 *----------
2348 */
2352 {
2361 /*
2362 * Check for and reject tables with too many columns. We perform this
2363 * check relatively early for two reasons: (a) we don't run the risk of
2364 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
2365 * okay if we're processing <= 1600 columns, but could take minutes to
2366 * execute if the user attempts to create a table with hundreds of
2367 * thousands of columns.
2368 *
2369 * Note that we also need to check that we do not exceed this figure after
2370 * including columns from inherited relations.
2371 */
2376 MaxHeapAttributeNumber)));
2378 /*
2379 * Check for duplicate names in the explicit list of attributes.
2380 *
2381 * Although we might consider merging such entries in the same way that we
2382 * handle name conflicts for inherited attributes, it seems to make more
2383 * sense to assume such conflicts are errors.
2384 *
2385 * We don't use foreach() here because we have two nested loops over the
2386 * schema list, with possible element deletions in the inner one. If we
2387 * used foreach_delete_current() it could only fix up the state of one of
2388 * the loops, so it seems cleaner to use looping over list indexes for
2389 * both loops. Note that any deletion will happen beyond where the outer
2390 * loop is, so its index never needs adjustment.
2391 */
2393 {
2397 {
2398 /*
2399 * Typed table column option that does not belong to a column from
2400 * the type. This works because the columns from the type come
2401 * first in the list. (We omit this check for partition column
2402 * lists; those are processed separately below.)
2403 */
2408 }
2410 /* restpos scans all entries beyond coldef; incr is in loop body */
2412 {
2416 {
2418 {
2419 /*
2420 * merge the column options into the column from the type
2421 */
2428 }
2429 else
2434 }
2435 else
2436 restpos++;
2437 }
2438 }
2440 /*
2441 * In case of a partition, there are no new column definitions, only dummy
2442 * ColumnDefs created for column constraints. Set them aside for now and
2443 * process them at the end.
2444 */
2446 {
2449 }
2451 /*
2452 * Scan the parents left-to-right, and merge their attributes to form a
2453 * list of inherited attributes (inhSchema).
2454 */
2457 {
2459 Relation relation;
2460 TupleDesc tupleDesc;
2465 AttrNumber parent_attno;
2469 /* caller already got lock */
2472 /*
2473 * Check for active uses of the parent partitioned table in the
2474 * current transaction, such as being used in some manner by an
2475 * enclosing command.
2476 */
2480 /*
2481 * We do not allow partitioned tables and partitions to participate in
2482 * regular inheritance.
2483 */
2504 /*
2505 * If the parent is permanent, so must be all of its partitions. Note
2506 * that inheritance allows that case.
2507 */
2516 /* Permanent rels cannot inherit from temporary ones */
2526 /* If existing rel is temp, it must belong to this session */
2535 /*
2536 * We should have an UNDER permission flag for this, but for now,
2537 * demand that creator of a child table own the parent.
2538 */
2546 /*
2547 * newattmap->attnums[] will contain the child-table attribute numbers
2548 * for the attributes of this parent table. (They are not the same
2549 * for parents after the first one, nor if we have dropped columns.)
2550 */
2553 /* We can't process inherited defaults until newattmap is complete. */
2557 parent_attno++)
2558 {
2565 /*
2566 * Ignore dropped columns in the parent.
2567 */
2571 /*
2572 * Does it conflict with some previously inherited column?
2573 */
2576 {
2577 Oid defTypeId;
2578 int32 deftypmod;
2579 Oid defCollId;
2581 /*
2582 * Yes, try to merge the two column definitions.
2583 */
2586 attributeName)));
2589 /*
2590 * Must have the same type and typmod
2591 */
2598 attributeName),
2601 deftypmod),
2605 /*
2606 * Must have the same collation
2607 */
2613 attributeName),
2618 /*
2619 * Copy/check storage parameter
2620 */
2627 attributeName),
2632 /*
2633 * Copy/check compression parameter
2634 */
2636 {
2646 attributeName),
2648 }
2650 /*
2651 * Merge of NOT NULL constraints = OR 'em together
2652 */
2655 /*
2656 * Check for GENERATED conflicts
2657 */
2662 attributeName)));
2664 /*
2665 * Default and other constraints are handled below
2666 */
2675 }
2676 else
2677 {
2678 /*
2679 * No, create a new inherited column
2680 */
2700 else
2704 }
2706 /*
2707 * Locate default/generation expression if any
2708 */
2710 {
2713 /* Find default in constraint structure */
2715 {
2719 {
2721 {
2724 }
2725 }
2726 }
2731 /*
2732 * If it's a GENERATED default, it might contain Vars that
2733 * need to be mapped to the inherited column(s)' new numbers.
2734 * We can't do that till newattmap is ready, so just remember
2735 * all the inherited default expressions for the moment.
2736 */
2739 }
2740 }
2742 /*
2743 * Now process any inherited default expressions, adjusting attnos
2744 * using the completed newattmap map.
2745 */
2747 {
2752 /* Adjust Vars to match new table's column numbering */
2755 newattmap,
2758 /*
2759 * For the moment we have to reject whole-row variables. We could
2760 * convert them, if we knew the new table's rowtype OID, but that
2761 * hasn't been assigned yet. (A variable could only appear in a
2762 * generation expression, so the error message is correct.)
2763 */
2768 errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
2772 /*
2773 * If we already had a default from some prior parent, check to
2774 * see if they are the same. If so, no problem; if not, mark the
2775 * column as having a bogus default. Below, we will complain if
2776 * the bogus default isn't overridden by the child schema.
2777 */
2782 {
2785 }
2786 }
2788 /*
2789 * Now copy the CHECK constraints of this parent, adjusting attnos
2790 * using the completed newattmap map. Identically named constraints
2791 * are merged if possible, else we throw error.
2792 */
2794 {
2799 {
2804 /* ignore if the constraint is non-inheritable */
2808 /* Adjust Vars to match new table's column numbering */
2811 newattmap,
2814 /*
2815 * For the moment we have to reject whole-row variables. We
2816 * could convert them, if we knew the new table's rowtype OID,
2817 * but that hasn't been assigned yet.
2818 */
2824 name,
2827 /* check for duplicate */
2829 {
2830 /* nope, this is a new one */
2844 }
2845 }
2846 }
2850 /*
2851 * Close the parent rel, but keep our lock on it until xact commit.
2852 * That will prevent someone else from deleting or ALTERing the parent
2853 * before the child is committed.
2854 */
2856 }
2858 /*
2859 * If we had no inherited attributes, the result schema is just the
2860 * explicitly declared columns. Otherwise, we need to merge the declared
2861 * columns into the inherited schema list. Although, we never have any
2862 * explicitly declared columns if the table is a partition.
2863 */
2865 {
2869 {
2874 schema_attno++;
2876 /*
2877 * Does it conflict with some previously inherited column?
2878 */
2881 {
2883 Oid defTypeId,
2884 newTypeId;
2885 int32 deftypmod,
2886 newtypmod;
2887 Oid defcollid,
2888 newcollid;
2890 /*
2891 * Partitions have only one parent and have no column
2892 * definitions of their own, so conflict should never occur.
2893 */
2896 /*
2897 * Yes, try to merge the two column definitions.
2898 */
2902 attributeName)));
2903 else
2909 /*
2910 * Must have the same type and typmod
2911 */
2918 attributeName),
2921 deftypmod),
2923 newtypmod))));
2925 /*
2926 * Must have the same collation
2927 */
2934 attributeName),
2939 /*
2940 * Identity is never inherited. The new column can have an
2941 * identity definition, so we always just take that one.
2942 */
2945 /*
2946 * Copy storage parameter
2947 */
2954 attributeName),
2959 /*
2960 * Copy compression parameter
2961 */
2965 {
2970 attributeName),
2972 }
2974 /*
2975 * Merge of NOT NULL constraints = OR 'em together
2976 */
2979 /*
2980 * Check for conflicts related to generated columns.
2981 *
2982 * If the parent column is generated, the child column will be
2983 * made a generated column if it isn't already. If it is a
2984 * generated column, we'll take its generation expression in
2985 * preference to the parent's. We must check that the child
2986 * column doesn't specify a default value or identity, which
2987 * matches the rules for a single column in parse_utilcmd.c.
2988 *
2989 * Conversely, if the parent column is not generated, the
2990 * child column can't be either. (We used to allow that, but
2991 * it results in being able to override the generation
2992 * expression via UPDATEs through the parent.)
2993 */
2995 {
3006 }
3007 else
3008 {
3015 }
3017 /*
3018 * If new def has a default, override previous default
3019 */
3021 {
3024 }
3026 /* Mark the column as locally defined */
3028 }
3029 else
3030 {
3031 /*
3032 * No, attach new column to result schema
3033 */
3035 }
3036 }
3040 /*
3041 * Check that we haven't exceeded the legal # of columns after merging
3042 * in inherited columns.
3043 */
3048 MaxHeapAttributeNumber)));
3049 }
3051 /*
3052 * Now that we have the column definition list for a partition, we can
3053 * check whether the columns referenced in the column constraint specs
3054 * actually exist. Also, we merge parent's NOT NULL constraints and
3055 * defaults into each corresponding column definition.
3056 */
3058 {
3060 {
3066 {
3070 {
3074 /*
3075 * Check for conflicts related to generated columns.
3076 *
3077 * Same rules as above: generated-ness has to match the
3078 * parent, but the contents of the generation expression
3079 * can be different.
3080 */
3082 {
3093 }
3094 else
3095 {
3102 }
3104 /*
3105 * Override the parent's default value for this column
3106 * (coldef->cooked_default) with the partition's local
3107 * definition (restdef->raw_default), if there's one. It
3108 * should be physically impossible to get a cooked default
3109 * in the local definition or a raw default in the
3110 * inherited definition, but make sure they're nulls, for
3111 * future-proofing.
3112 */
3116 {
3119 }
3120 }
3121 }
3123 /* complain for constraints on columns not in parent */
3129 }
3130 }
3132 /*
3133 * If we found any conflicting parent default values, check to make sure
3134 * they were overridden by the child.
3135 */
3137 {
3139 {
3143 {
3150 else
3156 }
3157 }
3158 }
3162 }
3165 /*
3166 * MergeCheckConstraint
3167 * Try to merge an inherited CHECK constraint with previous ones
3168 *
3169 * If we inherit identically-named constraints from multiple parents, we must
3170 * merge them, or throw an error if they don't have identical definitions.
3171 *
3172 * constraints is a list of CookedConstraint structs for previous constraints.
3173 *
3174 * Returns true if merged (constraint is a duplicate), or false if it's
3175 * got a so-far-unique name, or throws error if conflict.
3176 */
3177 static bool
3179 {
3183 {
3188 /* Non-matching names never conflict */
3193 {
3194 /* OK to merge */
3201 }
3206 name)));
3207 }
3210 }
3213 /*
3214 * StoreCatalogInheritance
3215 * Updates the system catalogs with proper inheritance information.
3216 *
3217 * supers is a list of the OIDs of the new relation's direct ancestors.
3218 */
3219 static void
3222 {
3223 Relation relation;
3224 int32 seqNumber;
3227 /*
3228 * sanity checks
3229 */
3235 /*
3236 * Store INHERITS information in pg_inherits using direct ancestors only.
3237 * Also enter dependencies on the direct ancestors, and make sure they are
3238 * marked with relhassubclass = true.
3239 *
3240 * (Once upon a time, both direct and indirect ancestors were found here
3241 * and then entered into pg_ipl. Since that catalog doesn't exist
3242 * anymore, there's no need to look for indirect ancestors.)
3243 */
3248 {
3252 child_is_partition);
3253 seqNumber++;
3254 }
3257 }
3259 /*
3260 * Make catalog entries showing relationId as being an inheritance child
3261 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
3262 */
3263 static void
3267 {
3268 ObjectAddress childobject,
3269 parentobject;
3271 /* store the pg_inherits row */
3274 /*
3275 * Store a dependency too
3276 */
3287 /*
3288 * Post creation hook of this inheritance. Since object_access_hook
3289 * doesn't take multiple object identifiers, we relay oid of parent
3290 * relation using auxiliary_id argument.
3291 */
3296 /*
3297 * Mark the parent as having subclasses.
3298 */
3300 }
3302 /*
3303 * Look for an existing schema entry with the given name.
3304 *
3305 * Returns the index (starting with 1) if attribute already exists in schema,
3306 * 0 if it doesn't.
3307 */
3308 static int
3310 {
3315 {
3321 i++;
3322 }
3324 }
3327 /*
3328 * SetRelationHasSubclass
3329 * Set the value of the relation's relhassubclass field in pg_class.
3330 *
3331 * NOTE: caller must be holding an appropriate lock on the relation.
3332 * ShareUpdateExclusiveLock is sufficient.
3333 *
3334 * NOTE: an important side-effect of this operation is that an SI invalidation
3335 * message is sent out to all backends --- including me --- causing plans
3336 * referencing the relation to be rebuilt with the new list of children.
3337 * This must happen even if we find that no change is needed in the pg_class
3338 * row.
3339 */
3340 void
3342 {
3343 Relation relationRelation;
3344 HeapTuple tuple;
3345 Form_pg_class classtuple;
3347 /*
3348 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
3349 */
3357 {
3360 }
3361 else
3362 {
3363 /* no need to change tuple, but force relcache rebuild anyway */
3365 }
3369 }
3371 /*
3372 * CheckRelationTableSpaceMove
3373 * Check if relation can be moved to new tablespace.
3374 *
3375 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3376 *
3377 * Returns true if the relation can be moved to the new tablespace; raises
3378 * an error if it is not possible to do the move; returns false if the move
3379 * would have no effect.
3380 */
3381 bool
3383 {
3384 Oid oldTableSpaceId;
3386 /*
3387 * No work if no change in tablespace. Note that MyDatabaseTableSpace is
3388 * stored as 0.
3389 */
3395 /*
3396 * We cannot support moving mapped relations into different tablespaces.
3397 * (In particular this eliminates all shared catalogs.)
3398 */
3405 /* Cannot move a non-shared relation into pg_global */
3411 /*
3412 * Do not allow moving temp tables of other backends ... their local
3413 * buffer manager is not going to cope.
3414 */
3421 }
3423 /*
3424 * SetRelationTableSpace
3425 * Set new reltablespace and relfilenumber in pg_class entry.
3426 *
3427 * newTableSpaceId is the new tablespace for the relation, and
3428 * newRelFilenumber its new filenumber. If newRelFilenumber is
3429 * InvalidRelFileNumber, this field is not updated.
3430 *
3431 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3432 *
3433 * The caller of this routine had better check if a relation can be
3434 * moved to this new tablespace by calling CheckRelationTableSpaceMove()
3435 * first, and is responsible for making the change visible with
3436 * CommandCounterIncrement().
3437 */
3438 void
3440 Oid newTableSpaceId,
3441 RelFileNumber newRelFilenumber)
3442 {
3443 Relation pg_class;
3444 HeapTuple tuple;
3445 Form_pg_class rd_rel;
3450 /* Get a modifiable copy of the relation's pg_class row. */
3458 /* Update the pg_class row. */
3465 /*
3466 * Record dependency on tablespace. This is only required for relations
3467 * that have no physical storage.
3468 */
3475 }
3477 /*
3478 * renameatt_check - basic sanity checks before attribute rename
3479 */
3480 static void
3482 {
3490 /*
3491 * Renaming the columns of sequences or toast tables doesn't actually
3492 * break anything from the system's point of view, since internal
3493 * references are by attnum. But it doesn't seem right to allow users to
3494 * change names that are hardcoded into the system, hence the following
3495 * restriction.
3496 */
3511 /*
3512 * permissions checking. only the owner of a class can change its schema.
3513 */
3522 }
3524 /*
3525 * renameatt_internal - workhorse for renameatt
3526 *
3527 * Return value is the attribute number in the 'myrelid' relation.
3528 */
3529 static AttrNumber
3536 DropBehavior behavior)
3537 {
3538 Relation targetrelation;
3539 Relation attrelation;
3540 HeapTuple atttup;
3541 Form_pg_attribute attform;
3542 AttrNumber attnum;
3544 /*
3545 * Grab an exclusive lock on the target table, which we will NOT release
3546 * until end of transaction.
3547 */
3551 /*
3552 * if the 'recurse' flag is set then we are supposed to rename this
3553 * attribute in all classes that inherit from 'relname' (as well as in
3554 * 'relname').
3555 *
3556 * any permissions or problems with duplicate attributes will cause the
3557 * whole transaction to abort, which is what we want -- all or nothing.
3558 */
3560 {
3566 /*
3567 * we need the number of parents for each child so that the recursive
3568 * calls to renameatt() can determine whether there are any parents
3569 * outside the inheritance hierarchy being processed.
3570 */
3574 /*
3575 * find_all_inheritors does the recursive search of the inheritance
3576 * hierarchy, so all we have to do is process all of the relids in the
3577 * list that it returns.
3578 */
3580 {
3586 /* note we need not recurse again */
3588 }
3589 }
3590 else
3591 {
3592 /*
3593 * If we are told not to recurse, there had better not be any child
3594 * tables; else the rename would put them out of step.
3595 *
3596 * expected_parents will only be 0 if we are not already recursing.
3597 */
3603 oldattname)));
3604 }
3606 /* rename attributes in typed tables of composite type */
3608 {
3614 behavior);
3618 }
3627 oldattname)));
3635 oldattname)));
3637 /*
3638 * if the attribute is inherited, forbid the renaming. if this is a
3639 * top-level call to renameatt(), then expected_parents will be 0, so the
3640 * effect of this code will be to prohibit the renaming if the attribute
3641 * is inherited at all. if this is a recursive call to renameatt(),
3642 * expected_parents will be the number of parents the current relation has
3643 * within the inheritance hierarchy being processed, so we'll prohibit the
3644 * renaming only if there are additional parents from elsewhere.
3645 */
3650 oldattname)));
3652 /* new name should not already exist */
3655 /* apply the update */
3669 }
3671 /*
3672 * Perform permissions and integrity checks before acquiring a relation lock.
3673 */
3674 static void
3677 {
3678 HeapTuple tuple;
3679 Form_pg_class form;
3687 }
3689 /*
3690 * renameatt - changes the name of an attribute in a relation
3691 *
3692 * The returned ObjectAddress is that of the renamed column.
3693 */
3694 ObjectAddress
3696 {
3697 Oid relid;
3698 AttrNumber attnum;
3699 ObjectAddress address;
3701 /* lock level taken here should match renameatt_internal */
3704 RangeVarCallbackForRenameAttribute,
3705 NULL);
3708 {
3713 }
3715 attnum =
3727 }
3729 /*
3730 * same logic as renameatt_internal
3731 */
3732 static ObjectAddress
3734 Oid mytypid,
3740 {
3742 Oid constraintOid;
3743 HeapTuple tuple;
3744 Form_pg_constraint con;
3745 ObjectAddress address;
3750 {
3752 }
3753 else
3754 {
3757 /*
3758 * don't tell it whether we're recursing; we allow changing typed
3759 * tables here
3760 */
3764 }
3769 constraintOid);
3773 {
3775 {
3785 {
3792 rename_constraint_internal(childrelid, InvalidOid, oldconname, newconname, false, true, numparents);
3793 }
3794 }
3795 else
3796 {
3802 oldconname)));
3803 }
3809 oldconname)));
3810 }
3816 /* rename the index; this renames the constraint as well */
3818 else
3826 {
3827 /*
3828 * Invalidate relcache so as others can see the new constraint name.
3829 */
3833 }
3836 }
3838 ObjectAddress
3840 {
3845 {
3846 Relation rel;
3847 HeapTuple tup;
3857 }
3858 else
3859 {
3860 /* lock level taken here should match rename_constraint_internal */
3863 RangeVarCallbackForRenameAttribute,
3864 NULL);
3866 {
3871 }
3872 }
3874 return
3882 }
3884 /*
3885 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW/MATERIALIZED VIEW/FOREIGN TABLE
3886 * RENAME
3887 */
3888 ObjectAddress
3890 {
3892 Oid relid;
3893 ObjectAddress address;
3895 /*
3896 * Grab an exclusive lock on the target table, index, sequence, view,
3897 * materialized view, or foreign table, which we will NOT release until
3898 * end of transaction.
3899 *
3900 * Lock level used here should match RenameRelationInternal, to avoid lock
3901 * escalation. However, because ALTER INDEX can be used with any relation
3902 * type, we mustn't believe without verification.
3903 */
3905 {
3906 LOCKMODE lockmode;
3914 RangeVarCallbackForAlterRelation,
3918 {
3923 }
3925 /*
3926 * We allow mismatched statement and object types (e.g., ALTER INDEX
3927 * to rename a table), but we might've used the wrong lock level. If
3928 * that happens, retry with the correct lock level. We don't bother
3929 * if we already acquired AccessExclusiveLock with an index, however.
3930 */
3939 }
3941 /* Do the work */
3947 }
3949 /*
3950 * RenameRelationInternal - change the name of a relation
3951 */
3952 void
3954 {
3955 Relation targetrelation;
3957 HeapTuple reltup;
3958 Form_pg_class relform;
3959 Oid namespaceId;
3961 /*
3962 * Grab a lock on the target relation, which we will NOT release until end
3963 * of transaction. We need at least a self-exclusive lock so that
3964 * concurrent DDL doesn't overwrite the rename if they start updating
3965 * while still seeing the old version. The lock also guards against
3966 * triggering relcache reloads in concurrent sessions, which might not
3967 * handle this information changing under them. For indexes, we can use a
3968 * reduced lock level because RelationReloadIndexInfo() handles indexes
3969 * specially.
3970 */
3971 targetrelation = relation_open(myrelid, is_index ? ShareUpdateExclusiveLock : AccessExclusiveLock);
3974 /*
3975 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
3976 */
3988 newrelname)));
3990 /*
3991 * RenameRelation is careful not to believe the caller's idea of the
3992 * relation kind being handled. We don't have to worry about this, but
3993 * let's not be totally oblivious to it. We can process an index as
3994 * not-an-index, but not the other way around.
3995 */
4000 /*
4001 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
4002 * because it's a copy...)
4003 */
4014 /*
4015 * Also rename the associated type, if any.
4016 */
4021 /*
4022 * Also rename the associated constraint, if any.
4023 */
4026 {
4031 }
4033 /*
4034 * Close rel, but keep lock!
4035 */
4037 }
4039 /*
4040 * ResetRelRewrite - reset relrewrite
4041 */
4042 void
4044 {
4046 HeapTuple reltup;
4047 Form_pg_class relform;
4049 /*
4050 * Find relation's pg_class tuple.
4051 */
4059 /*
4060 * Update pg_class tuple.
4061 */
4068 }
4070 /*
4071 * Disallow ALTER TABLE (and similar commands) when the current backend has
4072 * any open reference to the target table besides the one just acquired by
4073 * the calling command; this implies there's an open cursor or active plan.
4074 * We need this check because our lock doesn't protect us against stomping
4075 * on our own foot, only other people's feet!
4076 *
4077 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
4078 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
4079 * possibly be relaxed to only error out for certain types of alterations.
4080 * But the use-case for allowing any of these things is not obvious, so we
4081 * won't work hard at it for now.
4082 *
4083 * We also reject these commands if there are any pending AFTER trigger events
4084 * for the rel. This is certainly necessary for the rewriting variants of
4085 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
4086 * events would try to fetch the wrong tuples. It might be overly cautious
4087 * in other cases, but again it seems better to err on the side of paranoia.
4088 *
4089 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
4090 * we are worried about active indexscans on the index. The trigger-event
4091 * check can be skipped, since we are doing no damage to the parent table.
4092 *
4093 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
4094 */
4095 void
4097 {
4104 /* translator: first %s is a SQL command, eg ALTER TABLE */
4113 /* translator: first %s is a SQL command, eg ALTER TABLE */
4116 }
4118 /*
4119 * AlterTableLookupRelation
4120 * Look up, and lock, the OID for the relation named by an alter table
4121 * statement.
4122 */
4123 Oid
4125 {
4128 RangeVarCallbackForAlterRelation,
4130 }
4132 /*
4133 * AlterTable
4134 * Execute ALTER TABLE, which can be a list of subcommands
4135 *
4136 * ALTER TABLE is performed in three phases:
4137 * 1. Examine subcommands and perform pre-transformation checking.
4138 * 2. Validate and transform subcommands, and update system catalogs.
4139 * 3. Scan table(s) to check new constraints, and optionally recopy
4140 * the data into new table(s).
4141 * Phase 3 is not performed unless one or more of the subcommands requires
4142 * it. The intention of this design is to allow multiple independent
4143 * updates of the table schema to be performed with only one pass over the
4144 * data.
4145 *
4146 * ATPrepCmd performs phase 1. A "work queue" entry is created for
4147 * each table to be affected (there may be multiple affected tables if the
4148 * commands traverse a table inheritance hierarchy). Also we do preliminary
4149 * validation of the subcommands. Because earlier subcommands may change
4150 * the catalog state seen by later commands, there are limits to what can
4151 * be done in this phase. Generally, this phase acquires table locks,
4152 * checks permissions and relkind, and recurses to find child tables.
4153 *
4154 * ATRewriteCatalogs performs phase 2 for each affected table.
4155 * Certain subcommands need to be performed before others to avoid
4156 * unnecessary conflicts; for example, DROP COLUMN should come before
4157 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
4158 * lists, one for each logical "pass" of phase 2.
4159 *
4160 * ATRewriteTables performs phase 3 for those tables that need it.
4161 *
4162 * For most subcommand types, phases 2 and 3 do no explicit recursion,
4163 * since phase 1 already does it. However, for certain subcommand types
4164 * it is only possible to determine how to recurse at phase 2 time; for
4165 * those cases, phase 1 sets the cmd->recurse flag.
4166 *
4167 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
4168 * the whole operation; we don't have to do anything special to clean up.
4169 *
4170 * The caller must lock the relation, with an appropriate lock level
4171 * for the subcommands requested, using AlterTableGetLockLevel(stmt->cmds)
4172 * or higher. We pass the lock level down
4173 * so that we can apply it recursively to inherited tables. Note that the
4174 * lock level we want as we recurse might well be higher than required for
4175 * that specific subcommand. So we pass down the overall lock requirement,
4176 * rather than reassess it at lower levels.
4177 *
4178 * The caller also provides a "context" which is to be passed back to
4179 * utility.c when we need to execute a subcommand such as CREATE INDEX.
4180 * Some of the fields therein, such as the relid, are used here as well.
4181 */
4182 void
4185 {
4186 Relation rel;
4188 /* Caller is required to provide an adequate lock. */
4194 }
4196 /*
4197 * AlterTableInternal
4198 *
4199 * ALTER TABLE with target specified by OID
4200 *
4201 * We do not reject if the relation is already open, because it's quite
4202 * likely that one or more layers of caller have it open. That means it
4203 * is unsafe to use this entry point for alterations that could break
4204 * existing query plans. On the assumption it's not used for such, we
4205 * don't have to reject pending AFTER triggers, either.
4206 *
4207 * Also, since we don't have an AlterTableUtilityContext, this cannot be
4208 * used for any subcommand types that require parse transformation or
4209 * could generate subcommands that have to be passed to ProcessUtility.
4210 */
4211 void
4213 {
4214 Relation rel;
4222 }
4224 /*
4225 * AlterTableGetLockLevel
4226 *
4227 * Sets the overall lock level required for the supplied list of subcommands.
4228 * Policy for doing this set according to needs of AlterTable(), see
4229 * comments there for overall explanation.
4230 *
4231 * Function is called before and after parsing, so it must give same
4232 * answer each time it is called. Some subcommands are transformed
4233 * into other subcommand types, so the transform must never be made to a
4234 * lower lock level than previously assigned. All transforms are noted below.
4235 *
4236 * Since this is called before we lock the table we cannot use table metadata
4237 * to influence the type of lock we acquire.
4238 *
4239 * There should be no lockmodes hardcoded into the subcommand functions. All
4240 * lockmode decisions for ALTER TABLE are made here only. The one exception is
4241 * ALTER TABLE RENAME which is treated as a different statement type T_RenameStmt
4242 * and does not travel through this section of code and cannot be combined with
4243 * any of the subcommands given here.
4244 *
4245 * Note that Hot Standby only knows about AccessExclusiveLocks on the primary
4246 * so any changes that might affect SELECTs running on standbys need to use
4247 * AccessExclusiveLocks even if you think a lesser lock would do, unless you
4248 * have a solution for that also.
4249 *
4250 * Also note that pg_dump uses only an AccessShareLock, meaning that anything
4251 * that takes a lock less than AccessExclusiveLock can change object definitions
4252 * while pg_dump is running. Be careful to check that the appropriate data is
4253 * derived by pg_dump using an MVCC snapshot, rather than syscache lookups,
4254 * otherwise we might end up with an inconsistent dump that can't restore.
4255 */
4256 LOCKMODE
4258 {
4259 /*
4260 * This only works if we read catalog tables using MVCC snapshots.
4261 */
4266 {
4271 {
4272 /*
4273 * These subcommands rewrite the heap, so require full locks.
4274 */
4276 * to SELECT */
4283 /*
4284 * These subcommands may require addition of toast tables. If
4285 * we add a toast table to a table currently being scanned, we
4286 * might miss data added to the new toast table by concurrent
4287 * insert transactions.
4288 */
4290 * ATRewriteCatalogs() */
4294 /*
4295 * Removing constraints can affect SELECTs that have been
4296 * optimized assuming the constraint holds true. See also
4297 * CloneFkReferenced.
4298 */
4304 /*
4305 * Subcommands that may be visible to concurrent SELECTs
4306 */
4317 /*
4318 * Changing owner may remove implicit SELECT privileges
4319 */
4324 /*
4325 * Changing foreign table options may affect optimization.
4326 */
4332 /*
4333 * These subcommands affect write operations only.
4334 */
4346 /*
4347 * These subcommands affect write operations only. XXX
4348 * Theoretically, these could be ShareRowExclusiveLock.
4349 */
4373 {
4377 {
4382 /*
4383 * Cases essentially the same as CREATE INDEX. We
4384 * could reduce the lock strength to ShareLock if
4385 * we can work out how to allow concurrent catalog
4386 * updates. XXX Might be set down to
4387 * ShareRowExclusiveLock but requires further
4388 * analysis.
4389 */
4394 /*
4395 * We add triggers to both tables when we add a
4396 * Foreign Key, so the lock level must be at least
4397 * as strong as CREATE TRIGGER.
4398 */
4404 }
4405 }
4408 /*
4409 * These subcommands affect inheritance behaviour. Queries
4410 * started before us will continue to see the old inheritance
4411 * behaviour, while queries started after we commit will see
4412 * new behaviour. No need to prevent reads or writes to the
4413 * subtable while we hook it up though. Changing the TupDesc
4414 * may be a problem, so keep highest lock.
4415 */
4421 /*
4422 * These subcommands affect implicit row type conversion. They
4423 * have affects similar to CREATE/DROP CAST on queries. don't
4424 * provide for invalidating parse trees as a result of such
4425 * changes, so we keep these at AccessExclusiveLock.
4426 */
4432 /*
4433 * Only used by CREATE OR REPLACE VIEW which must conflict
4434 * with an SELECTs currently using the view.
4435 */
4440 /*
4441 * These subcommands affect general strategies for performance
4442 * and maintenance, though don't change the semantic results
4443 * from normal data reads and writes. Delaying an ALTER TABLE
4444 * behind currently active writes only delays the point where
4445 * the new strategy begins to take effect, so there is no
4446 * benefit in waiting. In this case the minimum restriction
4447 * applies: we don't currently allow concurrent catalog
4448 * updates.
4449 */
4467 /*
4468 * Rel options are more complex than first appears. Options
4469 * are set here for tables, views and indexes; for historical
4470 * reasons these can all be used with ALTER TABLE, so we can't
4471 * decide between them using the basic grammar.
4472 */
4474 * getTables() */
4476 * getTables() */
4487 else
4497 /*
4498 * This only examines the table's schema; but lock must be
4499 * strong enough to prevent concurrent DROP NOT NULL.
4500 */
4508 }
4510 /*
4511 * Take the greatest lockmode from any subcommand
4512 */
4515 }
4518 }
4520 /*
4521 * ATController provides top level control over the phases.
4522 *
4523 * parsetree is passed in to allow it to be passed to event triggers
4524 * when requested.
4525 */
4526 static void
4530 {
4534 /* Phase 1: preliminary examination of commands, create work queue */
4536 {
4540 }
4542 /* Close the relation, but keep lock until commit */
4545 /* Phase 2: update system catalogs */
4548 /* Phase 3: scan/rewrite tables as needed, and run afterStmts */
4550 }
4552 /*
4553 * ATPrepCmd
4554 *
4555 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
4556 * recursion and permission checks.
4557 *
4558 * Caller must have acquired appropriate lock type on relation already.
4559 * This lock should be held until commit.
4560 */
4561 static void
4565 {
4569 /* Find or create work queue entry for this table */
4572 /*
4573 * Disallow any ALTER TABLE other than ALTER TABLE DETACH FINALIZE on
4574 * partitions that are pending detach.
4575 */
4583 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
4585 /*
4586 * Copy the original subcommand for each table, so we can scribble on it.
4587 * This avoids conflicts when different child tables need to make
4588 * different parse transformations (for example, the same column may have
4589 * different column numbers in different children).
4590 */
4593 /*
4594 * Do permissions and relkind checking, recursion to child tables if
4595 * needed, and any additional phase-1 processing needed. (But beware of
4596 * adding any processing that looks at table details that another
4597 * subcommand could change. In some cases we reject multiple subcommands
4598 * that could try to change the same state in contrary ways.)
4599 */
4601 {
4607 /* Recursion occurs during execution phase */
4614 /* Recursion occurs during execution phase */
4619 /*
4620 * We allow defaults on views so that INSERT into a view can have
4621 * default-ish behavior. This works because the rewriter
4622 * substitutes default values into INSERTs before it expands
4623 * rules.
4624 */
4627 /* No command-specific prep needed */
4631 /* This is currently used only in CREATE TABLE */
4632 /* (so the permission check really isn't necessary) */
4634 /* This command never recurses */
4639 /* This command never recurses */
4644 /* This command never recurses */
4645 /* This should run after AddIdentity, so do it in MISC pass */
4650 /* This command never recurses */
4661 /* Need command-specific recursion decision */
4669 /* No command-specific prep needed */
4679 ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX | ATT_PARTITIONED_INDEX | ATT_FOREIGN_TABLE);
4681 /* No command-specific prep needed */
4687 /* This command never recurses */
4693 /* No command-specific prep needed */
4698 /* This command never recurses */
4699 /* No command-specific prep needed */
4707 /* Recursion occurs during execution phase */
4712 /* This command never recurses */
4713 /* No command-specific prep needed */
4718 /* Recursion occurs during execution phase */
4719 /* No command-specific prep needed except saving recurse flag */
4726 /* This command never recurses */
4727 /* No command-specific prep needed */
4733 /* Other recursion occurs during execution phase */
4734 /* No command-specific prep needed except saving recurse flag */
4742 /* See comments for ATPrepAlterColumnType */
4746 /* Performs own recursion */
4753 /* This command never recurses */
4754 /* No command-specific prep needed */
4758 /* This command never recurses */
4759 /* No command-specific prep needed */
4765 /* These commands never recurse */
4766 /* No command-specific prep needed */
4776 /* force rewrite if necessary; see comment in ATRewriteTables */
4778 {
4781 }
4791 /* force rewrite if necessary; see comment in ATRewriteTables */
4793 {
4796 }
4806 /* partitioned tables don't have an access method */
4812 /* check if another access method change was already requested */
4823 ATT_PARTITIONED_INDEX);
4824 /* This command never recurses */
4832 /* This command never recurses */
4833 /* No command-specific prep needed */
4838 /* This command never recurses */
4844 /* This command never recurses */
4845 /* No command-specific prep needed */
4850 /* Recursion occurs during execution phase */
4855 /* Recursion occurs during execution phase */
4856 /* No command-specific prep needed except saving recurse flag */
4864 /* This command never recurses */
4865 /* No command-specific prep needed */
4876 /* Set up recursion for phase 2; no other prep needed */
4892 /* These commands never recurse */
4893 /* No command-specific prep needed */
4898 /* No command-specific prep needed */
4903 /* No command-specific prep needed */
4908 /* No command-specific prep needed */
4913 /* No command-specific prep needed */
4921 }
4924 /* Add the subcommand to the appropriate list for phase 2 */
4926 }
4928 /*
4929 * ATRewriteCatalogs
4930 *
4931 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
4932 * dispatched in a "safe" execution order (designed to avoid unnecessary
4933 * conflicts).
4934 */
4935 static void
4938 {
4942 /*
4943 * We process all the tables "in parallel", one pass at a time. This is
4944 * needed because we may have to propagate work from one table to another
4945 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
4946 * re-adding of the foreign key constraint to the other table). Work can
4947 * only be propagated into later passes, however.
4948 */
4950 {
4951 /* Go through each table that needs to be processed */
4953 {
4961 /*
4962 * Open the relation and store it in tab. This allows subroutines
4963 * close and reopen, if necessary. Appropriate lock was obtained
4964 * by phase 1, needn't get it again.
4965 */
4973 /*
4974 * After the ALTER TYPE pass, do cleanup work (this is not done in
4975 * ATExecAlterColumnType since it should be done only once if
4976 * multiple columns of a table are altered).
4977 */
4982 {
4985 }
4986 }
4987 }
4989 /* Check to see if a toast table must be added. */
4991 {
4994 /*
4995 * If the table is source table of ATTACH PARTITION command, we did
4996 * not modify anything about it that will change its toasting
4997 * requirement, so no need to check.
4998 */
5004 }
5005 }
5007 /*
5008 * ATExecCmd: dispatch a subcommand to appropriate execution routine
5009 */
5010 static void
5014 {
5019 {
5073 lockmode);
5079 NULL);
5083 lockmode);
5087 lockmode);
5094 /* Transform the command only during initial examination */
5099 /* Depending on constraint type, might be no more work to do now */
5101 address =
5107 address =
5112 * constraint */
5113 address =
5116 NULL);
5123 lockmode);
5138 /* parse transformation was done earlier */
5142 address =
5161 /* nothing to do here, oid columns don't exist anymore */
5164 /* handled specially in Phase 3 */
5168 /*
5169 * Only do this for partitioned tables and indexes, for which this
5170 * is just a catalog change. Other relation types which have
5171 * storage are handled by Phase 3.
5172 */
5187 lockmode);
5193 lockmode);
5199 lockmode);
5205 lockmode);
5211 lockmode);
5217 lockmode);
5223 lockmode);
5229 lockmode);
5285 context);
5286 else
5294 /* ATPrepCmd ensures it must be a table */
5307 }
5309 /*
5310 * Report the subcommand to interested event triggers.
5311 */
5315 /*
5316 * Bump the command counter to ensure the next subcommand in the sequence
5317 * can see the changes so far
5318 */
5320 }
5322 /*
5323 * ATParseTransformCmd: perform parse transformation for one subcommand
5324 *
5325 * Returns the transformed subcommand tree, if there is one, else NULL.
5326 *
5327 * The parser may hand back additional AlterTableCmd(s) and/or other
5328 * utility statements, either before or after the original subcommand.
5329 * Other AlterTableCmds are scheduled into the appropriate slot of the
5330 * AlteredTableInfo (they had better be for later passes than the current one).
5331 * Utility statements that are supposed to happen before the AlterTableCmd
5332 * are executed immediately. Those that are supposed to happen afterwards
5333 * are added to the tab->afterStmts list to be done at the very end.
5334 */
5339 {
5346 /* Gin up an AlterTableStmt with just this subcommand and this table */
5356 /* Transform the AlterTableStmt */
5358 atstmt,
5363 /* Execute any statements that should happen before these subcommand(s) */
5365 {
5370 }
5372 /* Examine the transformed subcommands and schedule them appropriately */
5374 {
5378 /*
5379 * This switch need only cover the subcommand types that can be added
5380 * by parse_utilcmd.c; otherwise, we'll use the default strategy of
5381 * executing the subcommand immediately, as a substitute for the
5382 * original subcommand. (Note, however, that this does cause
5383 * AT_AddConstraint subcommands to be rescheduled into later passes,
5384 * which is important for index and foreign key constraints.)
5385 *
5386 * We assume we needn't do any phase-1 checks for added subcommands.
5387 */
5389 {
5391 /* Need command-specific recursion decision */
5398 /* This command never recurses */
5399 /* No command-specific prep needed */
5403 /* This command never recurses */
5404 /* No command-specific prep needed */
5408 /* Recursion occurs during execution phase */
5412 {
5421 }
5424 /* This command never recurses */
5425 /* No command-specific prep needed */
5431 }
5434 {
5435 /* Cannot schedule into a pass we already finished */
5437 pass);
5438 }
5440 {
5441 /* OK, queue it up for later */
5443 }
5444 else
5445 {
5446 /*
5447 * We should see at most one subcommand for the current pass,
5448 * which is the transformed version of the original subcommand.
5449 */
5451 {
5452 /* Found the transformed version of our subcommand */
5454 }
5455 else
5457 pass);
5458 }
5459 }
5461 /* Queue up any after-statements to happen at the end */
5465 }
5467 /*
5468 * ATRewriteTables: ALTER TABLE phase 3
5469 */
5470 static void
5473 {
5476 /* Go through each table that needs to be checked or rewritten */
5478 {
5481 /* Relations without storage may be ignored here */
5485 /*
5486 * If we change column data types, the operation has to be propagated
5487 * to tables that use this table's rowtype as a column type.
5488 * tab->newvals will also be non-NULL in the case where we're adding a
5489 * column with a default. We choose to forbid that case as well,
5490 * since composite types might eventually support defaults.
5491 *
5492 * (Eventually we'll probably need to check for composite type
5493 * dependencies even when we're just scanning the table without a
5494 * rewrite, but at the moment a composite type does not enforce any
5495 * constraints, so it's not necessary/appropriate to enforce them just
5496 * during ALTER.)
5497 */
5499 {
5500 Relation rel;
5505 }
5507 /*
5508 * We only need to rewrite the table if at least one column needs to
5509 * be recomputed, or we are changing its persistence or access method.
5510 *
5511 * There are two reasons for requiring a rewrite when changing
5512 * persistence: on one hand, we need to ensure that the buffers
5513 * belonging to each of the two relations are marked with or without
5514 * BM_PERMANENT properly. On the other hand, since rewriting creates
5515 * and assigns a new relfilenumber, we automatically create or drop an
5516 * init fork for the relation as appropriate.
5517 */
5519 {
5520 /* Build a temporary relation and copy data */
5521 Relation OldHeap;
5522 Oid OIDNewHeap;
5523 Oid NewAccessMethod;
5524 Oid NewTableSpace;
5529 /*
5530 * We don't support rewriting of system catalogs; there are too
5531 * many corner cases and too little benefit. In particular this
5532 * is certainly not going to work for mapped catalogs.
5533 */
5546 /*
5547 * Don't allow rewrite on temp tables of other backends ... their
5548 * local buffer manager is not going to cope.
5549 */
5555 /*
5556 * Select destination tablespace (same as original unless user
5557 * requested a change)
5558 */
5561 else
5564 /*
5565 * Select destination access method (same as original unless user
5566 * requested a change)
5567 */
5570 else
5573 /*
5574 * Select persistence of transient table (same as original unless
5575 * user requested a change)
5576 */
5582 /*
5583 * Fire off an Event Trigger now, before actually rewriting the
5584 * table.
5585 *
5586 * We don't support Event Trigger for nested commands anywhere,
5587 * here included, and parsetree is given NULL when coming from
5588 * AlterTableInternal.
5589 *
5590 * And fire it only once.
5591 */
5597 /*
5598 * Create transient table that will receive the modified data.
5599 *
5600 * Ensure it is marked correctly as logged or unlogged. We have
5601 * to do this here so that buffers for the new relfilenumber will
5602 * have the right persistence set, and at the same time ensure
5603 * that the original filenumbers's buffers will get read in with
5604 * the correct setting (i.e. the original one). Otherwise a
5605 * rollback after the rewrite would possibly result with buffers
5606 * for the original filenumbers having the wrong persistence
5607 * setting.
5608 *
5609 * NB: This relies on swap_relation_files() also swapping the
5610 * persistence. That wouldn't work for pg_class, but that can't be
5611 * unlogged anyway.
5612 */
5616 /*
5617 * Copy the heap data into the new table with the desired
5618 * modifications, and test the current data within the table
5619 * against new constraints generated by ALTER TABLE commands.
5620 */
5623 /*
5624 * Swap the physical files of the old and new heaps, then rebuild
5625 * indexes and discard the old heap. We can use RecentXmin for
5626 * the table's new relfrozenxid because we rewrote all the tuples
5627 * in ATRewriteTable, so no older Xid remains in the table. Also,
5628 * we never try to swap toast tables by content, since we have no
5629 * interest in letting this code work on system catalogs.
5630 */
5634 RecentXmin,
5636 persistence);
5639 }
5641 {
5644 }
5645 else
5646 {
5647 /*
5648 * If required, test the current data within the table against new
5649 * constraints generated by ALTER TABLE commands, but don't
5650 * rebuild data.
5651 */
5656 /*
5657 * If we had SET TABLESPACE but no reason to reconstruct tuples,
5658 * just do a block-by-block copy.
5659 */
5662 }
5664 /*
5665 * Also change persistence of owned sequences, so that it matches the
5666 * table persistence.
5667 */
5669 {
5674 {
5678 }
5679 }
5680 }
5682 /*
5683 * Foreign key constraints are checked in a final pass, since (a) it's
5684 * generally best to examine each one separately, and (b) it's at least
5685 * theoretically possible that we have changed both relations of the
5686 * foreign key, and we'd better have finished both rewrites before we try
5687 * to read the tables.
5688 */
5690 {
5695 /* Relations without storage may be ignored here too */
5700 {
5704 {
5706 Relation refrel;
5709 {
5710 /* Long since locked, no need for another */
5712 }
5720 /*
5721 * No need to mark the constraint row as validated, we did
5722 * that when we inserted the row earlier.
5723 */
5726 }
5727 }
5731 }
5733 /* Finally, run any afterStmts that were queued up */
5735 {
5740 {
5745 }
5746 }
5747 }
5749 /*
5750 * ATRewriteTable: scan or rewrite one table
5751 *
5752 * OIDNewHeap is InvalidOid if we don't need to rewrite
5753 */
5754 static void
5756 {
5757 Relation oldrel;
5758 Relation newrel;
5759 TupleDesc oldTupDesc;
5760 TupleDesc newTupDesc;
5766 CommandId mycid;
5767 BulkInsertState bistate;
5771 /*
5772 * Open the relation(s). We have surely already locked the existing
5773 * table.
5774 */
5781 else
5784 /*
5785 * Prepare a BulkInsertState and options for table_tuple_insert. The FSM
5786 * is empty, so don't bother using it.
5787 */
5789 {
5793 }
5794 else
5795 {
5796 /* keep compiler quiet about using these uninitialized */
5800 }
5802 /*
5803 * Generate the constraint and default execution states
5804 */
5808 /* Build the needed expression execution states */
5810 {
5814 {
5820 /* Nothing to do here */
5825 }
5826 }
5828 /* Build expression execution states for partition check quals */
5830 {
5833 }
5836 {
5839 /* expr already planned */
5841 }
5845 {
5846 /*
5847 * If we are rebuilding the tuples OR if we added any new but not
5848 * verified NOT NULL constraints, check all not-null constraints. This
5849 * is a bit of overkill but it minimizes risk of bugs, and
5850 * heap_attisnull is a pretty cheap test anyway.
5851 */
5853 {
5858 }
5861 }
5864 {
5868 TableScanDesc scan;
5869 MemoryContext oldCxt;
5872 Snapshot snapshot;
5878 else
5884 {
5885 /*
5886 * All predicate locks on the tuples or pages are about to be made
5887 * invalid, because we move tuples around. Promote them to
5888 * relation locks.
5889 */
5891 }
5895 /*
5896 * Create necessary tuple slots. When rewriting, two slots are needed,
5897 * otherwise one suffices. In the case where one slot suffices, we
5898 * need to use the new tuple descriptor, otherwise some constraints
5899 * can't be evaluated. Note that even when the tuple layout is the
5900 * same and no rewrite is required, the tupDescs might not be
5901 * (consider ADD COLUMN without a default).
5902 */
5904 {
5911 /*
5912 * Set all columns in the new slot to NULL initially, to ensure
5913 * columns added as part of the rewrite are initialized to NULL.
5914 * That is necessary as tab->newvals will not contain an
5915 * expression for columns with a NULL default, e.g. when adding a
5916 * column without a default together with a column with a default
5917 * requiring an actual rewrite.
5918 */
5920 }
5921 else
5922 {
5926 }
5928 /*
5929 * Any attributes that are dropped according to the new tuple
5930 * descriptor can be set to NULL. We precompute the list of dropped
5931 * attributes to avoid needing to do so in the per-tuple loop.
5932 */
5934 {
5937 }
5939 /*
5940 * Scan through the rows, generating a new row if needed and then
5941 * checking all the constraints.
5942 */
5946 /*
5947 * Switch to per-tuple memory context and reset it for each tuple
5948 * produced, so we don't leak memory.
5949 */
5953 {
5957 {
5958 /* Extract data from old tuple */
5962 /* copy attributes */
5968 /* Set dropped attributes to null in new tuple */
5972 /*
5973 * Constraints and GENERATED expressions might reference the
5974 * tableoid column, so fill tts_tableOid with the desired
5975 * value. (We must do this each time, because it gets
5976 * overwritten with newrel's OID during storing.)
5977 */
5980 /*
5981 * Process supplied expressions to replace selected columns.
5982 *
5983 * First, evaluate expressions whose inputs come from the old
5984 * tuple.
5985 */
5989 {
5997 econtext,
5999 }
6003 /*
6004 * Now, evaluate any expressions whose inputs come from the
6005 * new tuple. We assume these columns won't reference each
6006 * other, so that there's no ordering dependency.
6007 */
6011 {
6019 econtext,
6021 }
6024 }
6025 else
6026 {
6027 /*
6028 * If there's no rewrite, old and new table are guaranteed to
6029 * have the same AM, so we can just use the old slot to verify
6030 * new constraints etc.
6031 */
6033 }
6035 /* Now check any constraints on the possibly-changed tuple */
6039 {
6043 {
6052 }
6053 }
6056 {
6060 {
6071 /* Nothing to do here */
6076 }
6077 }
6080 {
6084 errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
6087 else
6093 }
6095 /* Write the tuple out to the new relation */
6103 }
6112 }
6118 {
6124 }
6125 }
6127 /*
6128 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
6129 */
6132 {
6138 {
6142 }
6144 /*
6145 * Not there, so add it. Note that we make a copy of the relation's
6146 * existing descriptor before anything interesting can happen to it.
6147 */
6161 }
6165 {
6167 {
6294 }
6297 }
6299 /*
6300 * ATSimplePermissions
6301 *
6302 * - Ensure that it is a relation (or possibly a view)
6303 * - Ensure this user is the owner
6304 * - Ensure that it is not a system table
6305 */
6306 static void
6308 {
6312 {
6341 }
6343 /* Wrong target type? */
6345 {
6351 /* translator: %s is a group of some SQL keywords */
6355 else
6356 /* internal error? */
6359 }
6361 /* Permissions checks */
6371 }
6373 /*
6374 * ATSimpleRecursion
6375 *
6376 * Simple table recursion sufficient for most ALTER TABLE operations.
6377 * All direct and indirect children are processed in an unspecified order.
6378 * Note that if a child inherits from the original table via multiple
6379 * inheritance paths, it will be visited just once.
6380 */
6381 static void
6385 {
6386 /*
6387 * Propagate to children, if desired and if there are (or might be) any
6388 * children.
6389 */
6391 {
6398 /*
6399 * find_all_inheritors does the recursive search of the inheritance
6400 * hierarchy, so all we have to do is process all of the relids in the
6401 * list that it returns.
6402 */
6404 {
6406 Relation childrel;
6410 /* find_all_inheritors already got lock */
6415 }
6416 }
6417 }
6419 /*
6420 * Obtain list of partitions of the given table, locking them all at the given
6421 * lockmode and ensuring that they all pass CheckTableNotInUse.
6422 *
6423 * This function is a no-op if the given relation is not a partitioned table;
6424 * in particular, nothing is done if it's a legacy inheritance parent.
6425 */
6426 static void
6428 {
6430 {
6435 /* first element is the parent rel; must ignore it */
6437 {
6438 Relation childrel;
6440 /* find_all_inheritors already got lock */
6444 }
6446 }
6447 }
6449 /*
6450 * ATTypedTableRecursion
6451 *
6452 * Propagate ALTER TYPE operations to the typed tables of that type.
6453 * Also check the RESTRICT/CASCADE behavior. Given CASCADE, also permit
6454 * recursion to inheritance children of the typed tables.
6455 */
6456 static void
6459 {
6470 {
6472 Relation childrel;
6478 }
6479 }
6482 /*
6483 * find_composite_type_dependencies
6484 *
6485 * Check to see if the type "typeOid" is being used as a column in some table
6486 * (possibly nested several levels deep in composite types, arrays, etc!).
6487 * Eventually, we'd like to propagate the check or rewrite operation
6488 * into such tables, but for now, just error out if we find any.
6489 *
6490 * Caller should provide either the associated relation of a rowtype,
6491 * or a type name (not both) for use in the error message, if any.
6492 *
6493 * Note that "typeOid" is not necessarily a composite type; it could also be
6494 * another container type such as an array or range, or a domain over one of
6495 * these things. The name of this function is therefore somewhat historical,
6496 * but it's not worth changing.
6497 *
6498 * We assume that functions and views depending on the type are not reasons
6499 * to reject the ALTER. (How safe is this really?)
6500 */
6501 void
6504 {
6505 Relation depRel;
6507 SysScanDesc depScan;
6508 HeapTuple depTup;
6510 /* since this function recurses, it could be driven to stack overflow */
6513 /*
6514 * We scan pg_depend to find those things that depend on the given type.
6515 * (We assume we can ignore refobjsubid for a type.)
6516 */
6520 Anum_pg_depend_refclassid,
6524 Anum_pg_depend_refobjid,
6532 {
6534 Relation rel;
6535 TupleDesc tupleDesc;
6536 Form_pg_attribute att;
6538 /* Check for directly dependent types */
6540 {
6541 /*
6542 * This must be an array, domain, or range containing the given
6543 * type, so recursively check for uses of this type. Note that
6544 * any error message will mention the original type not the
6545 * container; this is intentional.
6546 */
6550 }
6552 /* Else, ignore dependees that aren't relations */
6559 /*
6560 * If objsubid identifies a specific column, refer to that in error
6561 * messages. Otherwise, search to see if there's a user column of the
6562 * type. (We assume system columns are never of interesting types.)
6563 * The search is needed because an index containing an expression
6564 * column of the target type will just be recorded as a whole-relation
6565 * dependency. If we do not find a column of the type, the dependency
6566 * must indicate that the type is transiently referenced in an index
6567 * expression but not stored on disk, which we assume is OK, just as
6568 * we do for references in views. (It could also be that the target
6569 * type is embedded in some container type that is stored in an index
6570 * column, but the previous recursion should catch such cases.)
6571 */
6574 else
6575 {
6578 {
6583 }
6585 {
6586 /* No such column, so assume OK */
6589 }
6590 }
6592 /*
6593 * We definitely should reject if the relation has storage. If it's
6594 * partitioned, then perhaps we don't have to reject: if there are
6595 * partitions then we'll fail when we find one, else there is no
6596 * stored data to worry about. However, it's possible that the type
6597 * change would affect conclusions about whether the type is sortable
6598 * or hashable and thus (if it's a partitioning column) break the
6599 * partitioning rule. For now, reject for partitioned rels too.
6600 */
6603 {
6608 origTypeName,
6625 else
6632 }
6634 {
6635 /*
6636 * A view or composite type itself isn't a problem, but we must
6637 * recursively check for indirect dependencies via its rowtype.
6638 */
6641 }
6644 }
6649 }
6652 /*
6653 * find_typed_table_dependencies
6654 *
6655 * Check to see if a composite type is being used as the type of a
6656 * typed table. Abort if any are found and behavior is RESTRICT.
6657 * Else return the list of tables.
6658 */
6661 {
6662 Relation classRel;
6664 TableScanDesc scan;
6665 HeapTuple tuple;
6671 Anum_pg_class_reloftype,
6678 {
6685 typeName),
6687 else
6689 }
6695 }
6698 /*
6699 * check_of_type
6700 *
6701 * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF. If it
6702 * isn't suitable, throw an error. Currently, we require that the type
6703 * originated with CREATE TYPE AS. We could support any row type, but doing so
6704 * would require handling a number of extra corner cases in the DDL commands.
6705 * (Also, allowing domain-over-composite would open up a can of worms about
6706 * whether and how the domain's constraints should apply to derived tables.)
6707 */
6708 void
6710 {
6715 {
6716 Relation typeRelation;
6722 /*
6723 * Close the parent rel, but keep our AccessShareLock on it until xact
6724 * commit. That will prevent someone else from deleting or ALTERing
6725 * the type before the typed table creation/conversion commits.
6726 */
6728 }
6734 }
6737 /*
6738 * ALTER TABLE ADD COLUMN
6739 *
6740 * Adds an additional attribute to a relation making the assumption that
6741 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
6742 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
6743 * AlterTableCmd's.
6744 *
6745 * ADD COLUMN cannot use the normal ALTER TABLE recursion mechanism, because we
6746 * have to decide at runtime whether to recurse or not depending on whether we
6747 * actually add a column or merely merge with an existing column. (We can't
6748 * check this in a static pre-pass because it won't handle multiple inheritance
6749 * situations correctly.)
6750 */
6751 static void
6755 {
6766 }
6768 /*
6769 * Add a column to a table. The return value is the address of the
6770 * new column in the parent relation.
6771 *
6772 * cmd is pass-by-ref so that we can replace it with the parse-transformed
6773 * copy (but that happens only after we check for IF NOT EXISTS).
6774 */
6775 static ObjectAddress
6781 {
6785 Relation pgclass,
6786 attrdesc;
6787 HeapTuple reltup;
6788 FormData_pg_attribute attribute;
6791 HeapTuple typeTuple;
6792 Oid typeOid;
6793 int32 typmod;
6794 Oid collOid;
6795 Form_pg_type tform;
6800 AclResult aclresult;
6801 ObjectAddress address;
6802 TupleDesc tupdesc;
6805 /* At top level, permission check was done in ATPrepCmd, else do it */
6816 /*
6817 * Are we adding the column to a recursion child? If so, check whether to
6818 * merge with an existing definition for the column. If we do merge, we
6819 * must not recurse. Children will already have the column, and recursing
6820 * into them would mess up attinhcount.
6821 */
6823 {
6824 HeapTuple tuple;
6826 /* Does child already have a column by this name? */
6829 {
6831 Oid ctypeId;
6832 int32 ctypmod;
6833 Oid ccollid;
6835 /* Child column must match on type, typmod, and collation */
6853 /* Bump the existing child att's inhcount */
6863 /* Inform the user about the merge */
6870 }
6871 }
6873 /* skip if the name already exists and if_not_exists is true */
6875 {
6878 }
6880 /*
6881 * Okay, we need to add the column, so go ahead and do parse
6882 * transformation. This can result in queueing up, or even immediately
6883 * executing, subsidiary operations (such as creation of unique indexes);
6884 * so we mustn't do it until we have made the if_not_exists check.
6885 *
6886 * When recursing, the command was already transformed and we needn't do
6887 * so again. Also, if context isn't given we can't transform. (That
6888 * currently happens only for AT_AddColumnToView; we expect that view.c
6889 * passed us a ColumnDef that doesn't need work.)
6890 */
6892 {
6897 }
6899 /*
6900 * Cannot add identity column if table has children, because identity does
6901 * not inherit. (Adding column and identity separately will work.)
6902 */
6904 recurse &&
6917 /* Determine the new attribute's number */
6923 MaxHeapAttributeNumber)));
6935 /* make sure datatype is legal for a column */
6940 /*
6941 * Construct new attribute's pg_attribute entry. (Variable-length fields
6942 * are handled by InsertPgAttributeTuples().)
6943 */
6960 else
6982 /*
6983 * Update pg_class tuple as appropriate
6984 */
6991 /* Post creation hook for new attribute */
6996 /* Make the attribute's catalog entry visible */
6999 /*
7000 * Store the DEFAULT, if any, in the catalogs
7001 */
7003 {
7010 /*
7011 * Attempt to skip a complete table rewrite by storing the specified
7012 * DEFAULT value outside of the heap. This may be disabled inside
7013 * AddRelationNewConstraints if the optimization cannot be applied.
7014 */
7019 /*
7020 * This function is intended for CREATE TABLE, so it processes a
7021 * _list_ of defaults, but we just do one.
7022 */
7026 /* Make the additional catalog changes visible */
7029 /*
7030 * Did the request for a missing value work? If not we'll have to do a
7031 * rewrite
7032 */
7035 }
7037 /*
7038 * Tell Phase 3 to fill in the default expression, if there is one.
7039 *
7040 * If there is no default, Phase 3 doesn't have to do anything, because
7041 * that effectively means that the default is NULL. The heap tuple access
7042 * routines always check for attnum > # of attributes in tuple, and return
7043 * NULL if so, so without any modification of the tuple data we will get
7044 * the effect of NULL values in the new column.
7045 *
7046 * An exception occurs when the new column is of a domain type: the domain
7047 * might have a NOT NULL constraint, or a check constraint that indirectly
7048 * rejects nulls. If there are any domain constraints then we construct
7049 * an explicit NULL default value that will be passed through
7050 * CoerceToDomain processing. (This is a tad inefficient, since it causes
7051 * rewriting the table which we really don't have to do, but the present
7052 * design of domain processing doesn't offer any simple way of checking
7053 * the constraints more directly.)
7054 *
7055 * Note: we use build_column_default, and not just the cooked default
7056 * returned by AddRelationNewConstraints, so that the right thing happens
7057 * when a datatype's default applies.
7058 *
7059 * Note: it might seem that this should happen at the end of Phase 2, so
7060 * that the effects of subsequent subcommands can be taken into account.
7061 * It's intentional that we do it now, though. The new column should be
7062 * filled according to what is said in the ADD COLUMN subcommand, so that
7063 * the effects are the same as if this subcommand had been run by itself
7064 * and the later subcommands had been issued in new ALTER TABLE commands.
7065 *
7066 * We can skip this entirely for relations without storage, since Phase 3
7067 * is certainly not going to touch them. System attributes don't have
7068 * interesting defaults, either.
7069 */
7071 {
7072 /*
7073 * For an identity column, we can't use build_column_default(),
7074 * because the sequence ownership isn't set yet. So do it manually.
7075 */
7077 {
7085 /* must do a rewrite for identity columns */
7087 }
7088 else
7092 {
7093 Oid baseTypeId;
7094 int32 baseTypeMod;
7095 Oid baseTypeColl;
7103 baseTypeId,
7104 typeOid,
7105 typmod,
7106 COERCION_ASSIGNMENT,
7107 COERCE_IMPLICIT_CAST,
7111 }
7114 {
7123 }
7129 {
7130 /*
7131 * If the new column is NOT NULL, and there is no missing value,
7132 * tell Phase 3 it needs to check for NULLs.
7133 */
7135 }
7136 }
7138 /*
7139 * Add needed dependency entries for the new column.
7140 */
7144 /*
7145 * Propagate to children as appropriate. Unlike most other ALTER
7146 * routines, we have to do this one level of recursion at a time; we can't
7147 * use find_all_inheritors to do it in one pass.
7148 */
7149 children =
7152 /*
7153 * If we are told not to recurse, there had better not be any child
7154 * tables; else the addition would put them out of step.
7155 */
7161 /* Children should see column as singly inherited */
7163 {
7168 }
7169 else
7173 {
7175 Relation childrel;
7178 /* find_inheritance_children already got lock */
7182 /* Find or create work queue entry for this table */
7185 /* Recurse to child; return value is ignored */
7191 }
7195 }
7197 /*
7198 * If a new or renamed column will collide with the name of an existing
7199 * column and if_not_exists is false then error out, else do nothing.
7200 */
7201 static bool
7204 {
7205 HeapTuple attTuple;
7208 /*
7209 * this test is deliberately not attisdropped-aware, since if one tries to
7210 * add a column matching a dropped column name, it's gonna fail anyway.
7211 */
7221 /*
7222 * We throw a different error message for conflicts with system column
7223 * names, since they are normally not shown and the user might otherwise
7224 * be confused about the reason for the conflict.
7225 */
7230 colname)));
7231 else
7232 {
7234 {
7240 }
7246 }
7249 }
7251 /*
7252 * Install a column's dependency on its datatype.
7253 */
7254 static void
7256 {
7257 ObjectAddress myself,
7258 referenced;
7267 }
7269 /*
7270 * Install a column's dependency on its collation.
7271 */
7272 static void
7274 {
7275 ObjectAddress myself,
7276 referenced;
7278 /* We know the default collation is pinned, so don't bother recording it */
7280 {
7288 }
7289 }
7291 /*
7292 * ALTER TABLE ALTER COLUMN DROP NOT NULL
7293 */
7295 static void
7297 {
7298 /*
7299 * If the parent is a partitioned table, like check constraints, we do not
7300 * support removing the NOT NULL while partitions exist.
7301 */
7303 {
7312 }
7313 }
7315 /*
7316 * Return the address of the modified column. If the column was already
7317 * nullable, InvalidObjectAddress is returned.
7318 */
7319 static ObjectAddress
7321 {
7322 HeapTuple tuple;
7323 Form_pg_attribute attTup;
7324 AttrNumber attnum;
7325 Relation attr_rel;
7328 ObjectAddress address;
7330 /*
7331 * lookup the attribute
7332 */
7344 /* Prevent them from altering a system attribute */
7349 colName)));
7357 /*
7358 * Check that the attribute is not in a primary key or in an index used as
7359 * a replica identity.
7360 *
7361 * Note: we'll throw error even if the pkey index is not valid.
7362 */
7364 /* Loop over all indexes on the relation */
7368 {
7370 HeapTuple indexTuple;
7371 Form_pg_index indexStruct;
7379 /*
7380 * If the index is not a primary key or an index used as replica
7381 * identity, skip the check.
7382 */
7384 {
7385 /*
7386 * Loop over each attribute in the primary key or the index used
7387 * as replica identity and see if it matches the to-be-altered
7388 * attribute.
7389 */
7391 {
7393 {
7398 colName)));
7399 else
7403 colName)));
7404 }
7405 }
7406 }
7409 }
7413 /* If rel is partition, shouldn't drop NOT NULL if parent has the same */
7415 {
7419 AttrNumber parent_attnum;
7426 colName)));
7428 }
7430 /*
7431 * Okay, actually perform the catalog change ... if needed
7432 */
7434 {
7441 }
7442 else
7451 }
7453 /*
7454 * ALTER TABLE ALTER COLUMN SET NOT NULL
7455 */
7457 static void
7461 {
7462 /*
7463 * If we're already recursing, there's nothing to do; the topmost
7464 * invocation of ATSimpleRecursion already visited all children.
7465 */
7469 /*
7470 * If the target column is already marked NOT NULL, we can skip recursing
7471 * to children, because their columns should already be marked NOT NULL as
7472 * well. But there's no point in checking here unless the relation has
7473 * some children; else we can just wait till execution to check. (If it
7474 * does have children, however, this can save taking per-child locks
7475 * unnecessarily. This greatly improves concurrency in some parallel
7476 * restore scenarios.)
7477 *
7478 * Unfortunately, we can only apply this optimization to partitioned
7479 * tables, because traditional inheritance doesn't enforce that child
7480 * columns be NOT NULL when their parent is. (That's a bug that should
7481 * get fixed someday.)
7482 */
7485 {
7486 HeapTuple tuple;
7491 /* Might as well throw the error now, if name is bad */
7502 }
7504 /*
7505 * If we have ALTER TABLE ONLY ... SET NOT NULL on a partitioned table,
7506 * apply ALTER TABLE ... CHECK NOT NULL to every child. Otherwise, use
7507 * normal recursion logic.
7508 */
7511 {
7517 }
7518 else
7520 }
7522 /*
7523 * Return the address of the modified column. If the column was already NOT
7524 * NULL, InvalidObjectAddress is returned.
7525 */
7526 static ObjectAddress
7529 {
7530 HeapTuple tuple;
7531 AttrNumber attnum;
7532 Relation attr_rel;
7533 ObjectAddress address;
7535 /*
7536 * lookup the attribute
7537 */
7550 /* Prevent them from altering a system attribute */
7555 colName)));
7557 /*
7558 * Okay, actually perform the catalog change ... if needed
7559 */
7561 {
7566 /*
7567 * Ordinarily phase 3 must ensure that no NULLs exist in columns that
7568 * are set NOT NULL; however, if we can find a constraint which proves
7569 * this then we can skip that. We needn't bother looking if we've
7570 * already found that we must verify some other NOT NULL constraint.
7571 */
7574 {
7575 /* Tell Phase 3 it needs to test the constraint */
7577 }
7581 }
7582 else
7591 }
7593 /*
7594 * ALTER TABLE ALTER COLUMN CHECK NOT NULL
7595 *
7596 * This doesn't exist in the grammar, but we generate AT_CheckNotNull
7597 * commands against the partitions of a partitioned table if the user
7598 * writes ALTER TABLE ONLY ... SET NOT NULL on the partitioned table,
7599 * or tries to create a primary key on it (which internally creates
7600 * AT_SetNotNull on the partitioned table). Such a command doesn't
7601 * allow us to actually modify any partition, but we want to let it
7602 * go through if the partitions are already properly marked.
7603 *
7604 * In future, this might need to adjust the child table's state, likely
7605 * by incrementing an inheritance count for the attnotnull constraint.
7606 * For now we need only check for the presence of the flag.
7607 */
7608 static void
7611 {
7612 HeapTuple tuple;
7631 }
7633 /*
7634 * NotNullImpliedByRelConstraints
7635 * Does rel's existing constraints imply NOT NULL for the given attribute?
7636 */
7637 static bool
7639 {
7650 /*
7651 * argisrow = false is correct even for a composite column, because
7652 * attnotnull does not represent a SQL-spec IS NOT NULL test in such a
7653 * case, just IS DISTINCT FROM NULL.
7654 */
7659 {
7661 (errmsg_internal("existing constraints on column \"%s.%s\" are sufficient to prove that it does not contain nulls",
7664 }
7667 }
7669 /*
7670 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
7671 *
7672 * Return the address of the affected column.
7673 */
7674 static ObjectAddress
7677 {
7679 AttrNumber attnum;
7680 ObjectAddress address;
7682 /*
7683 * get the number of the attribute
7684 */
7692 /* Prevent them from altering a system attribute */
7697 colName)));
7711 newDefault || TupleDescAttr(tupdesc, attnum - 1)->attgenerated != ATTRIBUTE_GENERATED_STORED ? 0 :
7714 /*
7715 * Remove any old default for the column. We use RESTRICT here for
7716 * safety, but at present we do not expect anything to depend on the
7717 * default.
7718 *
7719 * We treat removing the existing default as an internal operation when it
7720 * is preparatory to adding a new default, but as a user-initiated
7721 * operation when the user asked for a drop.
7722 */
7727 {
7728 /* SET DEFAULT */
7737 /*
7738 * This function is intended for CREATE TABLE, so it processes a
7739 * _list_ of defaults, but we just do one.
7740 */
7743 }
7748 }
7750 /*
7751 * Add a pre-cooked default expression.
7752 *
7753 * Return the address of the affected column.
7754 */
7755 static ObjectAddress
7758 {
7759 ObjectAddress address;
7761 /* We assume no checking is required */
7763 /*
7764 * Remove any old default for the column. We use RESTRICT here for
7765 * safety, but at present we do not expect anything to depend on the
7766 * default. (In ordinary cases, there could not be a default in place
7767 * anyway, but it's possible when combining LIKE with inheritance.)
7768 */
7777 }
7779 /*
7780 * ALTER TABLE ALTER COLUMN ADD IDENTITY
7781 *
7782 * Return the address of the affected column.
7783 */
7784 static ObjectAddress
7787 {
7788 Relation attrelation;
7789 HeapTuple tuple;
7790 Form_pg_attribute attTup;
7791 AttrNumber attnum;
7792 ObjectAddress address;
7806 /* Can't alter a system attribute */
7811 colName)));
7813 /*
7814 * Creating a column as identity implies NOT NULL, so adding the identity
7815 * to an existing column that is not NOT NULL would create a state that
7816 * cannot be reproduced without contortions.
7817 */
7821 errmsg("column \"%s\" of relation \"%s\" must be declared NOT NULL before identity can be added",
7849 }
7851 /*
7852 * ALTER TABLE ALTER COLUMN SET { GENERATED or sequence options }
7853 *
7854 * Return the address of the affected column.
7855 */
7856 static ObjectAddress
7858 {
7861 HeapTuple tuple;
7862 Form_pg_attribute attTup;
7863 AttrNumber attnum;
7864 Relation attrelation;
7865 ObjectAddress address;
7868 {
7872 {
7878 }
7879 else
7882 }
7884 /*
7885 * Even if there is nothing to change here, we run all the checks. There
7886 * will be a subsequent ALTER SEQUENCE that relies on everything being
7887 * there.
7888 */
7905 colName)));
7914 {
7923 }
7924 else
7931 }
7933 /*
7934 * ALTER TABLE ALTER COLUMN DROP IDENTITY
7935 *
7936 * Return the address of the affected column.
7937 */
7938 static ObjectAddress
7940 {
7941 HeapTuple tuple;
7942 Form_pg_attribute attTup;
7943 AttrNumber attnum;
7944 Relation attrelation;
7945 ObjectAddress address;
7946 Oid seqid;
7947 ObjectAddress seqaddress;
7964 colName)));
7967 {
7973 else
7974 {
7981 }
7982 }
7996 /* drop the internal sequence */
8007 }
8009 /*
8010 * ALTER TABLE ALTER COLUMN DROP EXPRESSION
8011 */
8012 static void
8013 ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
8014 {
8015 /*
8016 * Reject ONLY if there are child tables. We could implement this, but it
8017 * is a bit complicated. GENERATED clauses must be attached to the column
8018 * definition and cannot be added later like DEFAULT, so if a child table
8019 * has a generation expression that the parent does not have, the child
8020 * column will necessarily be an attislocal column. So to implement ONLY
8021 * here, we'd need extra code to update attislocal of the direct child
8022 * tables, somewhat similar to how DROP COLUMN does it, so that the
8023 * resulting state can be properly dumped and restored.
8024 */
8031 /*
8032 * Cannot drop generation expression from inherited columns.
8033 */
8035 {
8036 HeapTuple tuple;
8037 Form_pg_attribute attTup;
8052 }
8053 }
8055 /*
8056 * Return the address of the affected column.
8057 */
8058 static ObjectAddress
8060 {
8061 HeapTuple tuple;
8062 Form_pg_attribute attTup;
8063 AttrNumber attnum;
8064 Relation attrelation;
8065 Oid attrdefoid;
8066 ObjectAddress address;
8083 colName)));
8086 {
8092 else
8093 {
8100 }
8101 }
8103 /*
8104 * Mark the column as no longer generated. (The atthasdef flag needs to
8105 * get cleared too, but RemoveAttrDefault will handle that.)
8106 */
8112 attnum);
8117 /*
8118 * Drop the dependency records of the GENERATED expression, in particular
8119 * its INTERNAL dependency on the column, which would otherwise cause
8120 * dependency.c to refuse to perform the deletion.
8121 */
8128 /* Make above changes visible */
8131 /*
8132 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8133 * safety, but at present we do not expect anything to depend on the
8134 * default.
8135 */
8142 }
8144 /*
8145 * ALTER TABLE ALTER COLUMN SET STATISTICS
8146 *
8147 * Return value is the address of the modified column
8148 */
8149 static ObjectAddress
8150 ATExecSetStatistics(Relation rel, const char *colName, int16 colNum, Node *newValue, LOCKMODE lockmode)
8151 {
8153 Relation attrelation;
8154 HeapTuple tuple;
8155 Form_pg_attribute attrtuple;
8156 AttrNumber attnum;
8157 ObjectAddress address;
8159 /*
8160 * We allow referencing columns by numbers only for indexes, since table
8161 * column numbers could contain gaps if columns are later dropped.
8162 */
8173 /*
8174 * Limit target to a sane range
8175 */
8177 {
8181 newtarget)));
8182 }
8184 {
8189 newtarget)));
8190 }
8195 {
8203 }
8204 else
8205 {
8213 }
8222 colName)));
8226 {
8238 }
8254 }
8256 /*
8257 * Return value is the address of the modified column
8258 */
8259 static ObjectAddress
8262 {
8263 Relation attrelation;
8264 HeapTuple tuple,
8265 newtuple;
8266 Form_pg_attribute attrtuple;
8267 AttrNumber attnum;
8268 Datum datum,
8269 newOptions;
8271 ObjectAddress address;
8292 colName)));
8294 /* Generate new proposed attoptions (text array) */
8300 /* Validate new options */
8303 /* Build new tuple. */
8308 else
8314 /* Update system catalog. */
8330 }
8332 /*
8333 * Helper function for ATExecSetStorage and ATExecSetCompression
8334 *
8335 * Set the attstorage and/or attcompression fields for index columns
8336 * associated with the specified table column.
8337 */
8338 static void
8340 AttrNumber attnum,
8343 LOCKMODE lockmode)
8344 {
8348 {
8350 Relation indrel;
8352 HeapTuple tuple;
8357 {
8359 {
8362 }
8363 }
8366 {
8369 }
8374 {
8390 }
8393 }
8394 }
8396 /*
8397 * ALTER TABLE ALTER COLUMN SET STORAGE
8398 *
8399 * Return value is the address of the modified column
8400 */
8401 static ObjectAddress
8403 {
8404 Relation attrelation;
8405 HeapTuple tuple;
8406 Form_pg_attribute attrtuple;
8407 AttrNumber attnum;
8408 ObjectAddress address;
8426 colName)));
8436 /*
8437 * Apply the change to indexes as well (only for simple index columns,
8438 * matching behavior of index.c ConstructTupleDescriptor()).
8439 */
8443 lockmode);
8452 }
8455 /*
8456 * ALTER TABLE DROP COLUMN
8457 *
8458 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
8459 * because we have to decide at runtime whether to recurse or not depending
8460 * on whether attinhcount goes to zero or not. (We can't check this in a
8461 * static pre-pass because it won't handle multiple inheritance situations
8462 * correctly.)
8463 */
8464 static void
8468 {
8479 }
8481 /*
8482 * Drops column 'colName' from relation 'rel' and returns the address of the
8483 * dropped column. The column is also dropped (or marked as no longer
8484 * inherited from relation) from the relation's inheritance children, if any.
8485 *
8486 * In the recursive invocations for inheritance child relations, instead of
8487 * dropping the column directly (if to be dropped at all), its object address
8488 * is added to 'addrs', which must be non-NULL in such invocations. All
8489 * columns are dropped at the same time after all the children have been
8490 * checked recursively.
8491 */
8492 static ObjectAddress
8494 DropBehavior behavior,
8498 {
8499 HeapTuple tuple;
8500 Form_pg_attribute targetatt;
8501 AttrNumber attnum;
8503 ObjectAddress object;
8506 /* At top level, permission check was done in ATPrepCmd, else do it */
8510 /* Initialize addrs on the first invocation */
8515 /*
8516 * get the number of the attribute
8517 */
8520 {
8522 {
8527 }
8528 else
8529 {
8534 }
8535 }
8540 /* Can't drop a system attribute */
8545 colName)));
8547 /*
8548 * Don't drop inherited columns, unless recursing (presumably from a drop
8549 * of the parent column)
8550 */
8555 colName)));
8557 /*
8558 * Don't drop columns used in the partition key, either. (If we let this
8559 * go through, the key column's dependencies would cause a cascaded drop
8560 * of the whole table, which is surely not what the user expected.)
8561 */
8572 /*
8573 * Propagate to children as appropriate. Unlike most other ALTER
8574 * routines, we have to do this one level of recursion at a time; we can't
8575 * use find_all_inheritors to do it in one pass.
8576 */
8577 children =
8581 {
8582 Relation attr_rel;
8585 /*
8586 * In case of a partitioned table, the column must be dropped from the
8587 * partitions as well.
8588 */
8597 {
8599 Relation childrel;
8600 Form_pg_attribute childatt;
8602 /* find_inheritance_children already got lock */
8617 {
8618 /*
8619 * If the child column has other definition sources, just
8620 * decrement its inheritance count; if not, recurse to delete
8621 * it.
8622 */
8624 {
8625 /* Time to delete this child column, too */
8629 }
8630 else
8631 {
8632 /* Child column must survive my deletion */
8637 /* Make update visible */
8639 }
8640 }
8641 else
8642 {
8643 /*
8644 * If we were told to drop ONLY in this table (no recursion),
8645 * we need to mark the inheritors' attributes as locally
8646 * defined rather than inherited.
8647 */
8653 /* Make update visible */
8655 }
8660 }
8662 }
8664 /* Add object to delete */
8671 {
8672 /* Recursion has ended, drop everything that was collected */
8675 }
8678 }
8680 /*
8681 * ALTER TABLE ADD INDEX
8682 *
8683 * There is no such command in the grammar, but parse_utilcmd.c converts
8684 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
8685 * us schedule creation of the index at the appropriate time during ALTER.
8686 *
8687 * Return value is the address of the new index.
8688 */
8689 static ObjectAddress
8692 {
8696 ObjectAddress address;
8701 /* The IndexStmt has already been through transformIndexStmt */
8704 /* suppress schema rights check when rebuilding existing index */
8706 /* skip index build if phase 3 will do it or we're reusing an old one */
8708 /* suppress notices when rebuilding existing index */
8712 stmt,
8718 check_rights,
8720 skip_build,
8721 quiet);
8723 /*
8724 * If TryReuseIndex() stashed a relfilenumber for us, we used it for the
8725 * new index instead of building from scratch. Restore associated fields.
8726 * This may store InvalidSubTransactionId in both fields, in which case
8727 * relcache.c will assume it can rebuild the relcache entry. Hence, do
8728 * this after the CCI that made catalog rows visible to any rebuild. The
8729 * DROP of the old edition of this index will have scheduled the storage
8730 * for deletion at commit, so cancel that pending deletion.
8731 */
8733 {
8740 }
8743 }
8745 /*
8746 * ALTER TABLE ADD STATISTICS
8747 *
8748 * This is no such command in the grammar, but we use this internally to add
8749 * AT_ReAddStatistics subcommands to rebuild extended statistics after a table
8750 * column type change.
8751 */
8752 static ObjectAddress
8755 {
8756 ObjectAddress address;
8760 /* The CreateStatsStmt has already been through transformStatsStmt */
8766 }
8768 /*
8769 * ALTER TABLE ADD CONSTRAINT USING INDEX
8770 *
8771 * Returns the address of the new constraint.
8772 */
8773 static ObjectAddress
8776 {
8778 Relation indexRel;
8783 ObjectAddress address;
8784 bits16 flags;
8790 /*
8791 * Doing this on partitioned tables is not a simple feature to implement,
8792 * so let's punt for now.
8793 */
8805 /* this should have been checked at parse time */
8809 /*
8810 * Determine name to assign to constraint. We require a constraint to
8811 * have the same name as the underlying index; therefore, use the index's
8812 * existing name as the default constraint name, and if the user
8813 * explicitly gives some other name for the constraint, rename the index
8814 * to match.
8815 */
8820 {
8825 }
8827 /* Extra checks needed if making primary key */
8831 /* Note we currently don't support EXCLUSION constraints here */
8834 else
8837 /* Create the catalog entries for the constraint */
8839 INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
8845 index_oid,
8846 InvalidOid,
8847 indexInfo,
8848 constraintName,
8849 constraintType,
8850 flags,
8851 allowSystemTableMods,
8857 }
8859 /*
8860 * ALTER TABLE ADD CONSTRAINT
8861 *
8862 * Return value is the address of the new constraint; if no constraint was
8863 * added, InvalidObjectAddress is returned.
8864 */
8865 static ObjectAddress
8868 LOCKMODE lockmode)
8869 {
8874 /*
8875 * Currently, we only expect to see CONSTR_CHECK and CONSTR_FOREIGN nodes
8876 * arriving here (see the preprocessing done in parse_utilcmd.c). Use a
8877 * switch anyway to make it easier to add more code later.
8878 */
8880 {
8882 address =
8885 lockmode);
8890 /*
8891 * Assign or validate constraint name
8892 */
8894 {
8903 }
8904 else
8910 NIL);
8913 newConstraint,
8915 lockmode);
8921 }
8924 }
8926 /*
8927 * Generate the column-name portion of the constraint name for a new foreign
8928 * key given the list of column names that reference the referenced
8929 * table. This will be passed to ChooseConstraintName along with the parent
8930 * table name and the "fkey" suffix.
8931 *
8932 * We know that less than NAMEDATALEN characters will actually be used, so we
8933 * can truncate the result once we've generated that many.
8934 *
8935 * XXX see also ChooseExtendedStatisticNameAddition and
8936 * ChooseIndexNameAddition.
8937 */
8940 {
8947 {
8953 /*
8954 * At this point we have buflen <= NAMEDATALEN. name should be less
8955 * than NAMEDATALEN already, but use strlcpy for paranoia.
8956 */
8961 }
8963 }
8965 /*
8966 * Add a check constraint to a single table and its children. Returns the
8967 * address of the constraint added to the parent relation, if one gets added,
8968 * or InvalidObjectAddress otherwise.
8969 *
8970 * Subroutine for ATExecAddConstraint.
8971 *
8972 * We must recurse to child tables during execution, rather than using
8973 * ALTER TABLE's normal prep-time recursion. The reason is that all the
8974 * constraints *must* be given the same name, else they won't be seen as
8975 * related later. If the user didn't explicitly specify a name, then
8976 * AddRelationNewConstraints would normally assign different names to the
8977 * child constraints. To fix that, we must capture the name assigned at
8978 * the parent table and pass that down.
8979 */
8980 static ObjectAddress
8984 {
8991 /* At top level, permission check was done in ATPrepCmd, else do it */
8995 /*
8996 * Call AddRelationNewConstraints to do the work, making sure it works on
8997 * a copy of the Constraint so transformExpr can't modify the original. It
8998 * returns a list of cooked constraints.
8999 *
9000 * If the constraint ends up getting merged with a pre-existing one, it's
9001 * omitted from the returned list, which is what we want: we do not need
9002 * to do any validation work. That can only happen at child tables,
9003 * though, since we disallow merging at the top level.
9004 */
9011 * here */
9013 /* we don't expect more than one constraint here */
9016 /* Add each to-be-validated constraint to Phase 3's queue */
9018 {
9022 {
9031 }
9033 /* Save the actually assigned name if it was defaulted */
9038 }
9040 /* At this point we must have a locked-down name to use */
9043 /* Advance command counter in case same table is visited multiple times */
9046 /*
9047 * If the constraint got merged with an existing constraint, we're done.
9048 * We mustn't recurse to child tables in this case, because they've
9049 * already got the constraint, and visiting them again would lead to an
9050 * incorrect value for coninhcount.
9051 */
9055 /*
9056 * If adding a NO INHERIT constraint, no need to find our children.
9057 */
9061 /*
9062 * Propagate to children as appropriate. Unlike most other ALTER
9063 * routines, we have to do this one level of recursion at a time; we can't
9064 * use find_all_inheritors to do it in one pass.
9065 */
9066 children =
9069 /*
9070 * Check if ONLY was specified with ALTER TABLE. If so, allow the
9071 * constraint creation only if there are no children currently. Error out
9072 * otherwise.
9073 */
9080 {
9082 Relation childrel;
9085 /* find_inheritance_children already got lock */
9089 /* Find or create work queue entry for this table */
9092 /* Recurse to child */
9097 }
9100 }
9102 /*
9103 * Add a foreign-key constraint to a single table; return the new constraint's
9104 * address.
9105 *
9106 * Subroutine for ATExecAddConstraint. Must already hold exclusive
9107 * lock on the rel, and have done appropriate validity checks for it.
9108 * We do permissions checks here, however.
9109 *
9110 * When the referenced or referencing tables (or both) are partitioned,
9111 * multiple pg_constraint rows are required -- one for each partitioned table
9112 * and each partition on each side (fortunately, not one for every combination
9113 * thereof). We also need action triggers on each leaf partition on the
9114 * referenced side, and check triggers on each leaf partition on the
9115 * referencing side.
9116 */
9117 static ObjectAddress
9121 {
9122 Relation pkrel;
9134 numpks,
9135 numfkdelsetcols;
9136 Oid indexOid;
9138 ObjectAddress address;
9141 /*
9142 * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
9143 * delete rows out from under us.
9144 */
9147 else
9150 /*
9151 * Validity checks (permission checks wait till we have the column
9152 * numbers)
9153 */
9155 {
9159 errmsg("cannot use ONLY for foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9165 errmsg("cannot add NOT VALID foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9169 }
9184 /*
9185 * References from permanent or unlogged tables to temp tables, and from
9186 * permanent tables to unlogged tables, are disallowed because the
9187 * referenced data can vanish out from under us. References from temp
9188 * tables to any other table type are also disallowed, because other
9189 * backends might need to run the RI triggers on the perm table, but they
9190 * can't reliably see tuples in the local buffers of other backends.
9191 */
9193 {
9217 }
9219 /*
9220 * Look up the referencing attributes to make sure they exist, and record
9221 * their attnums and type OIDs.
9222 */
9234 /*
9235 * If the attribute list for the referenced table was omitted, lookup the
9236 * definition of the primary key and use it. Otherwise, validate the
9237 * supplied attribute list. In either case, discover the index OID and
9238 * index opclasses, and the attnums and type OIDs of the attributes.
9239 */
9241 {
9245 opclasses);
9246 }
9247 else
9248 {
9252 /* Look for an index matching the column list */
9254 opclasses);
9255 }
9257 /*
9258 * Now we can check permissions.
9259 */
9262 /*
9263 * Check some things for generated columns.
9264 */
9266 {
9270 {
9271 /*
9272 * Check restrictions on UPDATE/DELETE actions, per SQL standard
9273 */
9287 }
9288 }
9290 /*
9291 * Look up the equality operators to use in the constraint.
9292 *
9293 * Note that we have to be careful about the difference between the actual
9294 * PK column type and the opclass' declared input type, which might be
9295 * only binary-compatible with it. The declared opcintype is the right
9296 * thing to probe pg_amop with.
9297 */
9303 /*
9304 * On the strength of a previous constraint, we might avoid scanning
9305 * tables to validate this one. See below.
9306 */
9311 {
9314 Oid fktyped;
9315 HeapTuple cla_ht;
9316 Form_pg_opclass cla_tup;
9317 Oid amid;
9318 Oid opfamily;
9319 Oid opcintype;
9320 Oid pfeqop;
9321 Oid ppeqop;
9322 Oid ffeqop;
9323 int16 eqstrategy;
9324 Oid pfeqop_right;
9326 /* We need several fields out of the pg_opclass entry */
9336 /*
9337 * Check it's a btree; currently this can never fail since no other
9338 * index AMs support unique indexes. If we ever did have other types
9339 * of unique indexes, we'd need a way to determine which operator
9340 * strategy number is equality. (Is it reasonable to insist that
9341 * every such index AM use btree's number for equality?)
9342 */
9347 /*
9348 * There had better be a primary equality operator for the index.
9349 * We'll use it for PK = PK comparisons.
9350 */
9352 eqstrategy);
9358 /*
9359 * Are there equality operators that take exactly the FK type? Assume
9360 * we should look through any domain here.
9361 */
9365 eqstrategy);
9367 {
9370 eqstrategy);
9371 }
9372 else
9373 {
9374 /* keep compiler quiet */
9377 }
9380 {
9381 /*
9382 * Otherwise, look for an implicit cast from the FK type to the
9383 * opcintype, and if found, use the primary equality operator.
9384 * This is a bit tricky because opcintype might be a polymorphic
9385 * type such as ANYARRAY or ANYENUM; so what we have to test is
9386 * whether the two actual column types can be concurrently cast to
9387 * that type. (Otherwise, we'd fail to reject combinations such
9388 * as int[] and point[].)
9389 */
9398 COERCION_IMPLICIT))
9399 {
9402 }
9403 }
9418 {
9419 /*
9420 * When a pfeqop changes, revalidate the constraint. We could
9421 * permit intra-opfamily changes, but that adds subtle complexity
9422 * without any concrete benefit for core types. We need not
9423 * assess ppeqop or ffeqop, which RI_Initial_Check() does not use.
9424 */
9427 old_pfeqop_item);
9428 }
9430 {
9431 Oid old_fktype;
9432 Oid new_fktype;
9433 CoercionPathType old_pathtype;
9434 CoercionPathType new_pathtype;
9435 Oid old_castfunc;
9436 Oid new_castfunc;
9440 /*
9441 * Identify coercion pathways from each of the old and new FK-side
9442 * column types to the right (foreign) operand type of the pfeqop.
9443 * We may assume that pg_constraint.conkey is not changing.
9444 */
9452 /*
9453 * Upon a change to the cast from the FK column to its pfeqop
9454 * operand, revalidate the constraint. For this evaluation, a
9455 * binary coercion cast is equivalent to no cast at all. While
9456 * type implementors should design implicit casts with an eye
9457 * toward consistency of operations like equality, we cannot
9458 * assume here that they have done so.
9459 *
9460 * A function with a polymorphic argument could change behavior
9461 * arbitrarily in response to get_fn_expr_argtype(). Therefore,
9462 * when the cast destination is polymorphic, we only avoid
9463 * revalidation if the input type has not changed at all. Given
9464 * just the core data types and operator classes, this requirement
9465 * prevents no would-be optimizations.
9466 *
9467 * If the cast converts from a base type to a domain thereon, then
9468 * that domain type must be the opcintype of the unique index.
9469 * Necessarily, the primary key column must then be of the domain
9470 * type. Since the constraint was previously valid, all values on
9471 * the foreign side necessarily exist on the primary side and in
9472 * turn conform to the domain. Consequently, we need not treat
9473 * domains specially here.
9474 *
9475 * Since we require that all collations share the same notion of
9476 * equality (which they do, because texteq reduces to bitwise
9477 * equality), we don't compare collation here.
9478 *
9479 * We need not directly consider the PK type. It's necessarily
9480 * binary coercible to the opcintype of the unique index column,
9481 * and ri_triggers.c will only deal with PK datums in terms of
9482 * that opcintype. Changing the opcintype also changes pfeqop.
9483 */
9488 }
9493 }
9495 /*
9496 * Create all the constraint and trigger objects, recursing to partitions
9497 * as necessary. First handle the referenced side.
9498 */
9500 indexOid,
9502 numfks,
9503 pkattnum,
9504 fkattnum,
9505 pfeqoperators,
9506 ppeqoperators,
9507 ffeqoperators,
9508 numfkdelsetcols,
9509 fkdelsetcols,
9510 old_check_ok,
9513 /* Now handle the referencing side. */
9515 indexOid,
9517 numfks,
9518 pkattnum,
9519 fkattnum,
9520 pfeqoperators,
9521 ppeqoperators,
9522 ffeqoperators,
9523 numfkdelsetcols,
9524 fkdelsetcols,
9525 old_check_ok,
9526 lockmode,
9529 /*
9530 * Done. Close pk table, but keep lock until we've committed.
9531 */
9535 }
9537 /*
9538 * validateFkOnDeleteSetColumns
9539 * Verifies that columns used in ON DELETE SET NULL/DEFAULT (...)
9540 * column lists are valid.
9541 */
9542 void
9546 {
9548 {
9553 {
9555 {
9558 }
9559 }
9562 {
9568 }
9569 }
9570 }
9572 /*
9573 * addFkRecurseReferenced
9574 * subroutine for ATAddForeignKeyConstraint; recurses on the referenced
9575 * side of the constraint
9576 *
9577 * Create pg_constraint rows for the referenced side of the constraint,
9578 * referencing the parent of the referencing side; also create action triggers
9579 * on leaf partitions. If the table is partitioned, recurse to handle each
9580 * partition.
9581 *
9582 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
9583 * of an ALTER TABLE sequence.
9584 * fkconstraint is the constraint being added.
9585 * rel is the root referencing relation.
9586 * pkrel is the referenced relation; might be a partition, if recursing.
9587 * indexOid is the OID of the index (on pkrel) implementing this constraint.
9588 * parentConstr is the OID of a parent constraint; InvalidOid if this is a
9589 * top-level constraint.
9590 * numfks is the number of columns in the foreign key
9591 * pkattnum is the attnum array of referenced attributes.
9592 * fkattnum is the attnum array of referencing attributes.
9593 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
9594 * (...) clause
9595 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
9596 * NULL/DEFAULT clause
9597 * pf/pp/ffeqoperators are OID array of operators between columns.
9598 * old_check_ok signals that this constraint replaces an existing one that
9599 * was already validated (thus this one doesn't need validation).
9600 * parentDelTrigger and parentUpdTrigger, when being recursively called on
9601 * a partition, are the OIDs of the parent action triggers for DELETE and
9602 * UPDATE respectively.
9603 */
9604 static ObjectAddress
9613 {
9614 ObjectAddress address;
9615 Oid constrOid;
9620 Oid deleteTriggerOid,
9621 updateTriggerOid;
9623 /*
9624 * Verify relkind for each referenced partition. At the top level, this
9625 * is redundant with a previous check, but we need it when recursing.
9626 */
9634 /*
9635 * Caller supplies us with a constraint name; however, it may be used in
9636 * this partition, so come up with a different one in that case.
9637 */
9645 else
9649 {
9653 }
9654 else
9655 {
9659 /*
9660 * always inherit for partitioned tables, never for legacy inheritance
9661 */
9663 }
9665 /*
9666 * Record the FK constraint in pg_constraint.
9667 */
9670 CONSTRAINT_FOREIGN,
9674 parentConstr,
9676 fkattnum,
9677 numfks,
9678 numfks,
9680 indexOid,
9682 pkattnum,
9683 pfeqoperators,
9684 ppeqoperators,
9685 ffeqoperators,
9686 numfks,
9689 fkdelsetcols,
9690 numfkdelsetcols,
9694 NULL,
9702 /*
9703 * Mark the child constraint as part of the parent constraint; it must not
9704 * be dropped on its own. (This constraint is deleted when the partition
9705 * is detached, but a special check needs to occur that the partition
9706 * contains no referenced values.)
9707 */
9709 {
9710 ObjectAddress referenced;
9714 }
9716 /* make new constraint visible, in case we add more */
9719 /*
9720 * Create the action triggers that enforce the constraint.
9721 */
9723 fkconstraint,
9728 /*
9729 * If the referenced table is partitioned, recurse on ourselves to handle
9730 * each partition. We need one pg_constraint row created for each
9731 * partition in addition to the pg_constraint row for the parent table.
9732 */
9734 {
9738 {
9739 Relation partRel;
9742 Oid partIndexId;
9746 /*
9747 * Map the attribute numbers in the referenced side of the FK
9748 * definition to match the partition's column layout.
9749 */
9754 {
9758 }
9759 else
9762 /* do the deed */
9772 old_check_ok,
9775 /* Done -- clean up (but keep the lock) */
9778 {
9781 }
9782 }
9783 }
9786 }
9788 /*
9789 * addFkRecurseReferencing
9790 * subroutine for ATAddForeignKeyConstraint and CloneFkReferencing
9791 *
9792 * If the referencing relation is a plain relation, create the necessary check
9793 * triggers that implement the constraint, and set up for Phase 3 constraint
9794 * verification. If the referencing relation is a partitioned table, then
9795 * we create a pg_constraint row for it and recurse on this routine for each
9796 * partition.
9797 *
9798 * We assume that the referenced relation is locked against concurrent
9799 * deletions. If it's a partitioned relation, every partition must be so
9800 * locked.
9801 *
9802 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
9803 * of an ALTER TABLE sequence.
9804 * fkconstraint is the constraint being added.
9805 * rel is the referencing relation; might be a partition, if recursing.
9806 * pkrel is the root referenced relation.
9807 * indexOid is the OID of the index (on pkrel) implementing this constraint.
9808 * parentConstr is the OID of the parent constraint (there is always one).
9809 * numfks is the number of columns in the foreign key
9810 * pkattnum is the attnum array of referenced attributes.
9811 * fkattnum is the attnum array of referencing attributes.
9812 * pf/pp/ffeqoperators are OID array of operators between columns.
9813 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
9814 * (...) clause
9815 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
9816 * NULL/DEFAULT clause
9817 * old_check_ok signals that this constraint replaces an existing one that
9818 * was already validated (thus this one doesn't need validation).
9819 * lockmode is the lockmode to acquire on partitions when recursing.
9820 * parentInsTrigger and parentUpdTrigger, when being recursively called on
9821 * a partition, are the OIDs of the parent check triggers for INSERT and
9822 * UPDATE respectively.
9823 */
9824 static void
9832 {
9833 Oid insertTriggerOid,
9834 updateTriggerOid;
9843 /*
9844 * Add the check triggers to it and, if necessary, schedule it to be
9845 * checked in Phase 3.
9846 *
9847 * If the relation is partitioned, drill down to do it to its partitions.
9848 */
9851 fkconstraint,
9852 parentConstr,
9853 indexOid,
9858 {
9859 /*
9860 * Tell Phase 3 to check that the constraint is satisfied by existing
9861 * rows. We can skip this during table creation, when requested
9862 * explicitly by specifying NOT VALID in an ADD FOREIGN KEY command,
9863 * and when we're recreating a constraint following a SET DATA TYPE
9864 * operation that did not impugn its validity.
9865 */
9867 {
9882 }
9883 }
9885 {
9887 Relation trigrel;
9889 /*
9890 * Triggers of the foreign keys will be manipulated a bunch of times
9891 * in the loop below. To avoid repeatedly opening/closing the trigger
9892 * catalog relation, we open it here and pass it to the subroutines
9893 * called below.
9894 */
9897 /*
9898 * Recurse to take appropriate action on each partition; either we
9899 * find an existing constraint to reparent to ours, or we create a new
9900 * one.
9901 */
9903 {
9911 Oid constrOid;
9912 ObjectAddress address,
9913 referenced;
9924 /* Check whether an existing constraint can be repurposed */
9928 {
9933 partitionId,
9934 parentConstr,
9935 numfks,
9936 mapped_fkattnum,
9937 pkattnum,
9938 pfeqoperators,
9939 insertTriggerOid,
9940 updateTriggerOid,
9941 trigrel))
9942 {
9945 }
9946 }
9948 {
9951 }
9953 /*
9954 * No luck finding a good constraint to reuse; create our own.
9955 */
9963 else
9965 constrOid =
9968 CONSTRAINT_FOREIGN,
9972 parentConstr,
9973 partitionId,
9974 mapped_fkattnum,
9975 numfks,
9976 numfks,
9977 InvalidOid,
9978 indexOid,
9980 pkattnum,
9981 pfeqoperators,
9982 ppeqoperators,
9983 ffeqoperators,
9984 numfks,
9987 fkdelsetcols,
9988 numfkdelsetcols,
9990 NULL,
9991 NULL,
9992 NULL,
9998 /*
9999 * Give this constraint partition-type dependencies on the parent
10000 * constraint as well as the table.
10001 */
10008 /* Make all this visible before recursing */
10011 /* call ourselves to finalize the creation and we're done */
10013 indexOid,
10014 constrOid,
10015 numfks,
10016 pkattnum,
10017 mapped_fkattnum,
10018 pfeqoperators,
10019 ppeqoperators,
10020 ffeqoperators,
10021 numfkdelsetcols,
10022 fkdelsetcols,
10023 old_check_ok,
10024 lockmode,
10025 insertTriggerOid,
10026 updateTriggerOid);
10029 }
10032 }
10033 }
10035 /*
10036 * CloneForeignKeyConstraints
10037 * Clone foreign keys from a partitioned table to a newly acquired
10038 * partition.
10039 *
10040 * partitionRel is a partition of parentRel, so we can be certain that it has
10041 * the same columns with the same datatypes. The columns may be in different
10042 * order, though.
10043 *
10044 * wqueue must be passed to set up phase 3 constraint checking, unless the
10045 * referencing-side partition is known to be empty (such as in CREATE TABLE /
10046 * PARTITION OF).
10047 */
10048 static void
10050 Relation partitionRel)
10051 {
10052 /* This only works for declarative partitioning */
10055 /*
10056 * Clone constraints for which the parent is on the referenced side.
10057 */
10060 /*
10061 * Now clone constraints where the parent is on the referencing side.
10062 */
10064 }
10066 /*
10067 * CloneFkReferenced
10068 * Subroutine for CloneForeignKeyConstraints
10069 *
10070 * Find all the FKs that have the parent relation on the referenced side;
10071 * clone those constraints to the given partition. This is to be called
10072 * when the partition is being created or attached.
10073 *
10074 * This ignores self-referencing FKs; those are handled by CloneFkReferencing.
10075 *
10076 * This recurses to partitions, if the relation being attached is partitioned.
10077 * Recursion is done by calling addFkRecurseReferenced.
10078 */
10079 static void
10081 {
10082 Relation pg_constraint;
10085 SysScanDesc scan;
10087 HeapTuple tuple;
10089 Relation trigrel;
10091 /*
10092 * Search for any constraints where this partition's parent is in the
10093 * referenced side. However, we must not clone any constraint whose
10094 * parent constraint is also going to be cloned, to avoid duplicates. So
10095 * do it in two steps: first construct the list of constraints to clone,
10096 * then go over that list cloning those whose parents are not in the list.
10097 * (We must not rely on the parent being seen first, since the catalog
10098 * scan could return children first.)
10099 */
10107 /* This is a seqscan, as we don't have a usable index ... */
10111 {
10115 }
10119 /*
10120 * Triggers of the foreign keys will be manipulated a bunch of times in
10121 * the loop below. To avoid repeatedly opening/closing the trigger
10122 * catalog relation, we open it here and pass it to the subroutines called
10123 * below.
10124 */
10131 {
10133 Form_pg_constraint constrForm;
10134 Relation fkRel;
10135 Oid indexOid;
10136 Oid partIndexId;
10147 Oid deleteTriggerOid,
10148 updateTriggerOid;
10155 /*
10156 * As explained above: don't try to clone a constraint for which we're
10157 * going to clone the parent.
10158 */
10160 {
10163 }
10165 /*
10166 * Don't clone self-referencing foreign keys, which can be in the
10167 * partitioned table or in the partition-to-be.
10168 */
10171 {
10174 }
10176 /*
10177 * Because we're only expanding the key space at the referenced side,
10178 * we don't need to prevent any operation in the referencing table, so
10179 * AccessShareLock suffices (assumes that dropping the constraint
10180 * acquires AEL).
10181 */
10187 conkey,
10188 confkey,
10189 conpfeqop,
10190 conppeqop,
10191 conffeqop,
10193 confdelsetcols);
10205 /* ->fk_attrs determined below */
10216 /* set up colnames that are used to generate the constraint name */
10218 {
10219 Form_pg_attribute att;
10225 }
10227 /*
10228 * Add the new foreign key constraint pointing to the new partition.
10229 * Because this new partition appears in the referenced side of the
10230 * constraint, we don't need to set up for Phase 3 check.
10231 */
10237 /*
10238 * Get the "action" triggers belonging to the constraint to pass as
10239 * parent OIDs for similar triggers that will be created on the
10240 * partition in addFkRecurseReferenced().
10241 */
10247 fkconstraint,
10248 fkRel,
10249 partitionRel,
10250 partIndexId,
10251 constrOid,
10252 numfks,
10253 mapped_confkey,
10254 conkey,
10255 conpfeqop,
10256 conppeqop,
10257 conffeqop,
10258 numfkdelsetcols,
10259 confdelsetcols,
10261 deleteTriggerOid,
10262 updateTriggerOid);
10266 }
10269 }
10271 /*
10272 * CloneFkReferencing
10273 * Subroutine for CloneForeignKeyConstraints
10274 *
10275 * For each FK constraint of the parent relation in the given list, find an
10276 * equivalent constraint in its partition relation that can be reparented;
10277 * if one cannot be found, create a new constraint in the partition as its
10278 * child.
10279 *
10280 * If wqueue is given, it is used to set up phase-3 verification for each
10281 * cloned constraint; if omitted, we assume that such verification is not
10282 * needed (example: the partition is being created anew).
10283 */
10284 static void
10286 {
10291 Relation trigrel;
10293 /* obtain a list of constraints that we need to clone */
10295 {
10299 }
10301 /*
10302 * Silently do nothing if there's nothing to do. In particular, this
10303 * avoids throwing a spurious error for foreign tables.
10304 */
10313 /*
10314 * Triggers of the foreign keys will be manipulated a bunch of times in
10315 * the loop below. To avoid repeatedly opening/closing the trigger
10316 * catalog relation, we open it here and pass it to the subroutines called
10317 * below.
10318 */
10321 /*
10322 * The constraint key may differ, if the columns in the partition are
10323 * different. This map is used to convert them.
10324 */
10332 {
10334 Form_pg_constraint constrForm;
10335 Relation pkrel;
10336 HeapTuple tuple;
10348 Oid indexOid;
10349 Oid constrOid;
10350 ObjectAddress address,
10351 referenced;
10353 Oid insertTriggerOid,
10354 updateTriggerOid;
10359 parentConstrOid);
10362 /* Don't clone constraints whose parents are being cloned */
10364 {
10367 }
10369 /*
10370 * Need to prevent concurrent deletions. If pkrel is a partitioned
10371 * relation, that means to lock all partitions.
10372 */
10384 /*
10385 * Get the "check" triggers belonging to the constraint to pass as
10386 * parent OIDs for similar triggers that will be created on the
10387 * partition in addFkRecurseReferencing(). They are also passed to
10388 * tryAttachPartitionForeignKey() below to simply assign as parents to
10389 * the partition's existing "check" triggers, that is, if the
10390 * corresponding constraints is deemed attachable to the parent
10391 * constraint.
10392 */
10397 /*
10398 * Before creating a new constraint, see whether any existing FKs are
10399 * fit for the purpose. If one is, attach the parent constraint to
10400 * it, and don't clone anything. This way we avoid the expensive
10401 * verification step and don't end up with a duplicate FK, and we
10402 * don't need to recurse to partitions for this constraint.
10403 */
10406 {
10411 parentConstrOid,
10412 numfks,
10413 mapped_conkey,
10414 confkey,
10415 conpfeqop,
10416 insertTriggerOid,
10417 updateTriggerOid,
10418 trigrel))
10419 {
10423 }
10424 }
10426 {
10429 }
10431 /* No dice. Set up to create our own constraint */
10434 /* ->conname determined below */
10439 /* ->fk_attrs determined below */
10450 {
10451 Form_pg_attribute att;
10457 }
10466 else
10470 constrOid =
10473 CONSTRAINT_FOREIGN,
10477 parentConstrOid,
10479 mapped_conkey,
10480 numfks,
10481 numfks,
10483 indexOid,
10485 confkey,
10486 conpfeqop,
10487 conppeqop,
10488 conffeqop,
10489 numfks,
10492 confdelsetcols,
10493 numfkdelsetcols,
10495 NULL,
10496 NULL,
10497 NULL,
10503 /* Set up partition dependencies for the new constraint */
10511 /* Done with the cloned constraint's tuple */
10514 /* Make all this visible before recursing */
10518 fkconstraint,
10519 partRel,
10520 pkrel,
10521 indexOid,
10522 constrOid,
10523 numfks,
10524 confkey,
10525 mapped_conkey,
10526 conpfeqop,
10527 conppeqop,
10528 conffeqop,
10529 numfkdelsetcols,
10530 confdelsetcols,
10532 AccessExclusiveLock,
10533 insertTriggerOid,
10534 updateTriggerOid);
10536 }
10539 }
10541 /*
10542 * When the parent of a partition receives [the referencing side of] a foreign
10543 * key, we must propagate that foreign key to the partition. However, the
10544 * partition might already have an equivalent foreign key; this routine
10545 * compares the given ForeignKeyCacheInfo (in the partition) to the FK defined
10546 * by the other parameters. If they are equivalent, create the link between
10547 * the two constraints and return true.
10548 *
10549 * If the given FK does not match the one defined by rest of the params,
10550 * return false.
10551 */
10552 static bool
10554 Oid partRelid,
10555 Oid parentConstrOid,
10560 Oid parentInsTrigger,
10561 Oid parentUpdTrigger,
10562 Relation trigrel)
10563 {
10564 HeapTuple parentConstrTup;
10565 Form_pg_constraint parentConstr;
10566 HeapTuple partcontup;
10567 Form_pg_constraint partConstr;
10568 ScanKeyData key;
10569 SysScanDesc scan;
10570 HeapTuple trigtup;
10571 Oid insertTriggerOid,
10572 updateTriggerOid;
10580 /*
10581 * Do some quick & easy initial checks. If any of these fail, we cannot
10582 * use this constraint.
10583 */
10585 {
10588 }
10590 {
10594 {
10597 }
10598 }
10600 /*
10601 * Looks good so far; do some more extensive checks. Presumably the check
10602 * for 'convalidated' could be dropped, since we don't really care about
10603 * that, but let's be careful for now.
10604 */
10617 {
10621 }
10626 /*
10627 * Looks good! Attach this constraint. The action triggers in the new
10628 * partition become redundant -- the parent table already has equivalent
10629 * ones, and those will be able to reach the partition. Remove the ones
10630 * in the partition. We identify them because they have our constraint
10631 * OID, as well as being on the referenced rel.
10632 */
10634 Anum_pg_trigger_tgconstraint,
10640 {
10642 ObjectAddress trigger;
10649 /*
10650 * The constraint is originally set up to contain this trigger as an
10651 * implementation object, so there's a dependency record that links
10652 * the two; however, since the trigger is no longer needed, we remove
10653 * the dependency link in order to be able to drop the trigger while
10654 * keeping the constraint intact.
10655 */
10659 /* make dependency deletion visible to performDeletion */
10664 /* make trigger drop visible, in case the loop iterates */
10666 }
10672 /*
10673 * Like the constraint, attach partition's "check" triggers to the
10674 * corresponding parent triggers.
10675 */
10681 partRelid);
10684 partRelid);
10688 }
10690 /*
10691 * GetForeignKeyActionTriggers
10692 * Returns delete and update "action" triggers of the given relation
10693 * belonging to the given constraint
10694 */
10695 static void
10700 {
10701 ScanKeyData key;
10702 SysScanDesc scan;
10703 HeapTuple trigtup;
10707 Anum_pg_trigger_tgconstraint,
10714 {
10721 /* Only ever look at "action" triggers on the PK side. */
10725 {
10728 }
10730 {
10733 }
10734 #ifndef USE_ASSERT_CHECKING
10735 /* In an assert-enabled build, continue looking to find duplicates */
10738 #endif
10739 }
10743 conoid);
10746 conoid);
10749 }
10751 /*
10752 * GetForeignKeyCheckTriggers
10753 * Returns insert and update "check" triggers of the given relation
10754 * belonging to the given constraint
10755 */
10756 static void
10761 {
10762 ScanKeyData key;
10763 SysScanDesc scan;
10764 HeapTuple trigtup;
10768 Anum_pg_trigger_tgconstraint,
10775 {
10782 /* Only ever look at "check" triggers on the FK side. */
10786 {
10789 }
10791 {
10794 }
10795 #ifndef USE_ASSERT_CHECKING
10796 /* In an assert-enabled build, continue looking to find duplicates. */
10799 #endif
10800 }
10804 conoid);
10807 conoid);
10810 }
10812 /*
10813 * ALTER TABLE ALTER CONSTRAINT
10814 *
10815 * Update the attributes of a constraint.
10816 *
10817 * Currently only works for Foreign Key constraints.
10818 *
10819 * If the constraint is modified, returns its address; otherwise, return
10820 * InvalidObjectAddress.
10821 */
10822 static ObjectAddress
10825 {
10827 Relation conrel;
10828 Relation tgrel;
10829 SysScanDesc scan;
10831 HeapTuple contuple;
10832 Form_pg_constraint currcon;
10833 ObjectAddress address;
10842 /*
10843 * Find and check the target constraint
10844 */
10846 Anum_pg_constraint_conrelid,
10850 Anum_pg_constraint_contypid,
10854 Anum_pg_constraint_conname,
10860 /* There can be at most one matching row */
10874 /*
10875 * If it's not the topmost constraint, raise an error.
10876 *
10877 * Altering a non-topmost constraint leaves some triggers untouched, since
10878 * they are not directly connected to this constraint; also, pg_dump would
10879 * ignore the deferrability status of the individual constraint, since it
10880 * only dumps topmost constraints. Avoid these problems by refusing this
10881 * operation and telling the user to alter the parent constraint instead.
10882 */
10884 {
10885 HeapTuple tp;
10890 /* Loop to find the topmost constraint */
10892 {
10895 /* If no parent, this is the constraint we want */
10897 {
10902 }
10906 }
10915 }
10917 /*
10918 * Do the actual catalog work. We can skip changing if already in the
10919 * desired state, but not if a partitioned table: partitions need to be
10920 * processed regardless, in case they had the constraint locally changed.
10921 */
10926 {
10930 }
10932 /*
10933 * ATExecAlterConstrRecurse already invalidated relcache for the relations
10934 * having the constraint itself; here we also invalidate for relations
10935 * that have any triggers that are part of the constraint.
10936 */
10946 }
10948 /*
10949 * Recursive subroutine of ATExecAlterConstraint. Returns true if the
10950 * constraint is altered.
10951 *
10952 * *otherrelids is appended OIDs of relations containing affected triggers.
10953 *
10954 * Note that we must recurse even when the values are correct, in case
10955 * indirect descendants have had their constraints altered locally.
10956 * (This could be avoided if we forbade altering constraints in partitions
10957 * but existing releases don't do that.)
10958 */
10959 static bool
10962 LOCKMODE lockmode)
10963 {
10964 Form_pg_constraint currcon;
10965 Oid conoid;
10966 Oid refrelid;
10973 /*
10974 * Update pg_constraint with the flags from cmdcon.
10975 *
10976 * If called to modify a constraint that's already in the desired state,
10977 * silently do nothing.
10978 */
10981 {
10982 HeapTuple copyTuple;
10983 Form_pg_constraint copy_con;
10984 HeapTuple tgtuple;
10985 ScanKeyData tgkey;
10986 SysScanDesc tgscan;
11000 /* Make new constraint flags visible to others */
11003 /*
11004 * Now we need to update the multiple entries in pg_trigger that
11005 * implement the constraint.
11006 */
11008 Anum_pg_trigger_tgconstraint,
11014 {
11016 Form_pg_trigger copy_tg;
11017 HeapTuple tgCopyTuple;
11019 /*
11020 * Remember OIDs of other relation(s) involved in FK constraint.
11021 * (Note: it's likely that we could skip forcing a relcache inval
11022 * for other rels that don't have a trigger whose properties
11023 * change, but let's be conservative.)
11024 */
11029 /*
11030 * Update deferrability of RI_FKey_noaction_del,
11031 * RI_FKey_noaction_upd, RI_FKey_check_ins and RI_FKey_check_upd
11032 * triggers, but not others; see createForeignKeyActionTriggers
11033 * and CreateFKCheckTrigger.
11034 */
11051 }
11054 }
11056 /*
11057 * If the table at either end of the constraint is partitioned, we need to
11058 * recurse and handle every constraint that is a child of this one.
11059 *
11060 * (This assumes that the recurse flag is forcibly set for partitioned
11061 * tables, and not set for legacy inheritance, though we don't check for
11062 * that here.)
11063 */
11066 {
11067 ScanKeyData pkey;
11068 SysScanDesc pscan;
11069 HeapTuple childtup;
11072 Anum_pg_constraint_conparentid,
11080 {
11082 Relation childrel;
11088 }
11091 }
11094 }
11096 /*
11097 * ALTER TABLE VALIDATE CONSTRAINT
11098 *
11099 * XXX The reason we handle recursion here rather than at Phase 1 is because
11100 * there's no good way to skip recursing when handling foreign keys: there is
11101 * no need to lock children in that case, yet we wouldn't be able to avoid
11102 * doing so at that level.
11103 *
11104 * Return value is the address of the validated constraint. If the constraint
11105 * was already validated, InvalidObjectAddress is returned.
11106 */
11107 static ObjectAddress
11110 {
11111 Relation conrel;
11112 SysScanDesc scan;
11114 HeapTuple tuple;
11115 Form_pg_constraint con;
11116 ObjectAddress address;
11120 /*
11121 * Find and check the target constraint
11122 */
11124 Anum_pg_constraint_conrelid,
11128 Anum_pg_constraint_contypid,
11132 Anum_pg_constraint_conname,
11138 /* There can be at most one matching row */
11154 {
11156 HeapTuple copyTuple;
11157 Form_pg_constraint copy_con;
11160 {
11164 /* Queue validation for phase 3 */
11166 /* for now this is all we need */
11177 /* Find or create work queue entry for this table */
11181 /*
11182 * We disallow creating invalid foreign keys to or from
11183 * partitioned tables, so ignoring the recursion bit is okay.
11184 */
11185 }
11187 {
11191 Datum val;
11194 /*
11195 * If we're recursing, the parent has already done this, so skip
11196 * it. Also, if the constraint is a NO INHERIT constraint, we
11197 * shouldn't try to look for it in the children.
11198 */
11203 /*
11204 * For CHECK constraints, we must ensure that we only mark the
11205 * constraint as validated on the parent if it's already validated
11206 * on the children.
11207 *
11208 * We recurse before validating on the parent, to reduce risk of
11209 * deadlocks.
11210 */
11212 {
11214 Relation childrel;
11219 /*
11220 * If we are told not to recurse, there had better not be any
11221 * child tables, because we can't mark the constraint on the
11222 * parent valid unless it is valid for all child tables.
11223 */
11229 /* find_all_inheritors already got lock */
11235 }
11237 /* Queue validation for phase 3 */
11246 Anum_pg_constraint_conbin);
11250 /* Find or create work queue entry for this table */
11254 /*
11255 * Invalidate relcache so that others see the new validated
11256 * constraint.
11257 */
11259 }
11261 /*
11262 * Now update the catalog, while we have the door open.
11263 */
11274 }
11275 else
11283 }
11286 /*
11287 * transformColumnNameList - transform list of column names
11288 *
11289 * Lookup each name and return its attnum and, optionally, type OID
11290 *
11291 * Note: the name of this function suggests that it's general-purpose,
11292 * but actually it's only used to look up names appearing in foreign-key
11293 * clauses. The error messages would need work to use it in other cases,
11294 * and perhaps the validity checks as well.
11295 */
11296 static int
11299 {
11305 {
11307 HeapTuple atttuple;
11308 Form_pg_attribute attform;
11315 attname)));
11325 INDEX_MAX_KEYS)));
11330 attnum++;
11331 }
11334 }
11336 /*
11337 * transformFkeyGetPrimaryKey -
11338 *
11339 * Look up the names, attnums, and types of the primary key attributes
11340 * for the pkrel. Also return the index OID and index opclasses of the
11341 * index supporting the primary key.
11342 *
11343 * All parameters except pkrel are output parameters. Also, the function
11344 * return value is the number of attributes in the primary key.
11345 *
11346 * Used when the column list in the REFERENCES specification is omitted.
11347 */
11348 static int
11353 {
11358 Datum indclassDatum;
11362 /*
11363 * Get the list of index OIDs for the table from the relcache, and look up
11364 * each one in the pg_index syscache until we find one marked primary key
11365 * (hopefully there isn't more than one such). Insist it's valid, too.
11366 */
11372 {
11380 {
11381 /*
11382 * Refuse to use a deferrable primary key. This is per SQL spec,
11383 * and there would be a lot of interesting semantic problems if we
11384 * tried to allow it.
11385 */
11394 }
11396 }
11400 /*
11401 * Check that we found it
11402 */
11409 /* Must get indclass the hard way */
11411 Anum_pg_index_indclass);
11414 /*
11415 * Now build the list of PK attributes from the indkey definition (we
11416 * assume a primary key cannot have expressional elements)
11417 */
11420 {
11428 }
11433 }
11435 /*
11436 * transformFkeyCheckAttrs -
11437 *
11438 * Make sure that the attributes of a referenced table belong to a unique
11439 * (or primary key) constraint. Return the OID of the index supporting
11440 * the constraint, as well as the opclasses associated with the index
11441 * columns.
11442 */
11443 static Oid
11447 {
11454 j;
11456 /*
11457 * Reject duplicate appearances of columns in the referenced-columns list.
11458 * Such a case is forbidden by the SQL standard, and even if we thought it
11459 * useful to allow it, there would be ambiguity about how to match the
11460 * list to unique indexes (in particular, it'd be unclear which index
11461 * opclass goes with which FK column).
11462 */
11464 {
11466 {
11471 }
11472 }
11474 /*
11475 * Get the list of index OIDs for the table from the relcache, and look up
11476 * each one in the pg_index syscache, and match unique indexes to the list
11477 * of attnums we are given.
11478 */
11482 {
11483 HeapTuple indexTuple;
11484 Form_pg_index indexStruct;
11492 /*
11493 * Must have the right number of columns; must be unique and not a
11494 * partial index; forget it if there are any expressions, too. Invalid
11495 * indexes are out as well.
11496 */
11502 {
11503 Datum indclassDatum;
11506 /* Must get indclass the hard way */
11508 Anum_pg_index_indclass);
11511 /*
11512 * The given attnum list may match the index columns in any order.
11513 * Check for a match, and extract the appropriate opclasses while
11514 * we're at it.
11515 *
11516 * We know that attnums[] is duplicate-free per the test at the
11517 * start of this function, and we checked above that the number of
11518 * index columns agrees, so if we find a match for each attnums[]
11519 * entry then we must have a one-to-one match in some order.
11520 */
11522 {
11525 {
11527 {
11531 }
11532 }
11535 }
11537 /*
11538 * Refuse to use a deferrable unique/primary key. This is per SQL
11539 * spec, and there would be a lot of interesting semantic problems
11540 * if we tried to allow it.
11541 */
11543 {
11544 /*
11545 * Remember that we found an otherwise matching index, so that
11546 * we can generate a more appropriate error message.
11547 */
11550 }
11551 }
11555 }
11558 {
11564 else
11569 }
11574 }
11576 /*
11577 * findFkeyCast -
11578 *
11579 * Wrapper around find_coercion_pathway() for ATAddForeignKeyConstraint().
11580 * Caller has equal regard for binary coercibility and for an exact match.
11581 */
11582 static CoercionPathType
11584 {
11585 CoercionPathType ret;
11588 {
11591 }
11592 else
11593 {
11597 /* A previously-relied-upon cast is now gone. */
11600 }
11603 }
11605 /*
11606 * Permissions checks on the referenced table for ADD FOREIGN KEY
11607 *
11608 * Note: we have already checked that the user owns the referencing table,
11609 * else we'd have failed much earlier; no additional checks are needed for it.
11610 */
11611 static void
11613 {
11615 AclResult aclresult;
11618 /* Okay if we have relation-level REFERENCES permission */
11620 ACL_REFERENCES);
11623 /* Else we must have REFERENCES on each column */
11625 {
11631 }
11632 }
11634 /*
11635 * Scan the existing rows in a table to verify they meet a proposed FK
11636 * constraint.
11637 *
11638 * Caller must have opened and locked both relations appropriately.
11639 */
11640 static void
11642 Relation rel,
11643 Relation pkrel,
11644 Oid pkindOid,
11645 Oid constraintOid)
11646 {
11648 TableScanDesc scan;
11650 Snapshot snapshot;
11651 MemoryContext oldcxt;
11652 MemoryContext perTupCxt;
11657 /*
11658 * Build a trigger call structure; we'll need it either way.
11659 */
11669 /* we needn't fill in remaining fields */
11671 /*
11672 * See if we can do it with a single LEFT JOIN query. A false result
11673 * indicates we must proceed with the fire-the-trigger method.
11674 */
11678 /*
11679 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
11680 * if that tuple had just been inserted. If any of those fail, it should
11681 * ereport(ERROR) and that's that.
11682 */
11689 ALLOCSET_SMALL_SIZES);
11693 {
11699 /*
11700 * Make a call to the trigger function
11701 *
11702 * No parameters are passed, but we do set a context
11703 */
11706 /*
11707 * We assume RI_FKey_check_ins won't look at flinfo...
11708 */
11721 }
11728 }
11730 /*
11731 * CreateFKCheckTrigger
11732 * Creates the insert (on_insert=true) or update "check" trigger that
11733 * implements a given foreign key
11734 *
11735 * Returns the OID of the so created trigger.
11736 */
11737 static Oid
11741 {
11742 ObjectAddress trigAddress;
11745 /*
11746 * Note: for a self-referential FK (referencing and referenced tables are
11747 * the same), it is important that the ON UPDATE action fires before the
11748 * CHECK action, since both triggers will fire on the same row during an
11749 * UPDATE event; otherwise the CHECK trigger will be checking a non-final
11750 * state of the row. Triggers fire in name order, so we ensure this by
11751 * using names like "RI_ConstraintTrigger_a_NNNN" for the action triggers
11752 * and "RI_ConstraintTrigger_c_NNNN" for the check triggers.
11753 */
11760 /* Either ON INSERT or ON UPDATE */
11762 {
11765 }
11766 else
11767 {
11770 }
11786 /* Make changes-so-far visible */
11790 }
11792 /*
11793 * createForeignKeyActionTriggers
11794 * Create the referenced-side "action" triggers that implement a foreign
11795 * key.
11796 *
11797 * Returns the OIDs of the so created triggers in *deleteTrigOid and
11798 * *updateTrigOid.
11799 */
11800 static void
11805 {
11807 ObjectAddress trigAddress;
11809 /*
11810 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
11811 * DELETE action on the referenced table.
11812 */
11827 {
11857 }
11866 /* Make changes-so-far visible */
11869 /*
11870 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
11871 * UPDATE action on the referenced table.
11872 */
11887 {
11917 }
11925 }
11927 /*
11928 * createForeignKeyCheckTriggers
11929 * Create the referencing-side "check" triggers that implement a foreign
11930 * key.
11931 *
11932 * Returns the OIDs of the so created triggers in *insertTrigOid and
11933 * *updateTrigOid.
11934 */
11935 static void
11938 Oid indexOid,
11941 {
11948 }
11950 /*
11951 * ALTER TABLE DROP CONSTRAINT
11952 *
11953 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
11954 */
11955 static void
11957 DropBehavior behavior,
11960 {
11963 Relation conrel;
11964 Form_pg_constraint con;
11965 SysScanDesc scan;
11967 HeapTuple tuple;
11972 /* At top level, permission check was done in ATPrepCmd, else do it */
11978 /*
11979 * Find and drop the target constraint
11980 */
11982 Anum_pg_constraint_conrelid,
11986 Anum_pg_constraint_contypid,
11990 Anum_pg_constraint_conname,
11996 /* There can be at most one matching row */
11998 {
11999 ObjectAddress conobj;
12003 /* Don't drop inherited constraints */
12013 /*
12014 * If it's a foreign-key constraint, we'd better lock the referenced
12015 * table and check that that's not in use, just as we've already done
12016 * for the constrained table (else we might, eg, be dropping a trigger
12017 * that has unfired events). But we can/must skip that in the
12018 * self-referential case.
12019 */
12022 {
12023 Relation frel;
12025 /* Must match lock taken by RemoveTriggerById: */
12029 }
12031 /*
12032 * Perform the actual constraint deletion
12033 */
12041 }
12046 {
12048 {
12053 }
12054 else
12055 {
12061 }
12062 }
12064 /*
12065 * For partitioned tables, non-CHECK inherited constraints are dropped via
12066 * the dependency mechanism, so we're done here.
12067 */
12070 {
12073 }
12075 /*
12076 * Propagate to children as appropriate. Unlike most other ALTER
12077 * routines, we have to do this one level of recursion at a time; we can't
12078 * use find_all_inheritors to do it in one pass.
12079 */
12082 else
12085 /*
12086 * For a partitioned table, if partitions exist and we are told not to
12087 * recurse, it's a user error. It doesn't make sense to have a constraint
12088 * be defined only on the parent, especially if it's a partitioned table.
12089 */
12098 {
12100 Relation childrel;
12101 HeapTuple copy_tuple;
12103 /* find_inheritance_children already got lock */
12108 Anum_pg_constraint_conrelid,
12112 Anum_pg_constraint_contypid,
12116 Anum_pg_constraint_conname,
12122 /* There can be at most one matching row */
12127 constrName,
12136 /* Right now only CHECK constraints can be inherited */
12145 {
12146 /*
12147 * If the child constraint has other definition sources, just
12148 * decrement its inheritance count; if not, recurse to delete it.
12149 */
12151 {
12152 /* Time to delete this child constraint, too */
12156 }
12157 else
12158 {
12159 /* Child constraint must survive my deletion */
12163 /* Make update visible */
12165 }
12166 }
12167 else
12168 {
12169 /*
12170 * If we were told to drop ONLY in this table (no recursion), we
12171 * need to mark the inheritors' constraints as locally defined
12172 * rather than inherited.
12173 */
12179 /* Make update visible */
12181 }
12186 }
12189 }
12191 /*
12192 * ALTER COLUMN TYPE
12193 *
12194 * Unlike other subcommand types, we do parse transformation for ALTER COLUMN
12195 * TYPE during phase 1 --- the AlterTableCmd passed in here is already
12196 * transformed (and must be, because we rely on some transformed fields).
12197 *
12198 * The point of this is that the execution of all ALTER COLUMN TYPEs for a
12199 * table will be done "in parallel" during phase 3, so all the USING
12200 * expressions should be parsed assuming the original column types. Also,
12201 * this allows a USING expression to refer to a field that will be dropped.
12202 *
12203 * To make this work safely, AT_PASS_DROP then AT_PASS_ALTER_TYPE must be
12204 * the first two execution steps in phase 2; they must not see the effects
12205 * of any other subcommand types, since the USING expressions are parsed
12206 * against the unmodified table's state.
12207 */
12208 static void
12214 {
12219 HeapTuple tuple;
12220 Form_pg_attribute attTup;
12221 AttrNumber attnum;
12222 Oid targettype;
12223 int32 targettypmod;
12224 Oid targetcollid;
12227 AclResult aclresult;
12235 /* lookup the attribute so we can check inheritance status */
12245 /* Can't alter a system attribute */
12250 colName)));
12252 /*
12253 * Don't alter inherited columns. At outer level, there had better not be
12254 * any inherited definition; when recursing, we assume this was checked at
12255 * the parent level (see below).
12256 */
12261 colName)));
12263 /* Don't alter columns used in the partition key */
12269 errmsg("cannot alter column \"%s\" because it is part of the partition key of relation \"%s\"",
12272 /* Look up the target type */
12279 /* And the collation */
12282 /* make sure datatype is legal for a column */
12289 {
12290 /*
12291 * Set up an expression to transform the old data value to the new
12292 * type. If a USING option was given, use the expression as
12293 * transformed by transformAlterTableStmt, else just take the old
12294 * value and try to coerce it. We do this first so that type
12295 * incompatibility can be detected before we waste effort, and because
12296 * we need the expression to be parsed against the original table row
12297 * type.
12298 */
12300 {
12305 }
12310 COERCION_ASSIGNMENT,
12311 COERCE_IMPLICIT_CAST,
12314 {
12315 /* error text depends on whether USING was specified or not */
12323 else
12328 /* translator: USING is SQL, don't translate it */
12332 targettypmod))));
12333 }
12335 /* Fix collations after all else */
12338 /* Plan the expr now so we can accurately assess the need to rewrite. */
12341 /*
12342 * Add a work queue item to make ATRewriteTable update the column
12343 * contents.
12344 */
12353 }
12361 {
12362 /*
12363 * For relations without storage, do this check now. Regular tables
12364 * will check it later when the table is being rewritten.
12365 */
12367 }
12371 /*
12372 * Recurse manually by queueing a new command for each child, if
12373 * necessary. We cannot apply ATSimpleRecursion here because we need to
12374 * remap attribute numbers in the USING expression, if any.
12375 *
12376 * If we are told not to recurse, there had better not be any child
12377 * tables; else the alter would put them out of step.
12378 */
12380 {
12390 /*
12391 * find_all_inheritors does the recursive search of the inheritance
12392 * hierarchy, so all we have to do is process all of the relids in the
12393 * list that it returns.
12394 */
12396 {
12399 Relation childrel;
12400 HeapTuple childtuple;
12401 Form_pg_attribute childattTup;
12406 /* find_all_inheritors already got lock */
12410 /*
12411 * Verify that the child doesn't have any inherited definitions of
12412 * this column that came from outside this inheritance hierarchy.
12413 * (renameatt makes a similar test, though in a different way
12414 * because of its different recursion mechanism.)
12415 */
12417 colName);
12433 /*
12434 * Remap the attribute numbers. If no USING expression was
12435 * specified, there is no need for this step.
12436 */
12438 {
12442 /* create a copy to scribble on */
12451 attmap,
12459 }
12462 }
12463 }
12469 colName)));
12473 }
12475 /*
12476 * When the data type of a column is changed, a rewrite might not be required
12477 * if the new type is sufficiently identical to the old one, and the USING
12478 * clause isn't trying to insert some other value. It's safe to skip the
12479 * rewrite in these cases:
12480 *
12481 * - the old type is binary coercible to the new type
12482 * - the new type is an unconstrained domain over the old type
12483 * - {NEW,OLD} or {OLD,NEW} is {timestamptz,timestamp} and the timezone is UTC
12484 *
12485 * In the case of a constrained domain, we could get by with scanning the
12486 * table and checking the constraint rather than actually rewriting it, but we
12487 * don't currently try to do that.
12488 */
12489 static bool
12491 {
12495 {
12496 /* only one varno, so no need to check that */
12502 {
12508 }
12510 {
12514 {
12519 else
12524 }
12525 }
12526 else
12528 }
12529 }
12531 /*
12532 * ALTER COLUMN .. SET DATA TYPE
12533 *
12534 * Return the address of the modified column.
12535 */
12536 static ObjectAddress
12539 {
12543 HeapTuple heapTup;
12544 Form_pg_attribute attTup,
12545 attOldTup;
12546 AttrNumber attnum;
12547 HeapTuple typeTuple;
12548 Form_pg_type tform;
12549 Oid targettype;
12550 int32 targettypmod;
12551 Oid targetcollid;
12553 Relation attrelation;
12554 Relation depRel;
12556 SysScanDesc scan;
12557 HeapTuple depTup;
12558 ObjectAddress address;
12560 /*
12561 * Clear all the missing values if we're rewriting the table, since this
12562 * renders them pointless.
12563 */
12565 {
12566 Relation newrel;
12571 /* make sure we don't conflict with later attribute modifications */
12573 }
12577 /* Look up the target column */
12588 /* Check for multiple ALTER TYPE on same column --- can't cope */
12594 colName)));
12596 /* Look up the target type (should not fail, since prep found it) */
12600 /* And the collation */
12603 /*
12604 * If there is a default expression for the column, get it and ensure we
12605 * can coerce it to the new datatype. (We must do this before changing
12606 * the column type, because build_column_default itself will try to
12607 * coerce, and will not issue the error message we want if it fails.)
12608 *
12609 * We remove any implicit coercion steps at the top level of the old
12610 * default expression; this has been agreed to satisfy the principle of
12611 * least surprise. (The conversion to the new column type should act like
12612 * it started from what the user sees as the stored expression, and the
12613 * implicit coercions aren't going to be shown.)
12614 */
12616 {
12623 COERCION_ASSIGNMENT,
12624 COERCE_IMPLICIT_CAST,
12627 {
12633 else
12638 }
12639 }
12640 else
12643 /*
12644 * Find everything that depends on the column (constraints, indexes, etc),
12645 * and record enough information to let us recreate the objects.
12646 *
12647 * The actual recreation does not happen here, but only after we have
12648 * performed all the individual ALTER TYPE operations. We have to save
12649 * the info before executing ALTER TYPE, though, else the deparser will
12650 * get confused.
12651 */
12655 Anum_pg_depend_refclassid,
12659 Anum_pg_depend_refobjid,
12663 Anum_pg_depend_refobjsubid,
12671 {
12673 ObjectAddress foundObject;
12680 {
12682 {
12687 {
12690 }
12692 {
12693 /*
12694 * This must be a SERIAL column's sequence. We need
12695 * not do anything to it.
12696 */
12698 }
12699 else
12700 {
12701 /* Not expecting any other direct dependencies... */
12704 }
12706 }
12714 /* XXX someday see if we can cope with revising views */
12720 colName)));
12725 /*
12726 * A trigger can depend on a column because the column is
12727 * specified as an update target, or because the column is
12728 * used in the trigger's WHEN condition. The first case would
12729 * not require any extra work, but the second case would
12730 * require updating the WHEN expression, which will take a
12731 * significant amount of new code. Since we can't easily tell
12732 * which case applies, we punt for both. FIXME someday.
12733 */
12739 colName)));
12744 /*
12745 * A policy can depend on a column because the column is
12746 * specified in the policy's USING or WITH CHECK qual
12747 * expressions. It might be possible to rewrite and recheck
12748 * the policy expression, but punt for now. It's certainly
12749 * easy enough to remove and recreate the policy; still, FIXME
12750 * someday.
12751 */
12757 colName)));
12761 {
12766 {
12767 /*
12768 * Ignore the column's own default expression, which
12769 * we will deal with below.
12770 */
12772 }
12773 else
12774 {
12775 /*
12776 * This must be a reference from the expression of a
12777 * generated column elsewhere in the same table.
12778 * Changing the type of a column that is used by a
12779 * generated column is not allowed by SQL standard, so
12780 * just punt for now. It might be doable with some
12781 * thinking and effort.
12782 */
12787 colName,
12791 }
12793 }
12797 /*
12798 * Give the extended-stats machinery a chance to fix anything
12799 * that this column type change would break.
12800 */
12839 /*
12840 * We don't expect any of these sorts of objects to depend on
12841 * a column.
12842 */
12847 /*
12848 * There's intentionally no default: case here; we want the
12849 * compiler to warn if a new OCLASS hasn't been handled above.
12850 */
12851 }
12852 }
12856 /*
12857 * Now scan for dependencies of this column on other things. The only
12858 * things we should find are the dependency on the column datatype and
12859 * possibly a collation dependency. Those can be removed.
12860 */
12862 Anum_pg_depend_classid,
12866 Anum_pg_depend_objid,
12870 Anum_pg_depend_objsubid,
12878 {
12880 ObjectAddress foundObject;
12897 }
12903 /*
12904 * Here we go --- change the recorded column type and collation. (Note
12905 * heapTup is a copy of the syscache entry, so okay to scribble on.) First
12906 * fix up the missing value if any.
12907 */
12909 {
12910 Datum missingval;
12913 /* if rewrite is true the missing value should already be cleared */
12916 /* Get the missing value datum */
12918 Anum_pg_attribute_attmissingval,
12922 /* if it's a null array there is nothing to do */
12925 {
12926 /*
12927 * Get the datum out of the array and repack it in a new array
12928 * built with the new type data. We assume that since the table
12929 * doesn't need rewriting, the actual Datum doesn't need to be
12930 * changed, only the array metadata.
12931 */
12938 HeapTuple newTup;
12950 targettype,
12964 }
12965 }
12987 /* Install dependencies on new datatype and collation */
12991 /*
12992 * Drop any pg_statistic entry for the column, since it's now wrong type
12993 */
12999 /*
13000 * Update the default, if present, by brute force --- remove and re-add
13001 * the default. Probably unsafe to take shortcuts, since the new version
13002 * may well have additional dependencies. (It's okay to do this now,
13003 * rather than after other ALTER TYPE commands, since the default won't
13004 * depend on other column types.)
13005 */
13007 {
13008 /*
13009 * If it's a GENERATED default, drop its dependency records, in
13010 * particular its INTERNAL dependency on the column, which would
13011 * otherwise cause dependency.c to refuse to perform the deletion.
13012 */
13014 {
13021 }
13023 /*
13024 * Make updates-so-far visible, particularly the new pg_attribute row
13025 * which will be updated again.
13026 */
13029 /*
13030 * We use RESTRICT here for safety, but at present we do not expect
13031 * anything to depend on the default.
13032 */
13037 }
13042 /* Cleanup */
13046 }
13048 /*
13049 * Subroutine for ATExecAlterColumnType: remember that a replica identity
13050 * needs to be reset.
13051 */
13052 static void
13054 {
13062 }
13064 /*
13065 * Subroutine for ATExecAlterColumnType: remember any clustered index.
13066 */
13067 static void
13069 {
13077 }
13079 /*
13080 * Subroutine for ATExecAlterColumnType: remember that a constraint needs
13081 * to be rebuilt (which we might already know).
13082 */
13083 static void
13085 {
13086 /*
13087 * This de-duplication check is critical for two independent reasons: we
13088 * mustn't try to recreate the same constraint twice, and if a constraint
13089 * depends on more than one column whose type is to be altered, we must
13090 * capture its definition string before applying any of the column type
13091 * changes. ruleutils.c will get confused if we ask again later.
13092 */
13094 {
13095 /* OK, capture the constraint's existing definition string */
13097 Oid indoid;
13100 conoid);
13102 defstring);
13104 /*
13105 * For the index of a constraint, if any, remember if it is used for
13106 * the table's replica identity or if it is a clustered index, so that
13107 * ATPostAlterTypeCleanup() can queue up commands necessary to restore
13108 * those properties.
13109 */
13112 {
13115 }
13116 }
13117 }
13119 /*
13120 * Subroutine for ATExecAlterColumnType: remember that an index needs
13121 * to be rebuilt (which we might already know).
13122 */
13123 static void
13125 {
13126 /*
13127 * This de-duplication check is critical for two independent reasons: we
13128 * mustn't try to recreate the same index twice, and if an index depends
13129 * on more than one column whose type is to be altered, we must capture
13130 * its definition string before applying any of the column type changes.
13131 * ruleutils.c will get confused if we ask again later.
13132 */
13134 {
13135 /*
13136 * Before adding it as an index-to-rebuild, we'd better see if it
13137 * belongs to a constraint, and if so rebuild the constraint instead.
13138 * Typically this check fails, because constraint indexes normally
13139 * have only dependencies on their constraint. But it's possible for
13140 * such an index to also have direct dependencies on table columns,
13141 * for example with a partial exclusion constraint.
13142 */
13146 {
13148 }
13149 else
13150 {
13151 /* OK, capture the index's existing definition string */
13155 indoid);
13157 defstring);
13159 /*
13160 * Remember if this index is used for the table's replica identity
13161 * or if it is a clustered index, so that ATPostAlterTypeCleanup()
13162 * can queue up commands necessary to restore those properties.
13163 */
13166 }
13167 }
13168 }
13170 /*
13171 * Subroutine for ATExecAlterColumnType: remember that a statistics object
13172 * needs to be rebuilt (which we might already know).
13173 */
13174 static void
13176 {
13177 /*
13178 * This de-duplication check is critical for two independent reasons: we
13179 * mustn't try to recreate the same statistics object twice, and if the
13180 * statistics object depends on more than one column whose type is to be
13181 * altered, we must capture its definition string before applying any of
13182 * the type changes. ruleutils.c will get confused if we ask again later.
13183 */
13185 {
13186 /* OK, capture the statistics object's existing definition string */
13190 stxoid);
13192 defstring);
13193 }
13194 }
13196 /*
13197 * Cleanup after we've finished all the ALTER TYPE operations for a
13198 * particular relation. We have to drop and recreate all the indexes
13199 * and constraints that depend on the altered columns. We do the
13200 * actual dropping here, but re-creation is managed by adding work
13201 * queue entries to do those steps later.
13202 */
13203 static void
13205 {
13206 ObjectAddress obj;
13211 /*
13212 * Collect all the constraints and indexes to drop so we can process them
13213 * in a single call. That way we don't have to worry about dependencies
13214 * among them.
13215 */
13218 /*
13219 * Re-parse the index and constraint definitions, and attach them to the
13220 * appropriate work queue entries. We do this before dropping because in
13221 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
13222 * lock on the table the constraint is attached to, and we need to get
13223 * that before reparsing/dropping.
13224 *
13225 * We can't rely on the output of deparsing to tell us which relation to
13226 * operate on, because concurrent activity might have made the name
13227 * resolve differently. Instead, we've got to use the OID of the
13228 * constraint or index we're processing to figure out which relation to
13229 * operate on.
13230 */
13233 {
13235 HeapTuple tup;
13236 Form_pg_constraint con;
13237 Oid relid;
13238 Oid confrelid;
13248 else
13249 {
13250 /* must be a domain constraint */
13254 }
13263 /*
13264 * If the constraint is inherited (only), we don't want to inject a
13265 * new definition here; it'll get recreated when ATAddCheckConstraint
13266 * recurses from adding the parent table's constraint. But we had to
13267 * carry the info this far so that we can drop the constraint below.
13268 */
13272 /*
13273 * When rebuilding an FK constraint that references the table we're
13274 * modifying, we might not yet have any lock on the FK's table, so get
13275 * one now. We'll need AccessExclusiveLock for the DROP CONSTRAINT
13276 * step, so there's no value in asking for anything weaker.
13277 */
13284 }
13287 {
13289 Oid relid;
13298 }
13300 /* add dependencies for new statistics */
13303 {
13305 Oid relid;
13314 }
13316 /*
13317 * Queue up command to restore replica identity index marking
13318 */
13320 {
13329 /* do it after indexes and constraints */
13332 }
13334 /*
13335 * Queue up command to restore marking of index used for cluster.
13336 */
13338 {
13344 /* do it after indexes and constraints */
13347 }
13349 /*
13350 * It should be okay to use DROP_RESTRICT here, since nothing else should
13351 * be depending on these objects.
13352 */
13357 /*
13358 * The objects will get recreated during subsequent passes over the work
13359 * queue.
13360 */
13361 }
13363 /*
13364 * Parse the previously-saved definition string for a constraint, index or
13365 * statistics object against the newly-established column data type(s), and
13366 * queue up the resulting command parsetrees for execution.
13367 *
13368 * This might fail if, for example, you have a WHERE clause that uses an
13369 * operator that's not available for the new column type.
13370 */
13371 static void
13374 {
13378 Relation rel;
13380 /*
13381 * We expect that we will get only ALTER TABLE and CREATE INDEX
13382 * statements. Hence, there is no need to pass them through
13383 * parse_analyze_*() or the rewriter, but instead we need to pass them
13384 * through parse_utilcmd.c to make them ready for execution.
13385 */
13389 {
13397 cmd));
13399 {
13405 cmd,
13411 }
13416 cmd));
13417 else
13419 }
13421 /* Caller should already have acquired whatever lock we need. */
13424 /*
13425 * Attach each generated command to the proper place in the work queue.
13426 * Note this could result in creation of entirely new work-queue entries.
13427 *
13428 * Also note that we have to tweak the command subtypes, because it turns
13429 * out that re-creation of indexes and constraints has to act a bit
13430 * differently from initial creation.
13431 */
13433 {
13440 {
13447 /* keep the index's comment */
13455 }
13457 {
13462 {
13466 {
13468 Oid indoid;
13475 /* keep any comment on the index */
13484 /* recreate any comment on the constraint */
13486 AT_PASS_OLD_INDEX,
13487 oldId,
13488 rel,
13489 NIL,
13491 }
13493 {
13497 /* rewriting neither side of a FK */
13506 /* recreate any comment on the constraint */
13508 AT_PASS_OLD_CONSTR,
13509 oldId,
13510 rel,
13511 NIL,
13513 }
13515 {
13516 /*
13517 * The parser will create AT_SetNotNull subcommands for
13518 * columns of PRIMARY KEY indexes/constraints, but we need
13519 * not do anything with them here, because the columns'
13520 * NOT NULL marks will already have been propagated into
13521 * the new table definition.
13522 */
13523 }
13524 else
13527 }
13528 }
13530 {
13534 {
13543 /* recreate any comment on the constraint */
13545 AT_PASS_OLD_CONSTR,
13546 oldId,
13547 NULL,
13550 }
13551 else
13554 }
13556 {
13560 /* keep the statistics object's comment */
13568 }
13569 else
13572 }
13575 }
13577 /*
13578 * Subroutine for ATPostAlterTypeParse() to recreate any existing comment
13579 * for a table or domain constraint that is being rebuilt.
13580 *
13581 * objid is the OID of the constraint.
13582 * Pass "rel" for a table constraint, or "domname" (domain's qualified name
13583 * as a string list) for a domain constraint.
13584 * (We could dig that info, as well as the conname, out of the pg_constraint
13585 * entry; but callers already have them so might as well pass them.)
13586 */
13587 static void
13591 {
13596 /* Look for comment for object wanted, and leave if none */
13601 /* Build CommentStmt node, copying all input data for safety */
13604 {
13610 }
13611 else
13612 {
13617 }
13620 /* Append it to list of commands */
13625 }
13627 /*
13628 * Subroutine for ATPostAlterTypeParse(). Calls out to CheckIndexCompatible()
13629 * for the real analysis, then mutates the IndexStmt based on that verdict.
13630 */
13631 static void
13633 {
13638 {
13641 /* If it's a partitioned index, there is no storage to share. */
13643 {
13647 }
13649 }
13650 }
13652 /*
13653 * Subroutine for ATPostAlterTypeParse().
13654 *
13655 * Stash the old P-F equality operator into the Constraint node, for possible
13656 * use by ATAddForeignKeyConstraint() in determining whether revalidation of
13657 * this constraint can be skipped.
13658 */
13659 static void
13661 {
13662 HeapTuple tup;
13663 Datum adatum;
13677 Anum_pg_constraint_conpfeqop);
13680 /* test follows the one in ri_FetchConstraintInfo() */
13687 /* stash a List of the operator Oids in our Constraint node */
13692 }
13694 /*
13695 * ALTER COLUMN .. OPTIONS ( ... )
13696 *
13697 * Returns the address of the modified column
13698 */
13699 static ObjectAddress
13703 LOCKMODE lockmode)
13704 {
13705 Relation ftrel;
13706 Relation attrel;
13709 HeapTuple tuple;
13710 HeapTuple newtuple;
13715 Datum datum;
13716 Form_pg_foreign_table fttableform;
13717 Form_pg_attribute atttableform;
13718 AttrNumber attnum;
13719 ObjectAddress address;
13724 /* First, determine FDW validator associated to the foreign table. */
13747 /* Prevent them from altering a system attribute */
13756 /* Initialize buffers for new tuple values */
13761 /* Extract the current options */
13763 tuple,
13764 Anum_pg_attribute_attfdwoptions,
13769 /* Transform the options */
13771 datum,
13772 options,
13777 else
13782 /* Everything looks good - update the tuple */
13802 }
13804 /*
13805 * ALTER TABLE OWNER
13806 *
13807 * recursing is true if we are recursing from a table to its indexes,
13808 * sequences, or toast table. We don't allow the ownership of those things to
13809 * be changed separately from the parent table. Also, we can skip permission
13810 * checks (this is necessary not just an optimization, else we'd fail to
13811 * handle toast tables properly).
13812 *
13813 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
13814 * free-standing composite type.
13815 */
13816 void
13818 {
13819 Relation target_rel;
13820 Relation class_rel;
13821 HeapTuple tuple;
13822 Form_pg_class tuple_class;
13824 /*
13825 * Get exclusive lock till end of transaction on the target table. Use
13826 * relation_open so that we can work on indexes and sequences.
13827 */
13830 /* Get its pg_class tuple, too */
13838 /* Can we change the ownership of this tuple? */
13840 {
13846 /* ok to change owner */
13850 {
13851 /*
13852 * Because ALTER INDEX OWNER used to be allowed, and in fact
13853 * is generated by old versions of pg_dump, we give a warning
13854 * and do nothing rather than erroring out. Also, to avoid
13855 * unnecessary chatter while restoring those old dumps, say
13856 * nothing at all if the command would be a no-op anyway.
13857 */
13864 /* quick hack to exit via the no-op path */
13866 }
13880 {
13881 /* if it's an owned sequence, disallow changing it by itself */
13882 Oid tableId;
13883 int32 colId;
13894 }
13908 /* FALL THRU */
13915 }
13917 /*
13918 * If the new owner is the same as the existing owner, consider the
13919 * command to have succeeded. This is for dump restoration purposes.
13920 */
13922 {
13927 Datum aclDatum;
13929 HeapTuple newtuple;
13931 /* skip permission checks when recursing to index or toast table */
13933 {
13934 /* Superusers can always do it */
13936 {
13938 AclResult aclresult;
13940 /* Otherwise, must be owner of the existing object */
13945 /* Must be able to become new owner */
13948 /* New owner must have CREATE privilege on namespace */
13950 ACL_CREATE);
13954 }
13955 }
13963 /*
13964 * Determine the modified ACL for the new owner. This is only
13965 * necessary when the ACL is non-null.
13966 */
13968 Anum_pg_class_relacl,
13971 {
13976 }
13978 newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
13984 /*
13985 * We must similarly update any per-column ACLs to reflect the new
13986 * owner; for neatness reasons that's split out as a subroutine.
13987 */
13990 newOwnerId);
13992 /*
13993 * Update owner dependency reference, if any. A composite type has
13994 * none, because it's tracked for the pg_type entry instead of here;
13995 * indexes and TOAST tables don't have their own entries either.
13996 */
14002 newOwnerId);
14004 /*
14005 * Also change the ownership of the table's row type, if it has one
14006 */
14010 /*
14011 * If we are operating on a table or materialized view, also change
14012 * the ownership of any indexes and sequences that belong to the
14013 * relation, as well as its toast table (if it has one).
14014 */
14019 {
14023 /* Find all the indexes belonging to this relation */
14026 /* For each index, recursively change its ownership */
14031 }
14033 /* If it has a toast table, recurse to change its ownership */
14038 /* If it has dependent sequences, recurse to change them too */
14040 }
14047 }
14049 /*
14050 * change_owner_fix_column_acls
14051 *
14052 * Helper function for ATExecChangeOwner. Scan the columns of the table
14053 * and fix any non-null column ACLs to reflect the new owner.
14054 */
14055 static void
14057 {
14058 Relation attRelation;
14059 SysScanDesc scan;
14061 HeapTuple attributeTuple;
14065 Anum_pg_attribute_attrelid,
14071 {
14077 Datum aclDatum;
14079 HeapTuple newtuple;
14081 /* Ignore dropped columns */
14086 Anum_pg_attribute_attacl,
14089 /* Null ACLs do not require changes */
14108 }
14111 }
14113 /*
14114 * change_owner_recurse_to_sequences
14115 *
14116 * Helper function for ATExecChangeOwner. Examines pg_depend searching
14117 * for sequences that are dependent on serial columns, and changes their
14118 * ownership.
14119 */
14120 static void
14122 {
14123 Relation depRel;
14124 SysScanDesc scan;
14126 HeapTuple tup;
14128 /*
14129 * SERIAL sequences are those having an auto dependency on one of the
14130 * table's columns (we don't care *which* column, exactly).
14131 */
14135 Anum_pg_depend_refclassid,
14139 Anum_pg_depend_refobjid,
14142 /* we leave refobjsubid unspecified */
14148 {
14150 Relation seqRel;
14152 /* skip dependencies other than auto dependencies on columns */
14159 /* Use relation_open just in case it's an index */
14162 /* skip non-sequence relations */
14164 {
14165 /* No need to keep the lock */
14168 }
14170 /* We don't need to close the sequence while we alter it. */
14173 /* Now we can close it. Keep the lock till end of transaction. */
14175 }
14180 }
14182 /*
14183 * ALTER TABLE CLUSTER ON
14184 *
14185 * The only thing we have to do is to change the indisclustered bits.
14186 *
14187 * Return the address of the new clustering index.
14188 */
14189 static ObjectAddress
14191 {
14192 Oid indexOid;
14193 ObjectAddress address;
14203 /* Check index is valid to cluster on */
14206 /* And do the work */
14213 }
14215 /*
14216 * ALTER TABLE SET WITHOUT CLUSTER
14217 *
14218 * We have to find any indexes on the table that have indisclustered bit
14219 * set and turn it off.
14220 */
14221 static void
14223 {
14225 }
14227 /*
14228 * Preparation phase for SET ACCESS METHOD
14229 *
14230 * Check that access method exists. If it is the same as the table's current
14231 * access method, it is a no-op. Otherwise, a table rewrite is necessary.
14232 */
14233 static void
14235 {
14236 Oid amoid;
14238 /* Check that the table access method exists */
14244 /* Save info for Phase 3 to do the real work */
14247 }
14249 /*
14250 * ALTER TABLE SET TABLESPACE
14251 */
14252 static void
14253 ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, const char *tablespacename, LOCKMODE lockmode)
14254 {
14255 Oid tablespaceId;
14257 /* Check that the tablespace exists */
14260 /* Check permissions except when moving to database's default */
14262 {
14263 AclResult aclresult;
14268 }
14270 /* Save info for Phase 3 to do the real work */
14277 }
14279 /*
14280 * Set, reset, or replace reloptions.
14281 */
14282 static void
14284 LOCKMODE lockmode)
14285 {
14286 Oid relid;
14287 Relation pgclass;
14288 HeapTuple tuple;
14289 HeapTuple newtuple;
14290 Datum datum;
14292 Datum newOptions;
14303 /* Fetch heap tuple */
14310 {
14311 /*
14312 * If we're supposed to replace the reloptions list, we just pretend
14313 * there were none before.
14314 */
14317 }
14318 else
14319 {
14320 /* Get the old reloptions */
14323 }
14325 /* Generate new proposed reloptions (text array) */
14330 /* Validate */
14332 {
14355 }
14357 /* Special-case validation of view options */
14359 {
14366 {
14371 }
14373 /*
14374 * If the check option is specified, look to see if the view is
14375 * actually auto-updatable or not.
14376 */
14378 {
14387 }
14388 }
14390 /*
14391 * All we need do here is update the pg_class row; the new options will be
14392 * propagated into relcaches during post-commit cache inval.
14393 */
14400 else
14416 /* repeat the whole exercise for the toast table, if there's one */
14418 {
14419 Relation toastrel;
14424 /* Fetch heap tuple */
14430 {
14431 /*
14432 * If we're supposed to replace the reloptions list, we just
14433 * pretend there were none before.
14434 */
14437 }
14438 else
14439 {
14440 /* Get the old reloptions */
14443 }
14457 else
14476 }
14479 }
14481 /*
14482 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
14483 * rewriting to be done, so we just want to copy the data as fast as possible.
14484 */
14485 static void
14487 {
14488 Relation rel;
14489 Oid reltoastrelid;
14490 RelFileNumber newrelfilenumber;
14491 RelFileLocator newrlocator;
14495 /*
14496 * Need lock here in case we are recursing to toast table or index
14497 */
14500 /* Check first if relation can be moved to new tablespace */
14502 {
14507 }
14510 /* Fetch the list of indexes on toast relation if necessary */
14512 {
14517 }
14519 /*
14520 * Relfilenumbers are not unique in databases across tablespaces, so we
14521 * need to allocate a new one in the new tablespace.
14522 */
14526 /* Open old and new relation */
14531 /* hand off to AM to actually create new rel storage and copy the data */
14533 {
14535 }
14536 else
14537 {
14540 }
14542 /*
14543 * Update the pg_class row.
14544 *
14545 * NB: This wouldn't work if ATExecSetTableSpace() were allowed to be
14546 * executed on pg_class or its indexes (the above copy wouldn't contain
14547 * the updated pg_class entry), but that's forbidden with
14548 * CheckRelationTableSpaceMove().
14549 */
14558 /* Make sure the reltablespace change is visible */
14561 /* Move associated toast relation and/or indexes, too */
14567 /* Clean up */
14569 }
14571 /*
14572 * Special handling of ALTER TABLE SET TABLESPACE for relations with no
14573 * storage that have an interest in preserving tablespace.
14574 *
14575 * Since these have no storage the tablespace can be updated with a simple
14576 * metadata only operation to update the tablespace.
14577 */
14578 static void
14580 {
14581 /*
14582 * Shouldn't be called on relations having storage; these are processed in
14583 * phase 3.
14584 */
14587 /* check if relation can be moved to its new tablespace */
14589 {
14594 }
14596 /* Update can be done, so change reltablespace */
14601 /* Make sure the reltablespace change is visible */
14603 }
14605 /*
14606 * Alter Table ALL ... SET TABLESPACE
14607 *
14608 * Allows a user to move all objects of some type in a given tablespace in the
14609 * current database to another tablespace. Objects can be chosen based on the
14610 * owner of the object also, to allow users to move only their objects.
14611 * The user must have CREATE rights on the new tablespace, as usual. The main
14612 * permissions handling is done by the lower-level table move function.
14613 *
14614 * All to-be-moved objects are locked first. If NOWAIT is specified and the
14615 * lock can't be acquired then we ereport(ERROR).
14616 */
14617 Oid
14619 {
14623 Relation rel;
14624 TableScanDesc scan;
14625 HeapTuple tuple;
14626 Oid orig_tablespaceoid;
14627 Oid new_tablespaceoid;
14630 /* Ensure we were not asked to move something we can't */
14637 /* Get the orig and new tablespace OIDs */
14641 /* Can't move shared relations in to or out of pg_global */
14642 /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
14649 /*
14650 * Must have CREATE rights on the new tablespace, unless it is the
14651 * database default tablespace (which all users implicitly have CREATE
14652 * rights on).
14653 */
14655 {
14656 AclResult aclresult;
14659 ACL_CREATE);
14663 }
14665 /*
14666 * Now that the checks are done, check if we should set either to
14667 * InvalidOid because it is our database's default tablespace.
14668 */
14675 /* no-op */
14679 /*
14680 * Walk the list of objects in the tablespace and move them. This will
14681 * only find objects in our database, of course.
14682 */
14684 Anum_pg_class_reltablespace,
14691 {
14695 /*
14696 * Do not move objects in pg_catalog as part of this, if an admin
14697 * really wishes to do so, they can issue the individual ALTER
14698 * commands directly.
14699 *
14700 * Also, explicitly avoid any shared tables, temp tables, or TOAST
14701 * (TOAST will be moved with the main table).
14702 */
14709 /* Only move the object type requested */
14720 /* Check if we are only moving objects owned by certain roles */
14724 /*
14725 * Handle permissions-checking here since we are locking the tables
14726 * and also to avoid doing a bunch of work only to fail part-way. Note
14727 * that permissions will also be checked by AlterTableInternal().
14728 *
14729 * Caller must be considered an owner on the table to move it.
14730 */
14742 else
14745 /* Add to our list of objects to move */
14747 }
14759 /* Everything is locked, loop through and move all of the relations. */
14761 {
14771 /* OID is set by AlterTableInternal */
14774 }
14777 }
14779 static void
14781 {
14782 SMgrRelation dstrel;
14786 /*
14787 * Since we copy the file directly without looking at the shared buffers,
14788 * we'd better first flush out any pages of the source relation that are
14789 * in shared buffers. We assume no new changes will be made while we are
14790 * holding exclusive lock on the rel.
14791 */
14794 /*
14795 * Create and copy all forks of the relation, and schedule unlinking of
14796 * old physical files.
14797 *
14798 * NOTE: any conflict in relfilenumber value will be caught in
14799 * RelationCreateStorage().
14800 */
14803 /* copy main fork */
14807 /* copy those extra forks that exist */
14810 {
14812 {
14815 /*
14816 * WAL log creation if the relation is persistent, or this is the
14817 * init fork of an unlogged relation.
14818 */
14825 }
14826 }
14828 /* drop old relation, and close new one */
14831 }
14833 /*
14834 * ALTER TABLE ENABLE/DISABLE TRIGGER
14835 *
14836 * We just pass this off to trigger.c.
14837 */
14838 static void
14841 LOCKMODE lockmode)
14842 {
14845 lockmode);
14849 }
14851 /*
14852 * ALTER TABLE ENABLE/DISABLE RULE
14853 *
14854 * We just pass this off to rewriteDefine.c.
14855 */
14856 static void
14859 {
14864 }
14866 /*
14867 * ALTER TABLE INHERIT
14868 *
14869 * Add a parent to the child's parents. This verifies that all the columns and
14870 * check constraints of the parent appear in the child and that they have the
14871 * same data types and expressions.
14872 */
14873 static void
14875 {
14890 }
14892 /*
14893 * Return the address of the new parent relation.
14894 */
14895 static ObjectAddress
14897 {
14898 Relation parent_rel;
14900 ObjectAddress address;
14903 /*
14904 * A self-exclusive lock is needed here. See the similar case in
14905 * MergeAttributes() for a full explanation.
14906 */
14909 /*
14910 * Must be owner of both parent and child -- child was checked by
14911 * ATSimplePermissions call in ATPrepCmd
14912 */
14915 /* Permanent rels cannot inherit from temporary ones */
14923 /* If parent rel is temp, it must belong to this session */
14930 /* Ditto for the child */
14937 /* Prevent partitioned tables from becoming inheritance parents */
14944 /* Likewise for partitions */
14950 /*
14951 * Prevent circularity by seeing if proposed parent inherits from child.
14952 * (In particular, this disallows making a rel inherit from itself.)
14953 *
14954 * This is not completely bulletproof because of race conditions: in
14955 * multi-level inheritance trees, someone else could concurrently be
14956 * making another inheritance link that closes the loop but does not join
14957 * either of the rels we have locked. Preventing that seems to require
14958 * exclusive locks on the entire inheritance tree, which is a cure worse
14959 * than the disease. find_all_inheritors() will cope with circularity
14960 * anyway, so don't sweat it too much.
14961 *
14962 * We use weakest lock we can on child's children, namely AccessShareLock.
14963 */
14975 /*
14976 * If child_rel has row-level triggers with transition tables, we
14977 * currently don't allow it to become an inheritance child. See also
14978 * prohibitions in ATExecAttachPartition() and CreateTrigger().
14979 */
14986 errdetail("ROW triggers with transition tables are not supported in inheritance hierarchies.")));
14988 /* OK to create inheritance */
14994 /* keep our lock on the parent relation until commit */
14998 }
15000 /*
15001 * CreateInheritance
15002 * Catalog manipulation portion of creating inheritance between a child
15003 * table and a parent table.
15004 *
15005 * Common to ATExecAddInherit() and ATExecAttachPartition().
15006 */
15007 static void
15009 {
15010 Relation catalogRelation;
15011 SysScanDesc scan;
15012 ScanKeyData key;
15013 HeapTuple inheritsTuple;
15014 int32 inhseqno;
15016 /* Note: get RowExclusiveLock because we will write pg_inherits below. */
15019 /*
15020 * Check for duplicates in the list of parents, and determine the highest
15021 * inhseqno already present; we'll use the next one for the new parent.
15022 * Also, if proposed child is a partition, it cannot already be
15023 * inheriting.
15024 *
15025 * Note: we do not reject the case where the child already inherits from
15026 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
15027 */
15029 Anum_pg_inherits_inhrelid,
15035 /* inhseqno sequences start at 1 */
15038 {
15049 }
15052 /* Match up the columns and bump attinhcount as needed */
15055 /* Match up the constraints and bump coninhcount as needed */
15058 /*
15059 * OK, it looks valid. Make the catalog entries that show inheritance.
15060 */
15064 catalogRelation,
15066 RELKIND_PARTITIONED_TABLE);
15068 /* Now we're done with pg_inherits */
15070 }
15072 /*
15073 * Obtain the source-text form of the constraint expression for a check
15074 * constraint, given its pg_constraint tuple
15075 */
15078 {
15079 Form_pg_constraint con;
15081 Datum attr;
15082 Datum expr;
15092 }
15094 /*
15095 * Determine whether two check constraints are functionally equivalent
15096 *
15097 * The test we apply is to see whether they reverse-compile to the same
15098 * source string. This insulates us from issues like whether attributes
15099 * have the same physical column numbers in parent and child relations.
15100 */
15101 static bool
15103 {
15112 else
15114 }
15116 /*
15117 * Check columns in child table match up with columns in parent, and increment
15118 * their attinhcount.
15119 *
15120 * Called by CreateInheritance
15121 *
15122 * Currently all parent columns must be found in child. Missing columns are an
15123 * error. One day we might consider creating new columns like CREATE TABLE
15124 * does. However, that is widely unpopular --- in the common use case of
15125 * partitioned tables it's a foot-gun.
15126 *
15127 * The data type must match exactly. If the parent column is NOT NULL then
15128 * the child must be as well. Defaults are not compared, however.
15129 */
15130 static void
15132 {
15133 Relation attrrel;
15134 AttrNumber parent_attno;
15136 TupleDesc tupleDesc;
15137 HeapTuple tuple;
15145 /* If parent_rel is a partitioned table, child_rel must be a partition */
15150 {
15155 /* Ignore dropped columns in the parent. */
15159 /* Find same column in child (matching on column name). */
15161 attributeName);
15163 {
15164 /* Check they are same type, typmod, and collation */
15173 attributeName)));
15180 attributeName)));
15182 /*
15183 * Check child doesn't discard NOT NULL property. (Other
15184 * constraints are checked elsewhere.)
15185 */
15190 attributeName)));
15192 /*
15193 * Child column must be generated if and only if parent column is.
15194 */
15199 attributeName)));
15204 attributeName)));
15206 /*
15207 * OK, bump the child column's inheritance count. (If we fail
15208 * later on, this change will just roll back.)
15209 */
15216 /*
15217 * In case of partitions, we must enforce that value of attislocal
15218 * is same in all partitions. (Note: there are only inherited
15219 * attributes in partitions)
15220 */
15222 {
15225 }
15229 }
15230 else
15231 {
15235 attributeName)));
15236 }
15237 }
15240 }
15242 /*
15243 * Check constraints in child table match up with constraints in parent,
15244 * and increment their coninhcount.
15245 *
15246 * Constraints that are marked ONLY in the parent are ignored.
15247 *
15248 * Called by CreateInheritance
15249 *
15250 * Currently all constraints in parent must be present in the child. One day we
15251 * may consider adding new constraints like CREATE TABLE does.
15252 *
15253 * XXX This is O(N^2) which may be an issue with tables with hundreds of
15254 * constraints. As long as tables have more like 10 constraints it shouldn't be
15255 * a problem though. Even 100 constraints ought not be the end of the world.
15256 *
15257 * XXX See MergeWithExistingConstraint too if you change this code.
15258 */
15259 static void
15261 {
15262 Relation catalog_relation;
15263 TupleDesc tuple_desc;
15264 SysScanDesc parent_scan;
15265 ScanKeyData parent_key;
15266 HeapTuple parent_tuple;
15272 /* If parent_rel is a partitioned table, child_rel must be a partition */
15276 /* Outer loop scans through the parent's constraint definitions */
15278 Anum_pg_constraint_conrelid,
15285 {
15287 SysScanDesc child_scan;
15288 ScanKeyData child_key;
15289 HeapTuple child_tuple;
15295 /* if the parent's constraint is marked NO INHERIT, it's not inherited */
15299 /* Search for a child constraint matching this one */
15301 Anum_pg_constraint_conrelid,
15308 {
15310 HeapTuple child_copy;
15326 /* If the child constraint is "no inherit" then cannot merge */
15334 /*
15335 * If the child constraint is "not valid" then cannot merge with a
15336 * valid parent constraint
15337 */
15345 /*
15346 * OK, bump the child constraint's inheritance count. (If we fail
15347 * later on, this change will just roll back.)
15348 */
15357 /*
15358 * In case of partitions, an inherited constraint must be
15359 * inherited only once since it cannot have multiple parents and
15360 * it is never considered local.
15361 */
15363 {
15366 }
15373 }
15382 }
15386 }
15388 /*
15389 * ALTER TABLE NO INHERIT
15390 *
15391 * Return value is the address of the relation that is no longer parent.
15392 */
15393 static ObjectAddress
15395 {
15396 ObjectAddress address;
15397 Relation parent_rel;
15404 /*
15405 * AccessShareLock on the parent is probably enough, seeing that DROP
15406 * TABLE doesn't lock parent tables at all. We need some lock since we'll
15407 * be inspecting the parent's schema.
15408 */
15411 /*
15412 * We don't bother to check ownership of the parent table --- ownership of
15413 * the child is presumed enough rights.
15414 */
15416 /* Off to RemoveInheritance() where most of the work happens */
15422 /* keep our lock on the parent relation until commit */
15426 }
15428 /*
15429 * MarkInheritDetached
15430 *
15431 * Set inhdetachpending for a partition, for ATExecDetachPartition
15432 * in concurrent mode. While at it, verify that no other partition is
15433 * already pending detach.
15434 */
15435 static void
15437 {
15438 Relation catalogRelation;
15439 SysScanDesc scan;
15440 ScanKeyData key;
15441 HeapTuple inheritsTuple;
15446 /*
15447 * Find pg_inherits entries by inhparent. (We need to scan them all in
15448 * order to verify that no other partition is pending detach.)
15449 */
15452 Anum_pg_inherits_inhparent,
15459 {
15460 Form_pg_inherits inhForm;
15470 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
15473 {
15474 HeapTuple newtup;
15481 newtup);
15484 /* keep looking, to ensure we catch others pending detach */
15485 }
15486 }
15488 /* Done */
15498 }
15500 /*
15501 * RemoveInheritance
15502 *
15503 * Drop a parent from the child's parents. This just adjusts the attinhcount
15504 * and attislocal of the columns and removes the pg_inherit and pg_depend
15505 * entries. expect_detached is passed down to DeleteInheritsTuple, q.v..
15506 *
15507 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
15508 * up attislocal stays true, which means if a child is ever removed from a
15509 * parent then its columns will never be automatically dropped which may
15510 * surprise. But at least we'll never surprise by dropping columns someone
15511 * isn't expecting to be dropped which would actually mean data loss.
15512 *
15513 * coninhcount and conislocal for inherited constraints are adjusted in
15514 * exactly the same way.
15515 *
15516 * Common to ATExecDropInherit() and ATExecDetachPartition().
15517 */
15518 static void
15520 {
15521 Relation catalogRelation;
15522 SysScanDesc scan;
15524 HeapTuple attributeTuple,
15525 constraintTuple;
15530 /* If parent_rel is a partitioned table, child_rel must be a partition */
15536 expect_detached,
15539 {
15546 else
15552 }
15554 /*
15555 * Search through child columns looking for ones matching parent rel
15556 */
15559 Anum_pg_attribute_attrelid,
15565 {
15568 /* Ignore if dropped or not inherited */
15576 {
15577 /* Decrement inhcount and possibly set islocal to true */
15587 }
15588 }
15592 /*
15593 * Likewise, find inherited check constraints and disinherit them. To do
15594 * this, we first need a list of the names of the parent's check
15595 * constraints. (We cheat a bit by only checking for name matches,
15596 * assuming that the expressions will match.)
15597 */
15600 Anum_pg_constraint_conrelid,
15609 {
15614 }
15618 /* Now scan the child's constraints */
15620 Anum_pg_constraint_conrelid,
15627 {
15637 {
15639 {
15642 }
15643 }
15646 {
15647 /* Decrement inhcount and possibly set islocal to true */
15661 }
15662 }
15668 RelationRelationId,
15672 /*
15673 * Post alter hook of this inherits. Since object_access_hook doesn't take
15674 * multiple object identifiers, we relay oid of parent relation using
15675 * auxiliary_id argument.
15676 */
15680 }
15682 /*
15683 * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE
15684 * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or
15685 * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will
15686 * be TypeRelationId). There's no convenient way to do this, so go trawling
15687 * through pg_depend.
15688 */
15689 static void
15691 DependencyType deptype)
15692 {
15693 Relation catalogRelation;
15694 SysScanDesc scan;
15696 HeapTuple depTuple;
15701 Anum_pg_depend_classid,
15705 Anum_pg_depend_objid,
15709 Anum_pg_depend_objsubid,
15717 {
15725 }
15729 }
15731 /*
15732 * ALTER TABLE OF
15733 *
15734 * Attach a table to a composite type, as though it had been created with CREATE
15735 * TABLE OF. All attname, atttypid, atttypmod and attcollation must match. The
15736 * subject table must not have inheritance parents. These restrictions ensure
15737 * that you cannot create a configuration impossible with CREATE TABLE OF alone.
15738 *
15739 * The address of the type is returned.
15740 */
15741 static ObjectAddress
15743 {
15745 Type typetuple;
15746 Form_pg_type typeform;
15748 Relation inheritsRelation,
15749 relationRelation;
15750 SysScanDesc scan;
15751 ScanKeyData key;
15752 AttrNumber table_attno,
15753 type_attno;
15754 TupleDesc typeTupleDesc,
15755 tableTupleDesc;
15756 ObjectAddress tableobj,
15757 typeobj;
15758 HeapTuple classtuple;
15760 /* Validate the type. */
15766 /* Fail if the table has any inheritance parents. */
15769 Anum_pg_inherits_inhrelid,
15781 /*
15782 * Check the tuple descriptors for compatibility. Unlike inheritance, we
15783 * require that the order also match. However, attnotnull need not match.
15784 */
15789 {
15790 Form_pg_attribute type_attr,
15791 table_attr;
15795 /* Get the next non-dropped type attribute. */
15801 /* Get the next non-dropped table attribute. */
15802 do
15803 {
15808 type_attname)));
15810 table_attno++;
15814 /* Compare name. */
15821 /* Compare type. */
15829 }
15832 /* Any remaining columns at the end of the table had better be dropped. */
15834 {
15843 }
15845 /* If the table was already typed, drop the existing dependency. */
15848 DEPENDENCY_NORMAL);
15850 /* Record a dependency on the new type. */
15859 /* Update pg_class.reloftype */
15875 }
15877 /*
15878 * ALTER TABLE NOT OF
15879 *
15880 * Detach a typed table from its originating type. Just clear reloftype and
15881 * remove the dependency.
15882 */
15883 static void
15885 {
15887 Relation relationRelation;
15888 HeapTuple tuple;
15896 /*
15897 * We don't bother to check ownership of the type --- ownership of the
15898 * table is presumed enough rights. No lock required on the type, either.
15899 */
15902 DEPENDENCY_NORMAL);
15904 /* Clear pg_class.reloftype */
15916 }
15918 /*
15919 * relation_mark_replica_identity: Update a table's replica identity
15920 *
15921 * Iff ri_type = REPLICA_IDENTITY_INDEX, indexOid must be the Oid of a suitable
15922 * index. Otherwise, it must be InvalidOid.
15923 *
15924 * Caller had better hold an exclusive lock on the relation, as the results
15925 * of running two of these concurrently wouldn't be pretty.
15926 */
15927 static void
15930 {
15931 Relation pg_index;
15932 Relation pg_class;
15933 HeapTuple pg_class_tuple;
15934 HeapTuple pg_index_tuple;
15935 Form_pg_class pg_class_form;
15936 Form_pg_index pg_index_form;
15939 /*
15940 * Check whether relreplident has changed, and update it if so.
15941 */
15950 {
15953 }
15957 /*
15958 * Update the per-index indisreplident flags correctly.
15959 */
15962 {
15973 {
15974 /* Set the bit if not already set. */
15976 {
15979 }
15980 }
15981 else
15982 {
15983 /* Unset the bit if set. */
15985 {
15988 }
15989 }
15992 {
15997 /*
15998 * Invalidate the relcache for the table, so that after we commit
15999 * all sessions will refresh the table's replica identity index
16000 * before attempting any UPDATE or DELETE on the table. (If we
16001 * changed the table's pg_class row above, then a relcache inval
16002 * is already queued due to that; but we might not have.)
16003 */
16005 }
16007 }
16010 }
16012 /*
16013 * ALTER TABLE <name> REPLICA IDENTITY ...
16014 */
16015 static void
16017 {
16018 Oid indexOid;
16019 Relation indexRel;
16023 {
16026 }
16028 {
16031 }
16033 {
16036 }
16038 {
16040 }
16041 else
16044 /* Check that the index exists */
16054 /* Check that the index is on the relation we're altering. */
16062 /* The AM must support uniqueness, and the index must in fact be unique. */
16069 /* Deferred indexes are not guaranteed to be always unique. */
16075 /* Expression indexes aren't supported. */
16081 /* Predicate indexes aren't supported. */
16088 /* Check index for nullable columns. */
16090 {
16092 Form_pg_attribute attr;
16094 /*
16095 * Reject any other system columns. (Going forward, we'll disallow
16096 * indexes containing such columns in the first place, but they might
16097 * exist in older branches.)
16098 */
16102 errmsg("index \"%s\" cannot be used as replica identity because column %d is a system column",
16112 }
16114 /* This index is suitable for use as a replica identity. Mark it. */
16118 }
16120 /*
16121 * ALTER TABLE ENABLE/DISABLE ROW LEVEL SECURITY
16122 */
16123 static void
16125 {
16126 Relation pg_class;
16127 Oid relid;
16128 HeapTuple tuple;
16132 /* Pull the record for this relation and update it */
16148 }
16150 /*
16151 * ALTER TABLE FORCE/NO FORCE ROW LEVEL SECURITY
16152 */
16153 static void
16155 {
16156 Relation pg_class;
16157 Oid relid;
16158 HeapTuple tuple;
16177 }
16179 /*
16180 * ALTER FOREIGN TABLE <name> OPTIONS (...)
16181 */
16182 static void
16184 {
16185 Relation ftrel;
16188 HeapTuple tuple;
16193 Datum datum;
16194 Form_pg_foreign_table tableform;
16216 /* Extract the current options */
16218 tuple,
16219 Anum_pg_foreign_table_ftoptions,
16224 /* Transform the options */
16226 datum,
16227 options,
16232 else
16237 /* Everything looks good - update the tuple */
16244 /*
16245 * Invalidate relcache so that all sessions will refresh any cached plans
16246 * that might depend on the old options.
16247 */
16256 }
16258 /*
16259 * ALTER TABLE ALTER COLUMN SET COMPRESSION
16260 *
16261 * Return value is the address of the modified column
16262 */
16263 static ObjectAddress
16267 LOCKMODE lockmode)
16268 {
16269 Relation attrel;
16270 HeapTuple tuple;
16271 Form_pg_attribute atttableform;
16272 AttrNumber attnum;
16275 ObjectAddress address;
16281 /* copy the cache entry so we can scribble on it below */
16289 /* prevent them from altering a system attribute */
16297 /*
16298 * Check that column type is compressible, then get the attribute
16299 * compression method code
16300 */
16303 /* update pg_attribute entry */
16309 attnum);
16311 /*
16312 * Apply the change to indexes as well (only for simple index columns,
16313 * matching behavior of index.c ConstructTupleDescriptor()).
16314 */
16318 lockmode);
16324 /* make changes visible */
16330 }
16333 /*
16334 * Preparation phase for SET LOGGED/UNLOGGED
16335 *
16336 * This verifies that we're not trying to change a temp table. Also,
16337 * existing foreign key constraints are checked to avoid ending up with
16338 * permanent tables referencing unlogged tables.
16339 *
16340 * Return value is false if the operation is a no-op (in which case the
16341 * checks are skipped), otherwise true.
16342 */
16343 static bool
16345 {
16346 Relation pg_constraint;
16347 HeapTuple tuple;
16348 SysScanDesc scan;
16351 /*
16352 * Disallow changing status for a temp table. Also verify whether we can
16353 * get away with doing nothing; in such cases we don't need to run the
16354 * checks below, either.
16355 */
16357 {
16367 /* nothing to do */
16372 /* nothing to do */
16375 }
16377 /*
16378 * Check that the table is not part of any publication when changing to
16379 * UNLOGGED, as UNLOGGED tables can't be published.
16380 */
16389 /*
16390 * Check existing foreign key constraints to preserve the invariant that
16391 * permanent tables cannot reference unlogged ones. Self-referencing
16392 * foreign keys can safely be ignored.
16393 */
16396 /*
16397 * Scan conrelid if changing to permanent, else confrelid. This also
16398 * determines whether a useful index exists.
16399 */
16402 Anum_pg_constraint_confrelid,
16410 {
16414 {
16415 Oid foreignrelid;
16416 Relation foreignrel;
16418 /* the opposite end of what we used as scankey */
16421 /* ignore if self-referencing */
16428 {
16436 }
16437 else
16438 {
16446 }
16449 }
16450 }
16457 }
16459 /*
16460 * Execute ALTER TABLE SET SCHEMA
16461 */
16462 ObjectAddress
16464 {
16465 Relation rel;
16466 Oid relid;
16467 Oid oldNspOid;
16468 Oid nspOid;
16471 ObjectAddress myself;
16475 RangeVarCallbackForAlterRelation,
16479 {
16484 }
16490 /* If it's an owned sequence, disallow moving it by itself. */
16492 {
16493 Oid tableId;
16494 int32 colId;
16504 }
16506 /* Get and lock schema OID and check its permissions. */
16510 /* common checks on switching namespaces */
16522 /* close rel, but keep lock until commit */
16526 }
16528 /*
16529 * The guts of relocating a table or materialized view to another namespace:
16530 * besides moving the relation itself, its dependent objects are relocated to
16531 * the new schema.
16532 */
16533 void
16536 {
16537 Relation classRel;
16541 /* OK, modify the pg_class row and pg_depend entry */
16547 /* Fix the table's row type too, if it has one */
16552 /* Fix other dependent stuff */
16556 {
16562 }
16565 }
16567 /*
16568 * The guts of relocating a relation to another namespace: fix the pg_class
16569 * entry, and the pg_depend entry if any. Caller must already have
16570 * opened and write-locked pg_class.
16571 */
16572 void
16577 {
16578 HeapTuple classTup;
16579 Form_pg_class classForm;
16580 ObjectAddress thisobj;
16594 /*
16595 * If the object has already been moved, don't move it again. If it's
16596 * already in the right place, don't move it, but still fire the object
16597 * access hook.
16598 */
16601 {
16602 /* check for duplicate name (more friendly than unique-index failure) */
16611 /* classTup is a copy, so OK to scribble on */
16616 /* Update dependency on schema if caller said so */
16619 relOid,
16620 NamespaceRelationId,
16621 oldNspOid,
16625 }
16627 {
16631 }
16634 }
16636 /*
16637 * Move all indexes for the specified relation to another namespace.
16638 *
16639 * Note: we assume adequate permission checking was done by the caller,
16640 * and that the caller has a suitable lock on the owning relation.
16641 */
16642 static void
16645 {
16652 {
16654 ObjectAddress thisobj;
16660 /*
16661 * Note: currently, the index will not have its own dependency on the
16662 * namespace, so we don't need to do changeDependencyFor(). There's no
16663 * row type in pg_type, either.
16664 *
16665 * XXX this objsMoved test may be pointless -- surely we have a single
16666 * dependency link from a relation to each index?
16667 */
16669 {
16674 }
16675 }
16678 }
16680 /*
16681 * Move all identity and SERIAL-column sequences of the specified relation to another
16682 * namespace.
16683 *
16684 * Note: we assume adequate permission checking was done by the caller,
16685 * and that the caller has a suitable lock on the owning relation.
16686 */
16687 static void
16690 LOCKMODE lockmode)
16691 {
16692 Relation depRel;
16693 SysScanDesc scan;
16695 HeapTuple tup;
16697 /*
16698 * SERIAL sequences are those having an auto dependency on one of the
16699 * table's columns (we don't care *which* column, exactly).
16700 */
16704 Anum_pg_depend_refclassid,
16708 Anum_pg_depend_refobjid,
16711 /* we leave refobjsubid unspecified */
16717 {
16719 Relation seqRel;
16721 /* skip dependencies other than auto dependencies on columns */
16728 /* Use relation_open just in case it's an index */
16731 /* skip non-sequence relations */
16733 {
16734 /* No need to keep the lock */
16737 }
16739 /* Fix the pg_class and pg_depend entries */
16744 /*
16745 * Sequences used to have entries in pg_type, but no longer do. If we
16746 * ever re-instate that, we'll need to move the pg_type entry to the
16747 * new namespace, too (using AlterTypeNamespaceInternal).
16748 */
16751 /* Now we can close it. Keep the lock till end of transaction. */
16753 }
16758 }
16761 /*
16762 * This code supports
16763 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
16764 *
16765 * Because we only support this for TEMP tables, it's sufficient to remember
16766 * the state in a backend-local data structure.
16767 */
16769 /*
16770 * Register a newly-created relation's ON COMMIT action.
16771 */
16772 void
16774 {
16776 MemoryContext oldcxt;
16778 /*
16779 * We needn't bother registering the relation unless there is an ON COMMIT
16780 * action we need to take.
16781 */
16793 /*
16794 * We use lcons() here so that ON COMMIT actions are processed in reverse
16795 * order of registration. That might not be essential but it seems
16796 * reasonable.
16797 */
16801 }
16803 /*
16804 * Unregister any ON COMMIT action when a relation is deleted.
16805 *
16806 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
16807 */
16808 void
16810 {
16814 {
16818 {
16821 }
16822 }
16823 }
16825 /*
16826 * Perform ON COMMIT actions.
16827 *
16828 * This is invoked just before actually committing, since it's possible
16829 * to encounter errors.
16830 */
16831 void
16833 {
16839 {
16842 /* Ignore entry if already dropped in this xact */
16847 {
16850 /* Do nothing (there shouldn't be such entries, actually) */
16854 /*
16855 * If this transaction hasn't accessed any temporary
16856 * relations, we can skip truncating ON COMMIT DELETE ROWS
16857 * tables, as they must still be empty.
16858 */
16865 }
16866 }
16868 /*
16869 * Truncate relations before dropping so that all dependencies between
16870 * relations are removed after they are worked on. Doing it like this
16871 * might be a waste as it is possible that a relation being truncated will
16872 * be dropped anyway due to its parent being dropped, but this makes the
16873 * code more robust because of not having to re-check that the relation
16874 * exists at truncation time.
16875 */
16880 {
16884 {
16885 ObjectAddress object;
16894 }
16896 /*
16897 * Since this is an automatic drop, rather than one directly initiated
16898 * by the user, we pass the PERFORM_DELETION_INTERNAL flag.
16899 */
16903 #ifdef USE_ASSERT_CHECKING
16905 /*
16906 * Note that table deletion will call remove_on_commit_action, so the
16907 * entry should get marked as deleted.
16908 */
16910 {
16917 }
16918 #endif
16919 }
16920 }
16922 /*
16923 * Post-commit or post-abort cleanup for ON COMMIT management.
16924 *
16925 * All we do here is remove no-longer-needed OnCommitItem entries.
16926 *
16927 * During commit, remove entries that were deleted during this transaction;
16928 * during abort, remove those created during this transaction.
16929 */
16930 void
16932 {
16936 {
16941 {
16942 /* cur_item must be removed */
16945 }
16946 else
16947 {
16948 /* cur_item must be preserved */
16951 }
16952 }
16953 }
16955 /*
16956 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
16957 *
16958 * During subabort, we can immediately remove entries created during this
16959 * subtransaction. During subcommit, just relabel entries marked during
16960 * this subtransaction as being the parent's responsibility.
16961 */
16962 void
16964 SubTransactionId parentSubid)
16965 {
16969 {
16973 {
16974 /* cur_item must be removed */
16977 }
16978 else
16979 {
16980 /* cur_item must be preserved */
16985 }
16986 }
16987 }
16989 /*
16990 * This is intended as a callback for RangeVarGetRelidExtended(). It allows
16991 * the relation to be locked only if (1) it's a plain or partitioned table,
16992 * materialized view, or TOAST table and (2) the current user is the owner (or
16993 * the superuser). This meets the permission-checking needs of CLUSTER,
16994 * REINDEX TABLE, and REFRESH MATERIALIZED VIEW; we expose it here so that it
16995 * can be used by all.
16996 */
16997 void
17000 {
17003 /* Nothing to do if the relation was not found. */
17007 /*
17008 * If the relation does exist, check whether it's an index. But note that
17009 * the relation might have been dropped between the time we did the name
17010 * lookup and now. In that case, there's nothing to do.
17011 */
17021 /* Check permissions */
17023 aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relId)), relation->relname);
17024 }
17026 /*
17027 * Callback to RangeVarGetRelidExtended() for TRUNCATE processing.
17028 */
17029 static void
17032 {
17033 HeapTuple tuple;
17035 /* Nothing to do if the relation was not found. */
17047 }
17049 /*
17050 * Callback for RangeVarGetRelidExtended(). Checks that the current user is
17051 * the owner of the relation, or superuser.
17052 */
17053 void
17056 {
17057 HeapTuple tuple;
17059 /* Nothing to do if the relation was not found. */
17079 }
17081 /*
17082 * Common RangeVarGetRelid callback for rename, set schema, and alter table
17083 * processing.
17084 */
17085 static void
17088 {
17090 ObjectType reltype;
17091 HeapTuple tuple;
17092 Form_pg_class classform;
17093 AclResult aclresult;
17102 /* Must own relation. */
17106 /* No system table modifications unless explicitly allowed. */
17113 /*
17114 * Extract the specified relation type from the statement parse tree.
17115 *
17116 * Also, for ALTER .. RENAME, check permissions: the user must (still)
17117 * have CREATE rights on the containing namespace.
17118 */
17120 {
17127 }
17133 else
17134 {
17137 }
17139 /*
17140 * For compatibility with prior releases, we allow ALTER TABLE to be used
17141 * with most other types of relations (but not composite types). We allow
17142 * similar flexibility for ALTER INDEX in the case of RENAME, but not
17143 * otherwise. Otherwise, the user must select the correct form of the
17144 * command for the relation at issue.
17145 */
17172 relkind != RELKIND_PARTITIONED_INDEX
17178 /*
17179 * Don't allow ALTER TABLE on composite types. We want people to use ALTER
17180 * TYPE for that.
17181 */
17188 /*
17189 * Don't allow ALTER TABLE .. SET SCHEMA on relations that can't be moved
17190 * to a different schema, such as indexes and TOAST tables.
17191 */
17193 {
17212 }
17215 }
17217 /*
17218 * Transform any expressions present in the partition key
17219 *
17220 * Returns a transformed PartitionSpec.
17221 */
17224 {
17236 /* Check valid number of columns for strategy */
17243 /*
17244 * Create a dummy ParseState and insert the target relation as its sole
17245 * rangetable entry. We need a ParseState for transformExpr.
17246 */
17252 /* take care of any partition expressions */
17254 {
17258 {
17259 /* Copy, to avoid scribbling on the input */
17262 /* Now do parse transformation of the expression */
17264 EXPR_KIND_PARTITION_EXPRESSION);
17266 /* we have to fix its collations too */
17268 }
17271 }
17274 }
17276 /*
17277 * Compute per-partition-column information from a list of PartitionElems.
17278 * Expressions in the PartitionElems must be parse-analyzed already.
17279 */
17280 static void
17281 ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
17283 PartitionStrategy strategy)
17284 {
17287 Oid am_oid;
17291 {
17293 Oid atttype;
17294 Oid attcollation;
17297 {
17298 /* Simple attribute reference */
17299 HeapTuple atttuple;
17300 Form_pg_attribute attform;
17319 /*
17320 * Generated columns cannot work: They are computed after BEFORE
17321 * triggers, but partition routing is done before all triggers.
17322 */
17335 }
17336 else
17337 {
17338 /* Expression */
17346 /*
17347 * The expression must be of a storable type (e.g., not RECORD).
17348 * The test is the same as for whether a table column is of a safe
17349 * type (which is why we needn't check for the non-expression
17350 * case).
17351 */
17357 /*
17358 * Strip any top-level COLLATE clause. This ensures that we treat
17359 * "x COLLATE y" and "(x COLLATE y)" alike.
17360 */
17366 {
17367 /*
17368 * User wrote "(column)" or "(column COLLATE something)".
17369 * Treat it like simple attribute anyway.
17370 */
17372 }
17373 else
17374 {
17381 /*
17382 * Try to simplify the expression before checking for
17383 * mutability. The main practical value of doing it in this
17384 * order is that an inline-able SQL-language function will be
17385 * accepted if its expansion is immutable, whether or not the
17386 * function itself is marked immutable.
17387 *
17388 * Note that expression_planner does not change the passed in
17389 * expression destructively and we have already saved the
17390 * expression to be stored into the catalog above.
17391 */
17394 /*
17395 * Partition expression cannot contain mutable functions,
17396 * because a given row must always map to the same partition
17397 * as long as there is no change in the partition boundary
17398 * structure.
17399 */
17405 /*
17406 * transformPartitionSpec() should have already rejected
17407 * subqueries, aggregates, window functions, and SRFs, based
17408 * on the EXPR_KIND_ for partition expressions.
17409 */
17411 /*
17412 * Cannot allow system column references, since that would
17413 * make partition routing impossible: their values won't be
17414 * known yet when we need to do that.
17415 */
17418 {
17420 expr_attrs))
17424 }
17426 /*
17427 * Generated columns cannot work: They are computed after
17428 * BEFORE triggers, but partition routing is done before all
17429 * triggers.
17430 */
17433 {
17444 }
17446 /*
17447 * While it is not exactly *wrong* for a partition expression
17448 * to be a constant, it seems better to reject such keys.
17449 */
17454 }
17455 }
17457 /*
17458 * Apply collation override if any
17459 */
17463 /*
17464 * Check we have a collation iff it's a collatable type. The only
17465 * expected failures here are (1) COLLATE applied to a noncollatable
17466 * type, or (2) partition expression had an unresolved collation. But
17467 * we might as well code this to be a complete consistency check.
17468 */
17470 {
17476 }
17477 else
17478 {
17484 }
17488 /*
17489 * Identify the appropriate operator class. For list and range
17490 * partitioning, we use a btree operator class; hash partitioning uses
17491 * a hash operator class.
17492 */
17495 else
17499 {
17503 {
17509 errhint("You must specify a hash operator class or define a default hash operator class for the data type.")));
17510 else
17515 errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
17516 }
17517 }
17518 else
17520 atttype,
17522 am_oid);
17524 attn++;
17525 }
17526 }
17528 /*
17529 * PartConstraintImpliedByRelConstraint
17530 * Do scanrel's existing constraints imply the partition constraint?
17531 *
17532 * "Existing constraints" include its check constraints and column-level
17533 * NOT NULL constraints. partConstraint describes the partition constraint,
17534 * in implicit-AND form.
17535 */
17536 bool
17539 {
17545 {
17549 {
17553 {
17557 i,
17564 /*
17565 * argisrow=false is correct even for a composite column,
17566 * because attnotnull does not represent a SQL-spec IS NOT
17567 * NULL test in such a case, just IS DISTINCT FROM NULL.
17568 */
17572 }
17573 }
17574 }
17577 }
17579 /*
17580 * ConstraintImpliedByRelConstraint
17581 * Do scanrel's existing constraints imply the given constraint?
17582 *
17583 * testConstraint is the constraint to validate. provenConstraint is a
17584 * caller-provided list of conditions which this function may assume
17585 * to be true. Both provenConstraint and testConstraint must be in
17586 * implicit-AND form, must only contain immutable clauses, and must
17587 * contain only Vars with varno = 1.
17588 */
17589 bool
17590 ConstraintImpliedByRelConstraint(Relation scanrel, List *testConstraint, List *provenConstraint)
17591 {
17595 i;
17599 {
17602 /*
17603 * If this constraint hasn't been fully validated yet, we must ignore
17604 * it here.
17605 */
17611 /*
17612 * Run each expression through const-simplification and
17613 * canonicalization. It is necessary, because we will be comparing it
17614 * to similarly-processed partition constraint expressions, and may
17615 * fail to detect valid matches without this.
17616 */
17622 }
17624 /*
17625 * Try to make the proof. Since we are comparing CHECK constraints, we
17626 * need to use weak implication, i.e., we assume existConstraint is
17627 * not-false and try to prove the same for testConstraint.
17628 *
17629 * Note that predicate_implied_by assumes its first argument is known
17630 * immutable. That should always be true for both NOT NULL and partition
17631 * constraints, so we don't test it here.
17632 */
17634 }
17636 /*
17637 * QueuePartitionConstraintValidation
17638 *
17639 * Add an entry to wqueue to have the given partition constraint validated by
17640 * Phase 3, for the given relation, and all its children.
17641 *
17642 * We first verify whether the given constraint is implied by pre-existing
17643 * relation constraints; if it is, there's no need to scan the table to
17644 * validate, so don't queue in that case.
17645 */
17646 static void
17650 {
17651 /*
17652 * Based on the table's existing constraints, determine whether or not we
17653 * may skip scanning the table.
17654 */
17656 {
17661 else
17663 (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
17666 }
17668 /*
17669 * Constraints proved insufficient. For plain relations, queue a
17670 * validation item now; for partitioned tables, recurse to process each
17671 * partition.
17672 */
17674 {
17677 /* Grab a work queue entry. */
17682 }
17684 {
17689 {
17690 Relation part_rel;
17693 /*
17694 * This is the minimum lock we need to prevent deadlocks.
17695 */
17698 /*
17699 * Adjust the constraint for scanrel so that it matches this
17700 * partition's attribute numbers.
17701 */
17702 thisPartConstraint =
17707 thisPartConstraint,
17708 validate_default);
17710 }
17711 }
17712 }
17714 /*
17715 * ALTER TABLE <name> ATTACH PARTITION <partition-name> FOR VALUES
17716 *
17717 * Return the address of the newly attached partition.
17718 */
17719 static ObjectAddress
17722 {
17723 Relation attachrel,
17724 catalog;
17727 SysScanDesc scan;
17728 ScanKeyData skey;
17729 AttrNumber attno;
17731 TupleDesc tupleDesc;
17732 ObjectAddress address;
17734 Oid defaultPartOid;
17740 /*
17741 * We must lock the default partition if one exists, because attaching a
17742 * new partition will change its partition constraint.
17743 */
17744 defaultPartOid =
17751 /*
17752 * XXX I think it'd be a good idea to grab locks on all tables referenced
17753 * by FKs at this point also.
17754 */
17756 /*
17757 * Must be owner of both parent and source table -- parent was checked by
17758 * ATSimplePermissions call in ATPrepCmd
17759 */
17762 /* A partition can only have one parent */
17774 /*
17775 * Table being attached should not already be part of inheritance; either
17776 * as a child table...
17777 */
17780 Anum_pg_inherits_inhrelid,
17791 /* ...or as a parent table (except the case when it is partitioned) */
17793 Anum_pg_inherits_inhparent,
17806 /*
17807 * Prevent circularity by seeing if rel is a partition of attachrel. (In
17808 * particular, this disallows making a rel a partition of itself.)
17809 *
17810 * We do that by checking if rel is a member of the list of attachrel's
17811 * partitions provided the latter is partitioned at all. We want to avoid
17812 * having to construct this list again, so we request the strongest lock
17813 * on all partitions. We need the strongest lock, because we may decide
17814 * to scan them if we find out that the table being attached (or its leaf
17815 * partitions) may contain rows that violate the partition constraint. If
17816 * the table has a constraint that would prevent such rows, which by
17817 * definition is present in all the partitions, we need not scan the
17818 * table, nor its partitions. But we cannot risk a deadlock by taking a
17819 * weaker lock now and the stronger one only when needed.
17820 */
17831 /* If the parent is permanent, so must be all of its partitions. */
17839 /* Temp parent cannot have a partition that is itself not a temp */
17847 /* If the parent is temp, it must belong to this session */
17854 /* Ditto for the partition */
17861 /* Check if there are any columns in attachrel that aren't in the parent */
17865 {
17869 /* Ignore dropped */
17873 /* Try to find the column in parent (matching on column name) */
17883 }
17885 /*
17886 * If child_rel has row-level triggers with transition tables, we
17887 * currently don't allow it to become a partition. See also prohibitions
17888 * in ATExecAddInherit() and CreateTrigger().
17889 */
17898 /*
17899 * Check that the new partition's bound is valid and does not overlap any
17900 * of existing partitions of the parent - note that it does not return on
17901 * error.
17902 */
17906 /* OK to create inheritance. Rest of the checks performed there */
17909 /* Update the pg_class entry. */
17912 /* Ensure there exists a correct set of indexes in the partition. */
17915 /* and triggers */
17918 /*
17919 * Clone foreign key constraints. Callee is responsible for setting up
17920 * for phase 3 constraint verification.
17921 */
17924 /*
17925 * Generate partition constraint from the partition bound specification.
17926 * If the parent itself is a partition, make sure to include its
17927 * constraint as well.
17928 */
17933 /* Skip validation if there are no constraints to validate. */
17935 {
17936 /*
17937 * Run the partition quals through const-simplification similar to
17938 * check constraints. We skip canonicalize_qual, though, because
17939 * partition quals should be in canonical form already.
17940 */
17941 partConstraint =
17945 /* XXX this sure looks wrong */
17948 /*
17949 * Adjust the generated constraint to match this partition's attribute
17950 * numbers.
17951 */
17953 rel);
17955 /* Validate partition constraints against the table being attached. */
17958 }
17960 /*
17961 * If we're attaching a partition other than the default partition and a
17962 * default one exists, then that partition's partition constraint changes,
17963 * so add an entry to the work queue to validate it, too. (We must not do
17964 * this when the partition being attached is the default one; we already
17965 * did it above!)
17966 */
17968 {
17969 Relation defaultrel;
17974 /* we already hold a lock on the default partition */
17976 defPartConstraint =
17979 /*
17980 * Map the Vars in the constraint expression from rel's attnos to
17981 * defaultrel's.
17982 */
17983 defPartConstraint =
17989 /* keep our lock until commit. */
17991 }
17995 /*
17996 * If the partition we just attached is partitioned itself, invalidate
17997 * relcache for all descendent partitions too to ensure that their
17998 * rd_partcheck expression trees are rebuilt; partitions already locked at
17999 * the beginning of this function.
18000 */
18002 {
18006 {
18008 }
18009 }
18011 /* keep our lock until commit */
18015 }
18017 /*
18018 * AttachPartitionEnsureIndexes
18019 * subroutine for ATExecAttachPartition to create/match indexes
18020 *
18021 * Enforce the indexing rule for partitioned tables during ALTER TABLE / ATTACH
18022 * PARTITION: every partition must have an index attached to each index on the
18023 * partitioned table.
18024 */
18025 static void
18027 {
18034 MemoryContext cxt;
18035 MemoryContext oldcxt;
18039 ALLOCSET_DEFAULT_SIZES);
18047 /* Build arrays of all existing indexes and their IndexInfos */
18050 {
18055 i++;
18056 }
18058 /*
18059 * If we're attaching a foreign table, we must fail if any of the indexes
18060 * is a constraint index; otherwise, there's nothing to do here. Do this
18061 * before starting work, to avoid wasting the effort of building a few
18062 * non-unique indexes before coming across a unique one.
18063 */
18065 {
18067 {
18081 }
18084 }
18086 /*
18087 * For each index on the partitioned table, find a matching one in the
18088 * partition-to-be; if one is not found, create one.
18089 */
18091 {
18097 Oid constraintOid;
18099 /*
18100 * Ignore indexes in the partitioned table other than partitioned
18101 * indexes.
18102 */
18104 {
18107 }
18109 /* construct an indexinfo to compare existing indexes against */
18116 /*
18117 * Scan the list of existing indexes in the partition-to-be, and mark
18118 * the first matching, valid, unattached one we find, if any, as
18119 * partition of the parent index. If we find one, we're done.
18120 */
18122 {
18126 /* does this index have a parent? if so, can't use it */
18130 /* If this index is invalid, can't use it */
18139 attmap))
18140 {
18141 /*
18142 * If this index is being created in the parent because of a
18143 * constraint, then the child needs to have a constraint also,
18144 * so look for one. If there is no such constraint, this
18145 * index is no good, so keep looking.
18146 */
18148 {
18149 cldConstrOid =
18151 cldIdxId);
18152 /* no dice */
18155 }
18157 /* bingo. */
18166 }
18167 }
18169 /*
18170 * If no suitable index was found in the partition-to-be, create one
18171 * now.
18172 */
18174 {
18176 Oid conOid;
18183 conOid,
18186 }
18189 }
18191 out:
18192 /* Clean up. */
18197 }
18199 /*
18200 * CloneRowTriggersToPartition
18201 * subroutine for ATExecAttachPartition/DefineRelation to create row
18202 * triggers on partitions
18203 */
18204 static void
18206 {
18207 Relation pg_trigger;
18208 ScanKeyData key;
18209 SysScanDesc scan;
18210 HeapTuple tuple;
18211 MemoryContext perTupCxt;
18223 {
18227 Datum value;
18231 MemoryContext oldcxt;
18233 /*
18234 * Ignore statement-level triggers; those are not cloned.
18235 */
18239 /*
18240 * Don't clone internal triggers, because the constraint cloning code
18241 * will.
18242 */
18246 /*
18247 * Complain if we find an unexpected trigger type.
18248 */
18254 /* Use short-lived context for CREATE TRIGGER */
18257 /*
18258 * If there is a WHEN clause, generate a 'cooked' version of it that's
18259 * appropriate for the partition.
18260 */
18264 {
18270 }
18272 /*
18273 * If there is a column list, transform it to a list of column names.
18274 * Note we don't need to map this list in any way ...
18275 */
18277 {
18281 {
18282 Form_pg_attribute col;
18288 }
18289 }
18291 /* Reconstruct trigger arguments list. */
18293 {
18305 {
18308 }
18309 }
18335 }
18341 }
18343 /*
18344 * ALTER TABLE DETACH PARTITION
18345 *
18346 * Return the address of the relation that is no longer a partition of rel.
18347 *
18348 * If concurrent mode is requested, we run in two transactions. A side-
18349 * effect is that this command cannot run in a multi-part ALTER TABLE.
18350 * Currently, that's enforced by the grammar.
18351 *
18352 * The strategy for concurrency is to first modify the partition's
18353 * pg_inherit catalog row to make it visible to everyone that the
18354 * partition is detached, lock the partition against writes, and commit
18355 * the transaction; anyone who requests the partition descriptor from
18356 * that point onwards has to ignore such a partition. In a second
18357 * transaction, we wait until all transactions that could have seen the
18358 * partition as attached are gone, then we remove the rest of partition
18359 * metadata (pg_inherits and pg_class.relpartbounds).
18360 */
18361 static ObjectAddress
18364 {
18365 Relation partRel;
18366 ObjectAddress address;
18367 Oid defaultPartOid;
18369 /*
18370 * We must lock the default partition, because detaching this partition
18371 * will change its partition constraint.
18372 */
18373 defaultPartOid =
18376 {
18377 /*
18378 * Concurrent detaching when a default partition exists is not
18379 * supported. The main problem is that the default partition
18380 * constraint would change. And there's a definitional problem: what
18381 * should happen to the tuples that are being inserted that belong to
18382 * the partition being detached? Putting them on the partition being
18383 * detached would be wrong, since they'd become "lost" after the
18384 * detaching completes but we cannot put them in the default partition
18385 * either until we alter its partition constraint.
18386 *
18387 * I think we could solve this problem if we effected the constraint
18388 * change before committing the first transaction. But the lock would
18389 * have to remain AEL and it would cause concurrent query planning to
18390 * be blocked, so changing it that way would be even worse.
18391 */
18397 }
18399 /*
18400 * In concurrent mode, the partition is locked with share-update-exclusive
18401 * in the first transaction. This allows concurrent transactions to be
18402 * doing DML to the partition.
18403 */
18405 AccessExclusiveLock);
18407 /*
18408 * Check inheritance conditions and either delete the pg_inherits row (in
18409 * non-concurrent mode) or just set the inhdetachpending flag.
18410 */
18413 else
18416 /*
18417 * Ensure that foreign keys still hold after this detach. This keeps
18418 * locks on the referencing tables, which prevents concurrent transactions
18419 * from adding rows that we wouldn't see. For this to work in concurrent
18420 * mode, it is critical that the partition appears as no longer attached
18421 * for the RI queries as soon as the first transaction commits.
18422 */
18425 /*
18426 * Concurrent mode has to work harder; first we add a new constraint to
18427 * the partition that matches the partition constraint. Then we close our
18428 * existing transaction, and in a new one wait for all processes to catch
18429 * up on the catalog updates we've done so far; at that point we can
18430 * complete the operation.
18431 */
18433 {
18434 Oid partrelid,
18435 parentrelid;
18436 LOCKTAG tag;
18440 /*
18441 * Add a new constraint to the partition being detached, which
18442 * supplants the partition constraint (unless there is one already).
18443 */
18446 /*
18447 * We're almost done now; the only traces that remain are the
18448 * pg_inherits tuple and the partition's relpartbounds. Before we can
18449 * remove those, we need to wait until all transactions that know that
18450 * this is a partition are gone.
18451 */
18453 /*
18454 * Remember relation OIDs to re-acquire them later; and relation names
18455 * too, for error messages if something is dropped in between.
18456 */
18464 /* Invalidate relcache entries for the parent -- must be before close */
18471 /* Make updated catalog entry visible */
18477 /*
18478 * Now wait. This ensures that all queries that were planned
18479 * including the partition are finished before we remove the rest of
18480 * catalog entries. We don't need or indeed want to acquire this
18481 * lock, though -- that would block later queries.
18482 *
18483 * We don't need to concern ourselves with waiting for a lock on the
18484 * partition itself, since we will acquire AccessExclusiveLock below.
18485 */
18489 /*
18490 * Now acquire locks in both relations again. Note they may have been
18491 * removed in the meantime, so care is required.
18492 */
18496 /* If the relations aren't there, something bad happened; bail out */
18498 {
18501 partrelname);
18505 parentrelname)));
18506 }
18513 }
18515 /* Do the final part of detaching */
18520 /* keep our lock until commit */
18524 }
18526 /*
18527 * Second part of ALTER TABLE .. DETACH.
18528 *
18529 * This is separate so that it can be run independently when the second
18530 * transaction of the concurrent algorithm fails (crash or abort).
18531 */
18532 static void
18534 Oid defaultPartOid)
18535 {
18536 Relation classRel;
18543 HeapTuple tuple,
18544 newtuple;
18548 {
18549 /*
18550 * We can remove the pg_inherits row now. (In the non-concurrent case,
18551 * this was already done).
18552 */
18554 }
18556 /* Drop any triggers that were cloned on creation/attach. */
18559 /*
18560 * Detach any foreign keys that are inherited. This includes creating
18561 * additional action triggers.
18562 */
18567 {
18569 HeapTuple contup;
18570 Form_pg_constraint conform;
18572 Oid insertTriggerOid,
18573 updateTriggerOid;
18580 /* consider only the inherited foreign keys */
18583 {
18586 }
18588 /* unset conparentid and adjust conislocal, coninhcount, etc. */
18591 /*
18592 * Also, look up the partition's "check" triggers corresponding to the
18593 * constraint being detached and detach them from the parent triggers.
18594 */
18605 /*
18606 * Make the action triggers on the referenced relation. When this was
18607 * a partition the action triggers pointed to the parent rel (they
18608 * still do), but now we need separate ones of our own.
18609 */
18635 }
18640 /*
18641 * Any sub-constraints that are in the referenced-side of a larger
18642 * constraint have to be removed. This partition is no longer part of the
18643 * key space of the constraint.
18644 */
18646 {
18648 ObjectAddress constraint;
18652 constrOid,
18653 ConstraintRelationId,
18654 DEPENDENCY_INTERNAL);
18659 }
18661 /* Now we can detach indexes */
18664 {
18666 Relation idx;
18667 Oid constrOid;
18678 /* If there's a constraint associated with the index, detach it too */
18680 idxid);
18685 }
18687 /* Update pg_class tuple */
18696 /* Clear relpartbound and reset relispartition */
18712 {
18713 /*
18714 * If the relation being detached is the default partition itself,
18715 * remove it from the parent's pg_partitioned_table entry.
18716 *
18717 * If not, we must invalidate default partition's relcache entry, as
18718 * in StorePartitionBound: its partition constraint depends on every
18719 * other partition's partition constraint.
18720 */
18723 else
18725 }
18727 /*
18728 * Invalidate the parent's relcache so that the partition is no longer
18729 * included in its partition descriptor.
18730 */
18733 /*
18734 * If the partition we just detached is partitioned itself, invalidate
18735 * relcache for all descendent partitions too to ensure that their
18736 * rd_partcheck expression trees are rebuilt; must lock partitions before
18737 * doing so, using the same lockmode as what partRel has been locked with
18738 * by the caller.
18739 */
18741 {
18747 {
18749 }
18750 }
18751 }
18753 /*
18754 * ALTER TABLE ... DETACH PARTITION ... FINALIZE
18755 *
18756 * To use when a DETACH PARTITION command previously did not run to
18757 * completion; this completes the detaching process.
18758 */
18759 static ObjectAddress
18761 {
18762 Relation partRel;
18763 ObjectAddress address;
18768 /*
18769 * Wait until existing snapshots are gone. This is important if the
18770 * second transaction of DETACH PARTITION CONCURRENTLY is canceled: the
18771 * user could immediately run DETACH FINALIZE without actually waiting for
18772 * existing transactions. We must not complete the detach action until
18773 * all such queries are complete (otherwise we would present them with an
18774 * inconsistent view of catalogs).
18775 */
18785 }
18787 /*
18788 * DetachAddConstraintIfNeeded
18789 * Subroutine for ATExecDetachPartition. Create a constraint that
18790 * takes the place of the partition constraint, but avoid creating
18791 * a dupe if an constraint already exists which implies the needed
18792 * constraint.
18793 */
18794 static void
18796 {
18802 /*
18803 * Avoid adding a new constraint if the needed constraint is implied by an
18804 * existing constraint
18805 */
18807 {
18813 /* Add constraint on partition, equivalent to the partition constraint */
18823 /* It's a re-add, since it nominally already exists */
18826 }
18827 }
18829 /*
18830 * DropClonedTriggersFromPartition
18831 * subroutine for ATExecDetachPartition to remove any triggers that were
18832 * cloned to the partition when it was created-as-partition or attached.
18833 * This undoes what CloneRowTriggersToPartition did.
18834 */
18835 static void
18837 {
18838 ScanKeyData skey;
18839 SysScanDesc scan;
18840 HeapTuple trigtup;
18841 Relation tgrel;
18846 /*
18847 * Scan pg_trigger to search for all triggers on this rel.
18848 */
18855 {
18857 ObjectAddress trig;
18859 /* Ignore triggers that weren't cloned */
18863 /*
18864 * Ignore internal triggers that are implementation objects of foreign
18865 * keys, because these will be detached when the foreign keys
18866 * themselves are.
18867 */
18871 /*
18872 * This is ugly, but necessary: remove the dependency markings on the
18873 * trigger so that it can be removed.
18874 */
18876 TriggerRelationId,
18877 DEPENDENCY_PARTITION_PRI);
18879 RelationRelationId,
18880 DEPENDENCY_PARTITION_SEC);
18882 /* remember this trigger to remove it below */
18885 }
18887 /* make the dependency removal visible to the deletion below */
18891 /* done */
18895 }
18897 /*
18898 * Before acquiring lock on an index, acquire the same lock on the owning
18899 * table.
18900 */
18901 struct AttachIndexCallbackState
18902 {
18903 Oid partitionOid;
18904 Oid parentTblOid;
18906 };
18908 static void
18911 {
18913 Form_pg_class classform;
18914 HeapTuple tuple;
18919 {
18922 }
18924 /*
18925 * If we previously locked some other heap, and the name we're looking up
18926 * no longer refers to an index on that relation, release the now-useless
18927 * lock. XXX maybe we should do *after* we verify whether the index does
18928 * not actually belong to the same relation ...
18929 */
18931 {
18934 }
18936 /* Didn't find a relation, so no need for locking or permission checks. */
18951 /*
18952 * Since we need only examine the heap's tupledesc, an access share lock
18953 * on it (preventing any DDL) is sufficient.
18954 */
18957 }
18959 /*
18960 * ALTER INDEX i1 ATTACH PARTITION i2
18961 */
18962 static ObjectAddress
18964 {
18965 Relation partIdx;
18966 Relation partTbl;
18967 Relation parentTbl;
18968 ObjectAddress address;
18969 Oid partIdxId;
18970 Oid currParent;
18973 /*
18974 * We need to obtain lock on the index 'name' to modify it, but we also
18975 * need to read its owning table's tuple descriptor -- so we need to lock
18976 * both. To avoid deadlocks, obtain lock on the table before doing so on
18977 * the index. Furthermore, we need to examine the parent table of the
18978 * partition, so lock that one too.
18979 */
18983 partIdxId =
18985 RangeVarCallbackForAttachIndex,
18987 /* Not there? */
18993 /* no deadlock risk: RangeVarGetRelidExtended already acquired the lock */
18996 /* we already hold locks on both tables, so this is safe: */
19002 /* Silently do nothing if already in the right state */
19006 {
19012 PartitionDesc partDesc;
19013 Oid constraintOid,
19016 /*
19017 * If this partition already has an index attached, refuse the
19018 * operation.
19019 */
19031 /* Make sure it indexes a partition of the other index's table */
19035 {
19037 {
19040 }
19041 }
19052 /* Ensure the indexes are compatible */
19063 attmap))
19071 /*
19072 * If there is a constraint in the parent, make sure there is one in
19073 * the child too.
19074 */
19079 {
19081 partIdxId);
19088 errdetail("The index \"%s\" belongs to a constraint in table \"%s\" but no constraint exists for index \"%s\".",
19092 }
19094 /* All good -- do it */
19103 }
19106 /* keep these locks till commit */
19111 }
19113 /*
19114 * Verify whether the given partition already contains an index attached
19115 * to the given partitioned index. If so, raise an error.
19116 */
19117 static void
19119 {
19120 Oid existingIdx;
19132 }
19134 /*
19135 * Verify whether the set of attached partition indexes to a parent index on
19136 * a partitioned table is complete. If it is, mark the parent index valid.
19137 *
19138 * This should be called each time a partition index is attached.
19139 */
19140 static void
19142 {
19143 Relation inheritsRel;
19144 SysScanDesc scan;
19145 ScanKeyData key;
19147 HeapTuple inhTup;
19152 /*
19153 * Scan pg_inherits for this parent index. Count each valid index we find
19154 * (verifying the pg_index entry for each), and if we reach the total
19155 * amount we expect, we can mark this parent index as valid.
19156 */
19164 {
19166 HeapTuple indTup;
19167 Form_pg_index indexForm;
19177 }
19179 /* Done with pg_inherits */
19183 /*
19184 * If we found as many inherited indexes as the partitioned table has
19185 * partitions, we're good; update pg_index to set indisvalid.
19186 */
19188 {
19189 Relation idxRel;
19190 HeapTuple indTup;
19191 Form_pg_index indexForm;
19208 }
19210 /*
19211 * If this index is in turn a partition of a larger index, validating it
19212 * might cause the parent to become valid also. Try that.
19213 */
19215 {
19216 Oid parentIdxId,
19217 parentTblId;
19218 Relation parentIdx,
19219 parentTbl;
19221 /* make sure we see the validation we just did */
19234 }
19235 }
19237 /*
19238 * Return an OID list of constraints that reference the given relation
19239 * that are marked as having a parent constraints.
19240 */
19243 {
19244 Relation pg_constraint;
19245 HeapTuple tuple;
19246 SysScanDesc scan;
19250 /*
19251 * If no indexes, or no columns are referenceable by FKs, we can avoid the
19252 * scan.
19253 */
19256 INDEX_ATTR_BITMAP_KEY)))
19259 /* Search for constraints referencing this table */
19268 /* XXX This is a seqscan, as we don't have a usable index */
19271 {
19274 /*
19275 * We only need to process constraints that are part of larger ones.
19276 */
19281 }
19287 }
19289 /*
19290 * During DETACH PARTITION, verify that any foreign keys pointing to the
19291 * partitioned table would not become invalid. An error is raised if any
19292 * referenced values exist.
19293 */
19294 static void
19296 {
19303 {
19305 HeapTuple tuple;
19306 Form_pg_constraint constrForm;
19307 Relation rel;
19318 /* prevent data changes into the referencing table until commit */
19330 /* we needn't fill in remaining fields */
19337 }
19338 }
19340 /*
19341 * resolve column compression specification to compression method.
19342 */
19343 static char
19345 {
19351 /*
19352 * To specify a nondefault method, the column data type must be toastable.
19353 * Note this says nothing about whether the column's attstorage setting
19354 * permits compression; we intentionally allow attstorage and
19355 * attcompression to be independent. But with a non-toastable type,
19356 * attstorage could not be set to a value that would permit compression.
19357 *
19358 * We don't actually need to enforce this, since nothing bad would happen
19359 * if attcompression were non-default; it would never be consulted. But
19360 * it seems more user-friendly to complain about a certainly-useless
19361 * attempt to set the property.
19362 */
19376 }
19378 /*
19379 * resolve column storage specification
19380 */
19381 static char
19383 {
19396 else
19400 storagemode)));
19402 /*
19403 * safety check: do not allow toasted storage modes unless column datatype
19404 * is TOAST-aware.
19405 */
19413 }