| blob | 416a98e7cef017156fbcfb07701b0d94b636ed4f |
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)
369 LOCKMODE lockmode);
374 LOCKMODE lockmode);
420 LOCKMODE lockmode,
423 DropBehavior behavior);
437 LOCKMODE lockmode);
457 static ObjectAddress ATExecDropIdentity(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
458 static void ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode);
459 static ObjectAddress ATExecDropExpression(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
470 DropBehavior behavior,
483 LOCKMODE lockmode);
491 LOCKMODE lockmode);
495 LOCKMODE lockmode);
514 Relation partitionRel);
517 Relation partRel);
520 Oid indexOid,
525 Oid indexOid,
529 Oid partRelid,
533 Oid parentInsTrigger,
534 Oid parentUpdTrigger,
535 Relation trigrel);
551 LOCKMODE lockmode);
564 LOCKMODE lockmode);
580 LOCKMODE lockmode);
589 AlterTableType operation,
590 LOCKMODE lockmode);
593 LOCKMODE lockmode);
600 DependencyType deptype);
618 static void ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
620 PartitionStrategy strategy);
646 Relation partitionTbl);
654 /* ----------------------------------------------------------------
655 * DefineRelation
656 * Creates a new relation.
657 *
658 * stmt carries parsetree information from an ordinary CREATE TABLE statement.
659 * The other arguments are used to extend the behavior for other cases:
660 * relkind: relkind to assign to the new relation
661 * ownerId: if not InvalidOid, use this as the new relation's owner.
662 * typaddress: if not null, it's set to the pg_type entry's address.
663 * queryString: for error reporting
664 *
665 * Note that permissions checks are done against current user regardless of
666 * ownerId. A nonzero ownerId is used when someone is creating a relation
667 * "on behalf of" someone else, so we still want to see that the current user
668 * has permissions to do it.
669 *
670 * If successful, returns the address of the new relation.
671 * ----------------------------------------------------------------
672 */
673 ObjectAddress
676 {
678 Oid namespaceId;
679 Oid relationId;
680 Oid tablespaceId;
681 Relation rel;
682 TupleDesc descriptor;
689 Datum reloptions;
691 AttrNumber attnum;
694 Oid ofTypeId;
695 ObjectAddress address;
696 LOCKMODE parentLockmode;
700 /*
701 * Truncate relname to appropriate length (probably a waste of time, as
702 * parser should have done this already).
703 */
706 /*
707 * Check consistency of arguments
708 */
716 {
722 }
723 else
726 /*
727 * Look up the namespace in which we are supposed to create the relation,
728 * check we have permission to create there, lock it against concurrent
729 * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
730 * namespace is selected.
731 */
732 namespaceId =
735 /*
736 * Security check: disallow creating temp tables from security-restricted
737 * code. This is needed because calling code might not expect untrusted
738 * tables to appear in pg_temp at the front of its search path.
739 */
746 /*
747 * Determine the lockmode to use when scanning parents. A self-exclusive
748 * lock is needed here.
749 *
750 * For regular inheritance, if two backends attempt to add children to the
751 * same parent simultaneously, and that parent has no pre-existing
752 * children, then both will attempt to update the parent's relhassubclass
753 * field, leading to a "tuple concurrently updated" error. Also, this
754 * interlocks against a concurrent ANALYZE on the parent table, which
755 * might otherwise be attempting to clear the parent's relhassubclass
756 * field, if its previous children were recently dropped.
757 *
758 * If the child table is a partition, then we instead grab an exclusive
759 * lock on the parent because its partition descriptor will be changed by
760 * addition of the new partition.
761 */
763 ShareUpdateExclusiveLock);
765 /* Determine the list of OIDs of the parents. */
768 {
770 Oid parentOid;
774 /*
775 * Reject duplications in the list of parents.
776 */
784 }
786 /*
787 * Select tablespace to use: an explicitly indicated one, or (in the case
788 * of a partitioned table) the parent's, if it has one.
789 */
791 {
798 }
800 {
801 /*
802 * For partitions, when no other tablespace is specified, we default
803 * the tablespace to the parent partitioned table's.
804 */
807 }
808 else
811 /* still nothing? use the default */
814 partitioned);
816 /* Check permissions except when using database's default */
818 {
819 AclResult aclresult;
822 ACL_CREATE);
826 }
828 /* In all cases disallow placing user relations in pg_global */
834 /* Identify user ID that will own the table */
838 /*
839 * Parse and validate reloptions, if any.
840 */
845 {
854 }
857 {
858 AclResult aclresult;
865 }
866 else
869 /*
870 * Look up inheritance ancestors and generate relation schema, including
871 * inherited attributes. (Note that stmt->tableElts is destructively
872 * modified by MergeAttributes.)
873 */
880 /*
881 * Create a tuple descriptor from the relation schema. Note that this
882 * deals with column names, types, and in-descriptor NOT NULL flags, but
883 * not default values, NOT NULL or CHECK constraints; we handle those
884 * below.
885 */
888 /*
889 * Find columns with default values and prepare for insertion of the
890 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
891 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
892 * while raw defaults go into a list of RawColumnDefault structs that will
893 * be processed by AddRelationNewConstraints. (We can't deal with raw
894 * expressions until we can do transformExpr.)
895 *
896 * We can set the atthasdef flags now in the tuple descriptor; this just
897 * saves StoreAttrDefault from having to do an immediate update of the
898 * pg_attribute rows.
899 */
905 {
907 Form_pg_attribute attr;
909 attnum++;
913 {
925 }
927 {
942 }
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 */
1254 /*
1255 * Finally, merge the not-null constraints that are declared directly with
1256 * those that come from parent relations (making sure to count inheritance
1257 * appropriately for each), create them, and set the attnotnull flag on
1258 * columns that don't yet have it.
1259 */
1261 old_notnulls);
1267 /*
1268 * Clean up. We keep lock on new relation (although it shouldn't be
1269 * visible to anyone else anyway, until commit).
1270 */
1274 }
1276 /*
1277 * BuildDescForRelation
1278 *
1279 * Given a list of ColumnDef nodes, build a TupleDesc.
1280 *
1281 * Note: tdtypeid will need to be filled in later on.
1282 */
1283 TupleDesc
1285 {
1287 AttrNumber attnum;
1289 TupleDesc desc;
1292 Oid atttypid;
1293 int32 atttypmod;
1294 Oid attcollation;
1297 /*
1298 * allocate a new tuple descriptor
1299 */
1307 {
1309 AclResult aclresult;
1310 Form_pg_attribute att;
1312 /*
1313 * for each entry in the list, get the name and type information from
1314 * the list and have TupleDescInitEntry fill in the attribute
1315 * information we need.
1316 */
1317 attnum++;
1337 attname)));
1343 /* Override TupleDescInitEntry's settings as requested */
1346 /* Fill in additional stuff not handled by TupleDescInitEntry */
1358 }
1361 {
1372 }
1373 else
1374 {
1376 }
1379 }
1381 /*
1382 * Emit the right error or warning message for a "DROP" command issued on a
1383 * non-existent relation
1384 */
1385 static void
1387 {
1392 {
1394 {
1398 }
1399 else
1400 {
1404 }
1406 }
1409 {
1411 {
1413 {
1417 }
1418 else
1419 {
1422 }
1423 }
1424 }
1427 }
1429 /*
1430 * Emit the right error message for a "DROP" command issued on a
1431 * relation of the wrong type
1432 */
1433 static void
1435 {
1447 /* wrongkind could be something we don't have in our table... */
1453 }
1455 /*
1456 * RemoveRelations
1457 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW,
1458 * DROP MATERIALIZED VIEW, DROP FOREIGN TABLE
1459 */
1460 void
1462 {
1469 /* DROP CONCURRENTLY uses a weaker lock, and has some restrictions */
1471 {
1472 /*
1473 * Note that for temporary relations this lock may get upgraded later
1474 * on, but as no other session can access a temporary relation, this
1475 * is actually fine.
1476 */
1487 }
1489 /*
1490 * First we identify all the relations, then we delete them in a single
1491 * performMultipleDeletions() call. This is to avoid unwanted DROP
1492 * RESTRICT errors if one of the relations depends on another.
1493 */
1495 /* Determine required relkind */
1497 {
1527 }
1529 /* Lock and validate each relation; build a list of object addresses */
1533 {
1535 Oid relOid;
1536 ObjectAddress obj;
1539 /*
1540 * These next few steps are a great deal like relation_openrv, but we
1541 * don't bother building a relcache entry since we don't need it.
1542 *
1543 * Check for shared-cache-inval messages before trying to access the
1544 * relation. This is needed to cover the case where the name
1545 * identifies a rel that has been dropped and recreated since the
1546 * start of our transaction: if we don't flush the old syscache entry,
1547 * then we'll latch onto that entry and suffer an error later.
1548 */
1551 /* Look up the appropriate relation using namespace search. */
1555 /* We must initialize these fields to show that no locks are held: */
1560 RangeVarCallbackForDropRelation,
1563 /* Not there? */
1565 {
1568 }
1570 /*
1571 * Decide if concurrent mode needs to be used here or not. The
1572 * callback retrieved the rel's persistence for us.
1573 */
1576 {
1580 }
1582 /*
1583 * Concurrent index drop cannot be used with partitioned indexes,
1584 * either.
1585 */
1593 /*
1594 * If we're told to drop a partitioned index, we must acquire lock on
1595 * all the children of its parent partitioned table before proceeding.
1596 * Otherwise we'd try to lock the child index partitions before their
1597 * tables, leading to potential deadlock against other sessions that
1598 * will lock those objects in the other order.
1599 */
1603 NULL);
1605 /* OK, we're ready to delete this one */
1611 }
1616 }
1618 /*
1619 * Before acquiring a table lock, check whether we have sufficient rights.
1620 * In the case of DROP INDEX, also try to lock the table before the index.
1621 * Also, if the table to be dropped is a partition, we try to lock the parent
1622 * first.
1623 */
1624 static void
1627 {
1628 HeapTuple tuple;
1632 Form_pg_class classform;
1633 LOCKMODE heap_lockmode;
1639 /*
1640 * If we previously locked some other index's heap, and the name we're
1641 * looking up no longer refers to that relation, release the now-useless
1642 * lock.
1643 */
1645 {
1648 }
1650 /*
1651 * Similarly, if we previously locked some other partition's heap, and the
1652 * name we're looking up no longer refers to that relation, release the
1653 * now-useless lock.
1654 */
1656 {
1659 }
1661 /* Didn't find a relation, so no need for locking or permission checks. */
1671 /* Pass back some data to save lookups in RemoveRelations */
1675 /*
1676 * Both RELKIND_RELATION and RELKIND_PARTITIONED_TABLE are OBJECT_TABLE,
1677 * but RemoveRelations() can only pass one relkind for a given relation.
1678 * It chooses RELKIND_RELATION for both regular and partitioned tables.
1679 * That means we must be careful before giving the wrong type error when
1680 * the relation is RELKIND_PARTITIONED_TABLE. An equivalent problem
1681 * exists with indexes.
1682 */
1687 else
1694 /* Allow DROP to either table owner or schema owner */
1701 /*
1702 * Check the case of a system index that might have been invalidated by a
1703 * failed concurrent process and allow its drop. For the time being, this
1704 * only concerns indexes of toast relations that became invalid during a
1705 * REINDEX CONCURRENTLY process.
1706 */
1708 {
1709 HeapTuple locTuple;
1710 Form_pg_index indexform;
1715 {
1718 }
1724 /* Mark object as being an invalid index of system catalogs */
1727 }
1729 /* In the case of an invalid index, it is fine to bypass this check */
1738 /*
1739 * In DROP INDEX, attempt to acquire lock on the parent table before
1740 * locking the index. index_drop() will need this anyway, and since
1741 * regular queries lock tables before their indexes, we risk deadlock if
1742 * we do it the other way around. No error if we don't find a pg_index
1743 * entry, though --- the relation may have been dropped. Note that this
1744 * code will execute for either plain or partitioned indexes.
1745 */
1748 {
1752 }
1754 /*
1755 * Similarly, if the relation is a partition, we must acquire lock on its
1756 * parent before locking the partition. That's because queries lock the
1757 * parent before its partitions, so we risk deadlock if we do it the other
1758 * way around.
1759 */
1761 {
1765 }
1766 }
1768 /*
1769 * ExecuteTruncate
1770 * Executes a TRUNCATE command.
1771 *
1772 * This is a multi-relation truncate. We first open and grab exclusive
1773 * lock on all relations involved, checking permissions and otherwise
1774 * verifying that the relation is OK for truncation. Note that if relations
1775 * are foreign tables, at this stage, we have not yet checked that their
1776 * foreign data in external data sources are OK for truncation. These are
1777 * checked when foreign data are actually truncated later. In CASCADE mode,
1778 * relations having FK references to the targeted relations are automatically
1779 * added to the group; in RESTRICT mode, we check that all FK references are
1780 * internal to the group that's being truncated. Finally all the relations
1781 * are truncated and reindexed.
1782 */
1783 void
1785 {
1791 /*
1792 * Open, exclusive-lock, and check all the explicitly-specified relations
1793 */
1795 {
1797 Relation rel;
1799 Oid myrelid;
1804 NULL);
1806 /* don't throw error for "TRUNCATE foo, foo" */
1810 /* open the relation, we already hold a lock on it */
1813 /*
1814 * RangeVarGetRelidExtended() has done most checks with its callback,
1815 * but other checks with the now-opened Relation remain.
1816 */
1822 /* Log this relation only if needed for logical decoding */
1827 {
1834 {
1840 /* find_all_inheritors already got lock */
1843 /*
1844 * It is possible that the parent table has children that are
1845 * temp tables of other backends. We cannot safely access
1846 * such tables (because of buffering issues), and the best
1847 * thing to do is to silently ignore them. Note that this
1848 * check is the same as one of the checks done in
1849 * truncate_check_activity() called below, still it is kept
1850 * here for simplicity.
1851 */
1853 {
1856 }
1858 /*
1859 * Inherited TRUNCATE commands perform access permission
1860 * checks on the parent table only. So we skip checking the
1861 * children's permissions and don't call
1862 * truncate_check_perms() here.
1863 */
1870 /* Log this relation only if needed for logical decoding */
1873 }
1874 }
1879 errhint("Do not specify the ONLY keyword, or use TRUNCATE ONLY on the partitions directly.")));
1880 }
1885 /* And close the rels */
1887 {
1891 }
1892 }
1894 /*
1895 * ExecuteTruncateGuts
1896 *
1897 * Internal implementation of TRUNCATE. This is called by the actual TRUNCATE
1898 * command (see above) as well as replication subscribers that execute a
1899 * replicated TRUNCATE action.
1900 *
1901 * explicit_rels is the list of Relations to truncate that the command
1902 * specified. relids is the list of Oids corresponding to explicit_rels.
1903 * relids_logged is the list of Oids (a subset of relids) that require
1904 * WAL-logging. This is all a bit redundant, but the existing callers have
1905 * this information handy in this form.
1906 */
1907 void
1913 {
1920 SubTransactionId mySubid;
1924 /*
1925 * Check the explicitly-specified relations.
1926 *
1927 * In CASCADE mode, suck in all referencing relations as well. This
1928 * requires multiple iterations to find indirectly-dependent relations. At
1929 * each phase, we need to exclusive-lock new rels before looking for their
1930 * dependencies, else we might miss something. Also, we check each rel as
1931 * soon as we open it, to avoid a faux pas such as holding lock for a long
1932 * time on a rel we have no permissions for.
1933 */
1936 {
1938 {
1946 {
1948 Relation rel;
1960 /* Log this relation only if needed for logical decoding */
1963 }
1964 }
1965 }
1967 /*
1968 * Check foreign key references. In CASCADE mode, this should be
1969 * unnecessary since we just pulled in all the references; but as a
1970 * cross-check, do it anyway if in an Assert-enabled build.
1971 */
1972 #ifdef USE_ASSERT_CHECKING
1974 #else
1977 #endif
1979 /*
1980 * If we are asked to restart sequences, find all the sequences, lock them
1981 * (we need AccessExclusiveLock for ResetSequence), and check permissions.
1982 * We want to do this early since it's pointless to do all the truncation
1983 * work only to fail on sequence permissions.
1984 */
1986 {
1988 {
1994 {
1996 Relation seq_rel;
2000 /* This check must match AlterSequence! */
2008 }
2009 }
2010 }
2012 /* Prepare to catch AFTER triggers. */
2015 /*
2016 * To fire triggers, we'll need an EState as well as a ResultRelInfo for
2017 * each relation. We don't need to call ExecOpenIndices, though.
2018 *
2019 * We put the ResultRelInfos in the es_opened_result_relations list, even
2020 * though we don't have a range table and don't populate the
2021 * es_result_relations array. That's a bit bogus, but it's enough to make
2022 * ExecGetTriggerResultRel() find them.
2023 */
2029 {
2033 rel,
2035 NULL,
2039 resultRelInfo++;
2040 }
2042 /*
2043 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
2044 * truncating (this is because one of them might throw an error). Also, if
2045 * we were to allow them to prevent statement execution, that would need
2046 * to be handled here.
2047 */
2050 {
2051 UserContext ucxt;
2059 resultRelInfo++;
2060 }
2062 /*
2063 * OK, truncate each table.
2064 */
2068 {
2071 /* Skip partitioned tables as there is nothing to do */
2075 /*
2076 * Build the lists of foreign tables belonging to each foreign server
2077 * and pass each list to the foreign data wrapper's callback function,
2078 * so that each server can truncate its all foreign tables in bulk.
2079 * Each list is saved as a single entry in a hash table that uses the
2080 * server OID as lookup key.
2081 */
2083 {
2088 /* First time through, initialize hashtable for foreign tables */
2090 {
2091 HASHCTL hctl;
2102 }
2104 /* Find or create cached entry for the foreign table */
2107 {
2110 }
2112 /*
2113 * Save the foreign table in the entry of the server that the
2114 * foreign table belongs to.
2115 */
2118 }
2120 /*
2121 * Normally, we need a transaction-safe truncation here. However, if
2122 * the table was either created in the current (sub)transaction or has
2123 * a new relfilenumber in the current (sub)transaction, then we can
2124 * just truncate it in-place, because a rollback would cause the whole
2125 * table or the current physical file to be thrown away anyway.
2126 */
2129 {
2130 /* Immediate, non-rollbackable truncation is OK */
2132 }
2133 else
2134 {
2135 Oid heap_relid;
2136 Oid toast_relid;
2139 /*
2140 * This effectively deletes all rows in the table, and may be done
2141 * in a serializable transaction. In that case we must record a
2142 * rw-conflict in to this transaction from each transaction
2143 * holding a predicate lock on the table.
2144 */
2147 /*
2148 * Need the full transaction-safe pushups.
2149 *
2150 * Create a new empty storage file for the relation, and assign it
2151 * as the relfilenumber value. The old storage file is scheduled
2152 * for deletion at commit.
2153 */
2158 /*
2159 * The same for the toast table, if any.
2160 */
2163 {
2165 AccessExclusiveLock);
2170 }
2172 /*
2173 * Reconstruct the indexes to match, and we're done.
2174 */
2177 }
2180 }
2182 /* Now go through the hash table, and truncate foreign tables */
2184 {
2186 HASH_SEQ_STATUS seq;
2191 {
2193 {
2196 /* truncate_check_rel() has checked that already */
2200 behavior,
2201 restart_seqs);
2202 }
2203 }
2205 {
2207 }
2209 }
2211 /*
2212 * Restart owned sequences if we were asked to.
2213 */
2215 {
2219 }
2221 /*
2222 * Write a WAL record to allow this set of actions to be logically
2223 * decoded.
2224 *
2225 * Assemble an array of relids so we can write a single WAL record for the
2226 * whole action.
2227 */
2229 {
2230 xl_heap_truncate xlrec;
2233 /* should only get here if wal_level >= logical */
2255 }
2257 /*
2258 * Process all AFTER STATEMENT TRUNCATE triggers.
2259 */
2262 {
2263 UserContext ucxt;
2271 resultRelInfo++;
2272 }
2274 /* Handle queued AFTER triggers */
2277 /* We can clean up the EState now */
2280 /*
2281 * Close any rels opened by CASCADE (can't do this while EState still
2282 * holds refs)
2283 */
2286 {
2290 }
2291 }
2293 /*
2294 * Check that a given relation is safe to truncate. Subroutine for
2295 * ExecuteTruncate() and RangeVarCallbackForTruncate().
2296 */
2297 static void
2299 {
2302 /*
2303 * Only allow truncate on regular tables, foreign tables using foreign
2304 * data wrappers supporting TRUNCATE and partitioned tables (although, the
2305 * latter are only being included here for the following checks; no
2306 * physical truncation will occur in their case.).
2307 */
2309 {
2317 relname)));
2318 }
2325 /*
2326 * Most system catalogs can't be truncated at all, or at least not unless
2327 * allow_system_table_mods=on. As an exception, however, we allow
2328 * pg_largeobject to be truncated as part of pg_upgrade, because we need
2329 * to change its relfilenode to match the old cluster, and allowing a
2330 * TRUNCATE command to be executed is the easiest way of doing that.
2331 */
2337 relname)));
2340 }
2342 /*
2343 * Check that current user has the permission to truncate given relation.
2344 */
2345 static void
2347 {
2349 AclResult aclresult;
2351 /* Permissions checks */
2355 relname);
2356 }
2358 /*
2359 * Set of extra sanity checks to check if a given relation is safe to
2360 * truncate. This is split with truncate_check_rel() as
2361 * RangeVarCallbackForTruncate() cannot open a Relation yet.
2362 */
2363 static void
2365 {
2366 /*
2367 * Don't allow truncate on temp tables of other backends ... their local
2368 * buffer manager is not going to cope.
2369 */
2375 /*
2376 * Also check for active uses of the relation in the current transaction,
2377 * including open scans and pending AFTER trigger events.
2378 */
2380 }
2382 /*
2383 * storage_name
2384 * returns the name corresponding to a typstorage/attstorage enum value
2385 */
2388 {
2390 {
2401 }
2402 }
2404 /*----------
2405 * MergeAttributes
2406 * Returns new schema given initial schema and superclasses.
2407 *
2408 * Input arguments:
2409 * 'columns' is the column/attribute definition for the table. (It's a list
2410 * of ColumnDef's.) It is destructively changed.
2411 * 'supers' is a list of OIDs of parent relations, already locked by caller.
2412 * 'relpersistence' is the persistence type of the table.
2413 * 'is_partition' tells if the table is a partition.
2414 *
2415 * Output arguments:
2416 * 'supconstr' receives a list of constraints belonging to the parents,
2417 * updated as necessary to be valid for the child.
2418 * 'supnotnulls' receives a list of CookedConstraints that corresponds to
2419 * constraints coming from inheritance parents.
2420 *
2421 * Return value:
2422 * Completed schema list.
2423 *
2424 * Notes:
2425 * The order in which the attributes are inherited is very important.
2426 * Intuitively, the inherited attributes should come first. If a table
2427 * inherits from multiple parents, the order of those attributes are
2428 * according to the order of the parents specified in CREATE TABLE.
2429 *
2430 * Here's an example:
2431 *
2432 * create table person (name text, age int4, location point);
2433 * create table emp (salary int4, manager text) inherits(person);
2434 * create table student (gpa float8) inherits (person);
2435 * create table stud_emp (percent int4) inherits (emp, student);
2436 *
2437 * The order of the attributes of stud_emp is:
2438 *
2439 * person {1:name, 2:age, 3:location}
2440 * / \
2441 * {6:gpa} student emp {4:salary, 5:manager}
2442 * \ /
2443 * stud_emp {7:percent}
2444 *
2445 * If the same attribute name appears multiple times, then it appears
2446 * in the result table in the proper location for its first appearance.
2447 *
2448 * Constraints (including not-null constraints) for the child table
2449 * are the union of all relevant constraints, from both the child schema
2450 * and parent tables. In addition, in legacy inheritance, each column that
2451 * appears in a primary key in any of the parents also gets a NOT NULL
2452 * constraint (partitioning doesn't need this, because the PK itself gets
2453 * inherited.)
2454 *
2455 * The default value for a child column is defined as:
2456 * (1) If the child schema specifies a default, that value is used.
2457 * (2) If neither the child nor any parent specifies a default, then
2458 * the column will not have a default.
2459 * (3) If conflicting defaults are inherited from different parents
2460 * (and not overridden by the child), an error is raised.
2461 * (4) Otherwise the inherited default is used.
2462 *
2463 * Note that the default-value infrastructure is used for generated
2464 * columns' expressions too, so most of the preceding paragraph applies
2465 * to generation expressions too. We insist that a child column be
2466 * generated if and only if its parent(s) are, but it need not have
2467 * the same generation expression.
2468 *----------
2469 */
2473 {
2483 /*
2484 * Check for and reject tables with too many columns. We perform this
2485 * check relatively early for two reasons: (a) we don't run the risk of
2486 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
2487 * okay if we're processing <= 1600 columns, but could take minutes to
2488 * execute if the user attempts to create a table with hundreds of
2489 * thousands of columns.
2490 *
2491 * Note that we also need to check that we do not exceed this figure after
2492 * including columns from inherited relations.
2493 */
2498 MaxHeapAttributeNumber)));
2500 /*
2501 * Check for duplicate names in the explicit list of attributes.
2502 *
2503 * Although we might consider merging such entries in the same way that we
2504 * handle name conflicts for inherited attributes, it seems to make more
2505 * sense to assume such conflicts are errors.
2506 *
2507 * We don't use foreach() here because we have two nested loops over the
2508 * columns list, with possible element deletions in the inner one. If we
2509 * used foreach_delete_current() it could only fix up the state of one of
2510 * the loops, so it seems cleaner to use looping over list indexes for
2511 * both loops. Note that any deletion will happen beyond where the outer
2512 * loop is, so its index never needs adjustment.
2513 */
2515 {
2519 {
2520 /*
2521 * Typed table column option that does not belong to a column from
2522 * the type. This works because the columns from the type come
2523 * first in the list. (We omit this check for partition column
2524 * lists; those are processed separately below.)
2525 */
2530 }
2532 /* restpos scans all entries beyond coldef; incr is in loop body */
2534 {
2538 {
2540 {
2541 /*
2542 * merge the column options into the column from the type
2543 */
2550 }
2551 else
2556 }
2557 else
2558 restpos++;
2559 }
2560 }
2562 /*
2563 * In case of a partition, there are no new column definitions, only dummy
2564 * ColumnDefs created for column constraints. Set them aside for now and
2565 * process them at the end.
2566 */
2568 {
2571 }
2573 /*
2574 * Scan the parents left-to-right, and merge their attributes to form a
2575 * list of inherited columns (inh_columns).
2576 */
2579 {
2581 Relation relation;
2582 TupleDesc tupleDesc;
2593 /* caller already got lock */
2596 /*
2597 * Check for active uses of the parent partitioned table in the
2598 * current transaction, such as being used in some manner by an
2599 * enclosing command.
2600 */
2604 /*
2605 * We do not allow partitioned tables and partitions to participate in
2606 * regular inheritance.
2607 */
2627 /*
2628 * If the parent is permanent, so must be all of its partitions. Note
2629 * that inheritance allows that case.
2630 */
2639 /* Permanent rels cannot inherit from temporary ones */
2649 /* If existing rel is temp, it must belong to this session */
2658 /*
2659 * We should have an UNDER permission flag for this, but for now,
2660 * demand that creator of a child table own the parent.
2661 */
2669 /*
2670 * newattmap->attnums[] will contain the child-table attribute numbers
2671 * for the attributes of this parent table. (They are not the same
2672 * for parents after the first one, nor if we have dropped columns.)
2673 */
2676 /* We can't process inherited defaults until newattmap is complete. */
2679 /*
2680 * All columns that are part of the parent's primary key need to be
2681 * NOT NULL; if partition just the attnotnull bit, otherwise a full
2682 * constraint (if they don't have one already). Also, we request
2683 * attnotnull on columns that have a not-null constraint that's not
2684 * marked NO INHERIT.
2685 */
2687 INDEX_ATTR_BITMAP_PRIMARY_KEY);
2694 parent_attno++)
2695 {
2702 /*
2703 * Ignore dropped columns in the parent.
2704 */
2708 /*
2709 * Does it conflict with some previously inherited column?
2710 */
2713 {
2714 Oid defTypeId;
2715 int32 deftypmod;
2716 Oid defCollId;
2718 /*
2719 * Yes, try to merge the two column definitions.
2720 */
2723 attributeName)));
2726 /*
2727 * Must have the same type and typmod
2728 */
2735 attributeName),
2738 deftypmod),
2742 /*
2743 * Must have the same collation
2744 */
2750 attributeName),
2755 /*
2756 * Copy/check storage parameter
2757 */
2764 attributeName),
2769 /*
2770 * Copy/check compression parameter
2771 */
2773 {
2783 attributeName),
2785 }
2787 /*
2788 * In regular inheritance, columns in the parent's primary key
2789 * get an extra not-null constraint. Partitioning doesn't
2790 * need this, because the PK itself is going to be cloned to
2791 * the partition.
2792 */
2795 pkattrs))
2796 {
2811 }
2813 /*
2814 * mark attnotnull if parent has it and it's not NO INHERIT
2815 */
2818 pkattrs))
2821 /*
2822 * Check for GENERATED conflicts
2823 */
2828 attributeName)));
2830 /*
2831 * Default and other constraints are handled below
2832 */
2841 }
2842 else
2843 {
2844 /*
2845 * No, create a new inherited column
2846 */
2851 /* mark attnotnull if parent has it and it's not NO INHERIT */
2854 pkattrs))
2864 /*
2865 * In regular inheritance, columns in the parent's primary key
2866 * get an extra not-null constraint. Partitioning doesn't
2867 * need this, because the PK itself is going to be cloned to
2868 * the partition.
2869 */
2872 FirstLowInvalidHeapAttributeNumber,
2873 pkattrs))
2874 {
2889 }
2890 }
2892 /*
2893 * Locate default/generation expression if any
2894 */
2896 {
2904 /*
2905 * If it's a GENERATED default, it might contain Vars that
2906 * need to be mapped to the inherited column(s)' new numbers.
2907 * We can't do that till newattmap is ready, so just remember
2908 * all the inherited default expressions for the moment.
2909 */
2912 }
2913 }
2915 /*
2916 * Now process any inherited default expressions, adjusting attnos
2917 * using the completed newattmap map.
2918 */
2920 {
2925 /* Adjust Vars to match new table's column numbering */
2928 newattmap,
2931 /*
2932 * For the moment we have to reject whole-row variables. We could
2933 * convert them, if we knew the new table's rowtype OID, but that
2934 * hasn't been assigned yet. (A variable could only appear in a
2935 * generation expression, so the error message is correct.)
2936 */
2941 errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
2945 /*
2946 * If we already had a default from some prior parent, check to
2947 * see if they are the same. If so, no problem; if not, mark the
2948 * column as having a bogus default. Below, we will complain if
2949 * the bogus default isn't overridden by the child columns.
2950 */
2955 {
2958 }
2959 }
2961 /*
2962 * Now copy the CHECK constraints of this parent, adjusting attnos
2963 * using the completed newattmap map. Identically named constraints
2964 * are merged if possible, else we throw error.
2965 */
2967 {
2971 {
2976 /* ignore if the constraint is non-inheritable */
2980 /* Adjust Vars to match new table's column numbering */
2983 newattmap,
2986 /*
2987 * For the moment we have to reject whole-row variables. We
2988 * could convert them, if we knew the new table's rowtype OID,
2989 * but that hasn't been assigned yet.
2990 */
2996 name,
3000 }
3001 }
3003 /*
3004 * Also copy the not-null constraints from this parent. The
3005 * attnotnull markings were already installed above.
3006 */
3008 {
3018 }
3022 /*
3023 * Close the parent rel, but keep our lock on it until xact commit.
3024 * That will prevent someone else from deleting or ALTERing the parent
3025 * before the child is committed.
3026 */
3028 }
3030 /*
3031 * If we had no inherited attributes, the result columns are just the
3032 * explicitly declared columns. Otherwise, we need to merge the declared
3033 * columns into the inherited column list. Although, we never have any
3034 * explicitly declared columns if the table is a partition.
3035 */
3037 {
3041 {
3046 newcol_attno++;
3048 /*
3049 * Does it conflict with some previously inherited column?
3050 */
3053 {
3055 Oid defTypeId,
3056 newTypeId;
3057 int32 deftypmod,
3058 newtypmod;
3059 Oid defcollid,
3060 newcollid;
3062 /*
3063 * Partitions have only one parent and have no column
3064 * definitions of their own, so conflict should never occur.
3065 */
3068 /*
3069 * Yes, try to merge the two column definitions.
3070 */
3074 attributeName)));
3075 else
3081 /*
3082 * Must have the same type and typmod
3083 */
3090 attributeName),
3093 deftypmod),
3095 newtypmod))));
3097 /*
3098 * Must have the same collation
3099 */
3106 attributeName),
3111 /*
3112 * Identity is never inherited. The new column can have an
3113 * identity definition, so we always just take that one.
3114 */
3117 /*
3118 * Copy storage parameter
3119 */
3126 attributeName),
3131 /*
3132 * Copy compression parameter
3133 */
3137 {
3142 attributeName),
3144 }
3146 /*
3147 * Merge of not-null constraints = OR 'em together
3148 */
3151 /*
3152 * Check for conflicts related to generated columns.
3153 *
3154 * If the parent column is generated, the child column will be
3155 * made a generated column if it isn't already. If it is a
3156 * generated column, we'll take its generation expression in
3157 * preference to the parent's. We must check that the child
3158 * column doesn't specify a default value or identity, which
3159 * matches the rules for a single column in parse_utilcmd.c.
3160 *
3161 * Conversely, if the parent column is not generated, the
3162 * child column can't be either. (We used to allow that, but
3163 * it results in being able to override the generation
3164 * expression via UPDATEs through the parent.)
3165 */
3167 {
3178 }
3179 else
3180 {
3187 }
3189 /*
3190 * If new def has a default, override previous default
3191 */
3193 {
3196 }
3198 /* Mark the column as locally defined */
3200 }
3201 else
3202 {
3203 /*
3204 * No, attach new column to result columns
3205 */
3207 }
3208 }
3212 /*
3213 * Check that we haven't exceeded the legal # of columns after merging
3214 * in inherited columns.
3215 */
3220 MaxHeapAttributeNumber)));
3221 }
3223 /*
3224 * Now that we have the column definition list for a partition, we can
3225 * check whether the columns referenced in the column constraint specs
3226 * actually exist. Also, merge column defaults.
3227 */
3229 {
3231 {
3237 {
3241 {
3244 /*
3245 * Check for conflicts related to generated columns.
3246 *
3247 * Same rules as above: generated-ness has to match the
3248 * parent, but the contents of the generation expression
3249 * can be different.
3250 */
3252 {
3263 }
3264 else
3265 {
3272 }
3274 /*
3275 * Override the parent's default value for this column
3276 * (coldef->cooked_default) with the partition's local
3277 * definition (restdef->raw_default), if there's one. It
3278 * should be physically impossible to get a cooked default
3279 * in the local definition or a raw default in the
3280 * inherited definition, but make sure they're nulls, for
3281 * future-proofing.
3282 */
3286 {
3289 }
3290 }
3291 }
3293 /* complain for constraints on columns not in parent */
3299 }
3300 }
3302 /*
3303 * If we found any conflicting parent default values, check to make sure
3304 * they were overridden by the child.
3305 */
3307 {
3309 {
3313 {
3320 else
3326 }
3327 }
3328 }
3334 }
3337 /*
3338 * MergeCheckConstraint
3339 * Try to merge an inherited CHECK constraint with previous ones
3340 *
3341 * If we inherit identically-named constraints from multiple parents, we must
3342 * merge them, or throw an error if they don't have identical definitions.
3343 *
3344 * constraints is a list of CookedConstraint structs for previous constraints.
3345 *
3346 * If the new constraint matches an existing one, then the existing
3347 * constraint's inheritance count is updated. If there is a conflict (same
3348 * name but different expression), throw an error. If the constraint neither
3349 * matches nor conflicts with an existing one, a new constraint is appended to
3350 * the list.
3351 */
3354 {
3359 {
3364 /* Non-matching names never conflict */
3369 {
3370 /* OK to merge constraint with existing */
3377 }
3382 name)));
3383 }
3385 /*
3386 * Constraint couldn't be merged with an existing one and also didn't
3387 * conflict with an existing one, so add it as a new one to the list.
3388 */
3395 }
3398 /*
3399 * StoreCatalogInheritance
3400 * Updates the system catalogs with proper inheritance information.
3401 *
3402 * supers is a list of the OIDs of the new relation's direct ancestors.
3403 */
3404 static void
3407 {
3408 Relation relation;
3409 int32 seqNumber;
3412 /*
3413 * sanity checks
3414 */
3420 /*
3421 * Store INHERITS information in pg_inherits using direct ancestors only.
3422 * Also enter dependencies on the direct ancestors, and make sure they are
3423 * marked with relhassubclass = true.
3424 *
3425 * (Once upon a time, both direct and indirect ancestors were found here
3426 * and then entered into pg_ipl. Since that catalog doesn't exist
3427 * anymore, there's no need to look for indirect ancestors.)
3428 */
3433 {
3437 child_is_partition);
3438 seqNumber++;
3439 }
3442 }
3444 /*
3445 * Make catalog entries showing relationId as being an inheritance child
3446 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
3447 */
3448 static void
3452 {
3453 ObjectAddress childobject,
3454 parentobject;
3456 /* store the pg_inherits row */
3459 /*
3460 * Store a dependency too
3461 */
3472 /*
3473 * Post creation hook of this inheritance. Since object_access_hook
3474 * doesn't take multiple object identifiers, we relay oid of parent
3475 * relation using auxiliary_id argument.
3476 */
3481 /*
3482 * Mark the parent as having subclasses.
3483 */
3485 }
3487 /*
3488 * Look for an existing column entry with the given name.
3489 *
3490 * Returns the index (starting with 1) if attribute already exists in columns,
3491 * 0 if it doesn't.
3492 */
3493 static int
3495 {
3500 {
3504 i++;
3505 }
3507 }
3510 /*
3511 * SetRelationHasSubclass
3512 * Set the value of the relation's relhassubclass field in pg_class.
3513 *
3514 * NOTE: caller must be holding an appropriate lock on the relation.
3515 * ShareUpdateExclusiveLock is sufficient.
3516 *
3517 * NOTE: an important side-effect of this operation is that an SI invalidation
3518 * message is sent out to all backends --- including me --- causing plans
3519 * referencing the relation to be rebuilt with the new list of children.
3520 * This must happen even if we find that no change is needed in the pg_class
3521 * row.
3522 */
3523 void
3525 {
3526 Relation relationRelation;
3527 HeapTuple tuple;
3528 Form_pg_class classtuple;
3530 /*
3531 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
3532 */
3540 {
3543 }
3544 else
3545 {
3546 /* no need to change tuple, but force relcache rebuild anyway */
3548 }
3552 }
3554 /*
3555 * CheckRelationTableSpaceMove
3556 * Check if relation can be moved to new tablespace.
3557 *
3558 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3559 *
3560 * Returns true if the relation can be moved to the new tablespace; raises
3561 * an error if it is not possible to do the move; returns false if the move
3562 * would have no effect.
3563 */
3564 bool
3566 {
3567 Oid oldTableSpaceId;
3569 /*
3570 * No work if no change in tablespace. Note that MyDatabaseTableSpace is
3571 * stored as 0.
3572 */
3578 /*
3579 * We cannot support moving mapped relations into different tablespaces.
3580 * (In particular this eliminates all shared catalogs.)
3581 */
3588 /* Cannot move a non-shared relation into pg_global */
3594 /*
3595 * Do not allow moving temp tables of other backends ... their local
3596 * buffer manager is not going to cope.
3597 */
3604 }
3606 /*
3607 * SetRelationTableSpace
3608 * Set new reltablespace and relfilenumber in pg_class entry.
3609 *
3610 * newTableSpaceId is the new tablespace for the relation, and
3611 * newRelFilenumber its new filenumber. If newRelFilenumber is
3612 * InvalidRelFileNumber, this field is not updated.
3613 *
3614 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3615 *
3616 * The caller of this routine had better check if a relation can be
3617 * moved to this new tablespace by calling CheckRelationTableSpaceMove()
3618 * first, and is responsible for making the change visible with
3619 * CommandCounterIncrement().
3620 */
3621 void
3623 Oid newTableSpaceId,
3624 RelFileNumber newRelFilenumber)
3625 {
3626 Relation pg_class;
3627 HeapTuple tuple;
3628 Form_pg_class rd_rel;
3633 /* Get a modifiable copy of the relation's pg_class row. */
3641 /* Update the pg_class row. */
3648 /*
3649 * Record dependency on tablespace. This is only required for relations
3650 * that have no physical storage.
3651 */
3658 }
3660 /*
3661 * renameatt_check - basic sanity checks before attribute rename
3662 */
3663 static void
3665 {
3673 /*
3674 * Renaming the columns of sequences or toast tables doesn't actually
3675 * break anything from the system's point of view, since internal
3676 * references are by attnum. But it doesn't seem right to allow users to
3677 * change names that are hardcoded into the system, hence the following
3678 * restriction.
3679 */
3694 /*
3695 * permissions checking. only the owner of a class can change its schema.
3696 */
3705 }
3707 /*
3708 * renameatt_internal - workhorse for renameatt
3709 *
3710 * Return value is the attribute number in the 'myrelid' relation.
3711 */
3712 static AttrNumber
3719 DropBehavior behavior)
3720 {
3721 Relation targetrelation;
3722 Relation attrelation;
3723 HeapTuple atttup;
3724 Form_pg_attribute attform;
3725 AttrNumber attnum;
3727 /*
3728 * Grab an exclusive lock on the target table, which we will NOT release
3729 * until end of transaction.
3730 */
3734 /*
3735 * if the 'recurse' flag is set then we are supposed to rename this
3736 * attribute in all classes that inherit from 'relname' (as well as in
3737 * 'relname').
3738 *
3739 * any permissions or problems with duplicate attributes will cause the
3740 * whole transaction to abort, which is what we want -- all or nothing.
3741 */
3743 {
3749 /*
3750 * we need the number of parents for each child so that the recursive
3751 * calls to renameatt() can determine whether there are any parents
3752 * outside the inheritance hierarchy being processed.
3753 */
3757 /*
3758 * find_all_inheritors does the recursive search of the inheritance
3759 * hierarchy, so all we have to do is process all of the relids in the
3760 * list that it returns.
3761 */
3763 {
3769 /* note we need not recurse again */
3771 }
3772 }
3773 else
3774 {
3775 /*
3776 * If we are told not to recurse, there had better not be any child
3777 * tables; else the rename would put them out of step.
3778 *
3779 * expected_parents will only be 0 if we are not already recursing.
3780 */
3786 oldattname)));
3787 }
3789 /* rename attributes in typed tables of composite type */
3791 {
3797 behavior);
3801 }
3810 oldattname)));
3818 oldattname)));
3820 /*
3821 * if the attribute is inherited, forbid the renaming. if this is a
3822 * top-level call to renameatt(), then expected_parents will be 0, so the
3823 * effect of this code will be to prohibit the renaming if the attribute
3824 * is inherited at all. if this is a recursive call to renameatt(),
3825 * expected_parents will be the number of parents the current relation has
3826 * within the inheritance hierarchy being processed, so we'll prohibit the
3827 * renaming only if there are additional parents from elsewhere.
3828 */
3833 oldattname)));
3835 /* new name should not already exist */
3838 /* apply the update */
3852 }
3854 /*
3855 * Perform permissions and integrity checks before acquiring a relation lock.
3856 */
3857 static void
3860 {
3861 HeapTuple tuple;
3862 Form_pg_class form;
3870 }
3872 /*
3873 * renameatt - changes the name of an attribute in a relation
3874 *
3875 * The returned ObjectAddress is that of the renamed column.
3876 */
3877 ObjectAddress
3879 {
3880 Oid relid;
3881 AttrNumber attnum;
3882 ObjectAddress address;
3884 /* lock level taken here should match renameatt_internal */
3887 RangeVarCallbackForRenameAttribute,
3888 NULL);
3891 {
3896 }
3898 attnum =
3910 }
3912 /*
3913 * same logic as renameatt_internal
3914 */
3915 static ObjectAddress
3917 Oid mytypid,
3923 {
3925 Oid constraintOid;
3926 HeapTuple tuple;
3927 Form_pg_constraint con;
3928 ObjectAddress address;
3933 {
3935 }
3936 else
3937 {
3940 /*
3941 * don't tell it whether we're recursing; we allow changing typed
3942 * tables here
3943 */
3947 }
3952 constraintOid);
3959 {
3961 {
3971 {
3978 rename_constraint_internal(childrelid, InvalidOid, oldconname, newconname, false, true, numparents);
3979 }
3980 }
3981 else
3982 {
3988 oldconname)));
3989 }
3995 oldconname)));
3996 }
4002 /* rename the index; this renames the constraint as well */
4004 else
4012 {
4013 /*
4014 * Invalidate relcache so as others can see the new constraint name.
4015 */
4019 }
4022 }
4024 ObjectAddress
4026 {
4031 {
4032 Relation rel;
4033 HeapTuple tup;
4043 }
4044 else
4045 {
4046 /* lock level taken here should match rename_constraint_internal */
4049 RangeVarCallbackForRenameAttribute,
4050 NULL);
4052 {
4057 }
4058 }
4060 return
4068 }
4070 /*
4071 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW/MATERIALIZED VIEW/FOREIGN TABLE
4072 * RENAME
4073 */
4074 ObjectAddress
4076 {
4078 Oid relid;
4079 ObjectAddress address;
4081 /*
4082 * Grab an exclusive lock on the target table, index, sequence, view,
4083 * materialized view, or foreign table, which we will NOT release until
4084 * end of transaction.
4085 *
4086 * Lock level used here should match RenameRelationInternal, to avoid lock
4087 * escalation. However, because ALTER INDEX can be used with any relation
4088 * type, we mustn't believe without verification.
4089 */
4091 {
4092 LOCKMODE lockmode;
4100 RangeVarCallbackForAlterRelation,
4104 {
4109 }
4111 /*
4112 * We allow mismatched statement and object types (e.g., ALTER INDEX
4113 * to rename a table), but we might've used the wrong lock level. If
4114 * that happens, retry with the correct lock level. We don't bother
4115 * if we already acquired AccessExclusiveLock with an index, however.
4116 */
4125 }
4127 /* Do the work */
4133 }
4135 /*
4136 * RenameRelationInternal - change the name of a relation
4137 */
4138 void
4140 {
4141 Relation targetrelation;
4143 HeapTuple reltup;
4144 Form_pg_class relform;
4145 Oid namespaceId;
4147 /*
4148 * Grab a lock on the target relation, which we will NOT release until end
4149 * of transaction. We need at least a self-exclusive lock so that
4150 * concurrent DDL doesn't overwrite the rename if they start updating
4151 * while still seeing the old version. The lock also guards against
4152 * triggering relcache reloads in concurrent sessions, which might not
4153 * handle this information changing under them. For indexes, we can use a
4154 * reduced lock level because RelationReloadIndexInfo() handles indexes
4155 * specially.
4156 */
4157 targetrelation = relation_open(myrelid, is_index ? ShareUpdateExclusiveLock : AccessExclusiveLock);
4160 /*
4161 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
4162 */
4174 newrelname)));
4176 /*
4177 * RenameRelation is careful not to believe the caller's idea of the
4178 * relation kind being handled. We don't have to worry about this, but
4179 * let's not be totally oblivious to it. We can process an index as
4180 * not-an-index, but not the other way around.
4181 */
4186 /*
4187 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
4188 * because it's a copy...)
4189 */
4200 /*
4201 * Also rename the associated type, if any.
4202 */
4207 /*
4208 * Also rename the associated constraint, if any.
4209 */
4212 {
4217 }
4219 /*
4220 * Close rel, but keep lock!
4221 */
4223 }
4225 /*
4226 * ResetRelRewrite - reset relrewrite
4227 */
4228 void
4230 {
4232 HeapTuple reltup;
4233 Form_pg_class relform;
4235 /*
4236 * Find relation's pg_class tuple.
4237 */
4245 /*
4246 * Update pg_class tuple.
4247 */
4254 }
4256 /*
4257 * Disallow ALTER TABLE (and similar commands) when the current backend has
4258 * any open reference to the target table besides the one just acquired by
4259 * the calling command; this implies there's an open cursor or active plan.
4260 * We need this check because our lock doesn't protect us against stomping
4261 * on our own foot, only other people's feet!
4262 *
4263 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
4264 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
4265 * possibly be relaxed to only error out for certain types of alterations.
4266 * But the use-case for allowing any of these things is not obvious, so we
4267 * won't work hard at it for now.
4268 *
4269 * We also reject these commands if there are any pending AFTER trigger events
4270 * for the rel. This is certainly necessary for the rewriting variants of
4271 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
4272 * events would try to fetch the wrong tuples. It might be overly cautious
4273 * in other cases, but again it seems better to err on the side of paranoia.
4274 *
4275 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
4276 * we are worried about active indexscans on the index. The trigger-event
4277 * check can be skipped, since we are doing no damage to the parent table.
4278 *
4279 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
4280 */
4281 void
4283 {
4290 /* translator: first %s is a SQL command, eg ALTER TABLE */
4299 /* translator: first %s is a SQL command, eg ALTER TABLE */
4302 }
4304 /*
4305 * AlterTableLookupRelation
4306 * Look up, and lock, the OID for the relation named by an alter table
4307 * statement.
4308 */
4309 Oid
4311 {
4314 RangeVarCallbackForAlterRelation,
4316 }
4318 /*
4319 * AlterTable
4320 * Execute ALTER TABLE, which can be a list of subcommands
4321 *
4322 * ALTER TABLE is performed in three phases:
4323 * 1. Examine subcommands and perform pre-transformation checking.
4324 * 2. Validate and transform subcommands, and update system catalogs.
4325 * 3. Scan table(s) to check new constraints, and optionally recopy
4326 * the data into new table(s).
4327 * Phase 3 is not performed unless one or more of the subcommands requires
4328 * it. The intention of this design is to allow multiple independent
4329 * updates of the table schema to be performed with only one pass over the
4330 * data.
4331 *
4332 * ATPrepCmd performs phase 1. A "work queue" entry is created for
4333 * each table to be affected (there may be multiple affected tables if the
4334 * commands traverse a table inheritance hierarchy). Also we do preliminary
4335 * validation of the subcommands. Because earlier subcommands may change
4336 * the catalog state seen by later commands, there are limits to what can
4337 * be done in this phase. Generally, this phase acquires table locks,
4338 * checks permissions and relkind, and recurses to find child tables.
4339 *
4340 * ATRewriteCatalogs performs phase 2 for each affected table.
4341 * Certain subcommands need to be performed before others to avoid
4342 * unnecessary conflicts; for example, DROP COLUMN should come before
4343 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
4344 * lists, one for each logical "pass" of phase 2.
4345 *
4346 * ATRewriteTables performs phase 3 for those tables that need it.
4347 *
4348 * For most subcommand types, phases 2 and 3 do no explicit recursion,
4349 * since phase 1 already does it. However, for certain subcommand types
4350 * it is only possible to determine how to recurse at phase 2 time; for
4351 * those cases, phase 1 sets the cmd->recurse flag.
4352 *
4353 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
4354 * the whole operation; we don't have to do anything special to clean up.
4355 *
4356 * The caller must lock the relation, with an appropriate lock level
4357 * for the subcommands requested, using AlterTableGetLockLevel(stmt->cmds)
4358 * or higher. We pass the lock level down
4359 * so that we can apply it recursively to inherited tables. Note that the
4360 * lock level we want as we recurse might well be higher than required for
4361 * that specific subcommand. So we pass down the overall lock requirement,
4362 * rather than reassess it at lower levels.
4363 *
4364 * The caller also provides a "context" which is to be passed back to
4365 * utility.c when we need to execute a subcommand such as CREATE INDEX.
4366 * Some of the fields therein, such as the relid, are used here as well.
4367 */
4368 void
4371 {
4372 Relation rel;
4374 /* Caller is required to provide an adequate lock. */
4380 }
4382 /*
4383 * AlterTableInternal
4384 *
4385 * ALTER TABLE with target specified by OID
4386 *
4387 * We do not reject if the relation is already open, because it's quite
4388 * likely that one or more layers of caller have it open. That means it
4389 * is unsafe to use this entry point for alterations that could break
4390 * existing query plans. On the assumption it's not used for such, we
4391 * don't have to reject pending AFTER triggers, either.
4392 *
4393 * Also, since we don't have an AlterTableUtilityContext, this cannot be
4394 * used for any subcommand types that require parse transformation or
4395 * could generate subcommands that have to be passed to ProcessUtility.
4396 */
4397 void
4399 {
4400 Relation rel;
4408 }
4410 /*
4411 * AlterTableGetLockLevel
4412 *
4413 * Sets the overall lock level required for the supplied list of subcommands.
4414 * Policy for doing this set according to needs of AlterTable(), see
4415 * comments there for overall explanation.
4416 *
4417 * Function is called before and after parsing, so it must give same
4418 * answer each time it is called. Some subcommands are transformed
4419 * into other subcommand types, so the transform must never be made to a
4420 * lower lock level than previously assigned. All transforms are noted below.
4421 *
4422 * Since this is called before we lock the table we cannot use table metadata
4423 * to influence the type of lock we acquire.
4424 *
4425 * There should be no lockmodes hardcoded into the subcommand functions. All
4426 * lockmode decisions for ALTER TABLE are made here only. The one exception is
4427 * ALTER TABLE RENAME which is treated as a different statement type T_RenameStmt
4428 * and does not travel through this section of code and cannot be combined with
4429 * any of the subcommands given here.
4430 *
4431 * Note that Hot Standby only knows about AccessExclusiveLocks on the primary
4432 * so any changes that might affect SELECTs running on standbys need to use
4433 * AccessExclusiveLocks even if you think a lesser lock would do, unless you
4434 * have a solution for that also.
4435 *
4436 * Also note that pg_dump uses only an AccessShareLock, meaning that anything
4437 * that takes a lock less than AccessExclusiveLock can change object definitions
4438 * while pg_dump is running. Be careful to check that the appropriate data is
4439 * derived by pg_dump using an MVCC snapshot, rather than syscache lookups,
4440 * otherwise we might end up with an inconsistent dump that can't restore.
4441 */
4442 LOCKMODE
4444 {
4445 /*
4446 * This only works if we read catalog tables using MVCC snapshots.
4447 */
4452 {
4457 {
4458 /*
4459 * These subcommands rewrite the heap, so require full locks.
4460 */
4462 * to SELECT */
4469 /*
4470 * These subcommands may require addition of toast tables. If
4471 * we add a toast table to a table currently being scanned, we
4472 * might miss data added to the new toast table by concurrent
4473 * insert transactions.
4474 */
4476 * ATRewriteCatalogs() */
4480 /*
4481 * Removing constraints can affect SELECTs that have been
4482 * optimized assuming the constraint holds true. See also
4483 * CloneFkReferenced.
4484 */
4490 /*
4491 * Subcommands that may be visible to concurrent SELECTs
4492 */
4503 /*
4504 * Changing owner may remove implicit SELECT privileges
4505 */
4510 /*
4511 * Changing foreign table options may affect optimization.
4512 */
4518 /*
4519 * These subcommands affect write operations only.
4520 */
4532 /*
4533 * These subcommands affect write operations only. XXX
4534 * Theoretically, these could be ShareRowExclusiveLock.
4535 */
4560 {
4564 {
4569 /*
4570 * Cases essentially the same as CREATE INDEX. We
4571 * could reduce the lock strength to ShareLock if
4572 * we can work out how to allow concurrent catalog
4573 * updates. XXX Might be set down to
4574 * ShareRowExclusiveLock but requires further
4575 * analysis.
4576 */
4581 /*
4582 * We add triggers to both tables when we add a
4583 * Foreign Key, so the lock level must be at least
4584 * as strong as CREATE TRIGGER.
4585 */
4591 }
4592 }
4595 /*
4596 * These subcommands affect inheritance behaviour. Queries
4597 * started before us will continue to see the old inheritance
4598 * behaviour, while queries started after we commit will see
4599 * new behaviour. No need to prevent reads or writes to the
4600 * subtable while we hook it up though. Changing the TupDesc
4601 * may be a problem, so keep highest lock.
4602 */
4608 /*
4609 * These subcommands affect implicit row type conversion. They
4610 * have affects similar to CREATE/DROP CAST on queries. don't
4611 * provide for invalidating parse trees as a result of such
4612 * changes, so we keep these at AccessExclusiveLock.
4613 */
4619 /*
4620 * Only used by CREATE OR REPLACE VIEW which must conflict
4621 * with an SELECTs currently using the view.
4622 */
4627 /*
4628 * These subcommands affect general strategies for performance
4629 * and maintenance, though don't change the semantic results
4630 * from normal data reads and writes. Delaying an ALTER TABLE
4631 * behind currently active writes only delays the point where
4632 * the new strategy begins to take effect, so there is no
4633 * benefit in waiting. In this case the minimum restriction
4634 * applies: we don't currently allow concurrent catalog
4635 * updates.
4636 */
4654 /*
4655 * Rel options are more complex than first appears. Options
4656 * are set here for tables, views and indexes; for historical
4657 * reasons these can all be used with ALTER TABLE, so we can't
4658 * decide between them using the basic grammar.
4659 */
4661 * getTables() */
4663 * getTables() */
4674 else
4686 }
4688 /*
4689 * Take the greatest lockmode from any subcommand
4690 */
4693 }
4696 }
4698 /*
4699 * ATController provides top level control over the phases.
4700 *
4701 * parsetree is passed in to allow it to be passed to event triggers
4702 * when requested.
4703 */
4704 static void
4708 {
4712 /* Phase 1: preliminary examination of commands, create work queue */
4714 {
4718 }
4720 /* Close the relation, but keep lock until commit */
4723 /* Phase 2: update system catalogs */
4726 /* Phase 3: scan/rewrite tables as needed, and run afterStmts */
4728 }
4730 /*
4731 * ATPrepCmd
4732 *
4733 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
4734 * recursion and permission checks.
4735 *
4736 * Caller must have acquired appropriate lock type on relation already.
4737 * This lock should be held until commit.
4738 */
4739 static void
4743 {
4747 /* Find or create work queue entry for this table */
4750 /*
4751 * Disallow any ALTER TABLE other than ALTER TABLE DETACH FINALIZE on
4752 * partitions that are pending detach.
4753 */
4761 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
4763 /*
4764 * Copy the original subcommand for each table, so we can scribble on it.
4765 * This avoids conflicts when different child tables need to make
4766 * different parse transformations (for example, the same column may have
4767 * different column numbers in different children).
4768 */
4771 /*
4772 * Do permissions and relkind checking, recursion to child tables if
4773 * needed, and any additional phase-1 processing needed. (But beware of
4774 * adding any processing that looks at table details that another
4775 * subcommand could change. In some cases we reject multiple subcommands
4776 * that could try to change the same state in contrary ways.)
4777 */
4779 {
4785 /* Recursion occurs during execution phase */
4792 /* Recursion occurs during execution phase */
4797 /*
4798 * We allow defaults on views so that INSERT into a view can have
4799 * default-ish behavior. This works because the rewriter
4800 * substitutes default values into INSERTs before it expands
4801 * rules.
4802 */
4805 /* No command-specific prep needed */
4809 /* This is currently used only in CREATE TABLE */
4810 /* (so the permission check really isn't necessary) */
4812 /* This command never recurses */
4817 /* This command never recurses */
4822 /* This command never recurses */
4823 /* This should run after AddIdentity, so do it in MISC pass */
4828 /* This command never recurses */
4833 /* Set up recursion for phase 2; no other prep needed */
4840 /* Set up recursion for phase 2; no other prep needed */
4846 * a constraint */
4848 /* Need command-specific recursion decision */
4859 ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX | ATT_PARTITIONED_INDEX | ATT_FOREIGN_TABLE);
4861 /* No command-specific prep needed */
4867 /* This command never recurses */
4873 /* No command-specific prep needed */
4878 /* This command never recurses */
4879 /* No command-specific prep needed */
4887 /* Recursion occurs during execution phase */
4892 /* This command never recurses */
4893 /* No command-specific prep needed */
4898 /* Recursion occurs during execution phase */
4899 /* No command-specific prep needed except saving recurse flag */
4906 /* This command never recurses */
4907 /* No command-specific prep needed */
4913 /* Other recursion occurs during execution phase */
4914 /* No command-specific prep needed except saving recurse flag */
4922 /* See comments for ATPrepAlterColumnType */
4926 /* Performs own recursion */
4933 /* This command never recurses */
4934 /* No command-specific prep needed */
4938 /* This command never recurses */
4939 /* No command-specific prep needed */
4945 /* These commands never recurse */
4946 /* No command-specific prep needed */
4956 /* force rewrite if necessary; see comment in ATRewriteTables */
4958 {
4961 }
4971 /* force rewrite if necessary; see comment in ATRewriteTables */
4973 {
4976 }
4986 /* partitioned tables don't have an access method */
4992 /* check if another access method change was already requested */
5003 ATT_PARTITIONED_INDEX);
5004 /* This command never recurses */
5012 /* This command never recurses */
5013 /* No command-specific prep needed */
5018 /* This command never recurses */
5024 /* This command never recurses */
5025 /* No command-specific prep needed */
5030 /* Recursion occurs during execution phase */
5035 /* Recursion occurs during execution phase */
5036 /* No command-specific prep needed except saving recurse flag */
5044 /* This command never recurses */
5045 /* No command-specific prep needed */
5056 /* Set up recursion for phase 2; no other prep needed */
5072 /* These commands never recurse */
5073 /* No command-specific prep needed */
5078 /* No command-specific prep needed */
5083 /* No command-specific prep needed */
5088 /* No command-specific prep needed */
5093 /* No command-specific prep needed */
5101 }
5104 /* Add the subcommand to the appropriate list for phase 2 */
5106 }
5108 /*
5109 * ATRewriteCatalogs
5110 *
5111 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
5112 * dispatched in a "safe" execution order (designed to avoid unnecessary
5113 * conflicts).
5114 */
5115 static void
5118 {
5122 /*
5123 * We process all the tables "in parallel", one pass at a time. This is
5124 * needed because we may have to propagate work from one table to another
5125 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
5126 * re-adding of the foreign key constraint to the other table). Work can
5127 * only be propagated into later passes, however.
5128 */
5130 {
5131 /* Go through each table that needs to be processed */
5133 {
5141 /*
5142 * Open the relation and store it in tab. This allows subroutines
5143 * close and reopen, if necessary. Appropriate lock was obtained
5144 * by phase 1, needn't get it again.
5145 */
5153 /*
5154 * After the ALTER TYPE pass, do cleanup work (this is not done in
5155 * ATExecAlterColumnType since it should be done only once if
5156 * multiple columns of a table are altered).
5157 */
5162 {
5165 }
5166 }
5167 }
5169 /* Check to see if a toast table must be added. */
5171 {
5174 /*
5175 * If the table is source table of ATTACH PARTITION command, we did
5176 * not modify anything about it that will change its toasting
5177 * requirement, so no need to check.
5178 */
5184 }
5185 }
5187 /*
5188 * ATExecCmd: dispatch a subcommand to appropriate execution routine
5189 */
5190 static void
5194 {
5199 {
5254 lockmode);
5260 NULL);
5264 lockmode);
5268 lockmode);
5275 /* Transform the command only during initial examination */
5280 /* Depending on constraint type, might be no more work to do now */
5282 address =
5288 address =
5293 * constraint */
5294 address =
5297 NULL);
5304 lockmode);
5319 /* parse transformation was done earlier */
5323 address =
5342 /* nothing to do here, oid columns don't exist anymore */
5345 /* handled specially in Phase 3 */
5349 /*
5350 * Only do this for partitioned tables and indexes, for which this
5351 * is just a catalog change. Other relation types which have
5352 * storage are handled by Phase 3.
5353 */
5368 lockmode);
5374 lockmode);
5380 lockmode);
5386 lockmode);
5392 lockmode);
5398 lockmode);
5404 lockmode);
5410 lockmode);
5466 context);
5467 else
5475 /* ATPrepCmd ensures it must be a table */
5488 }
5490 /*
5491 * Report the subcommand to interested event triggers.
5492 */
5496 /*
5497 * Bump the command counter to ensure the next subcommand in the sequence
5498 * can see the changes so far
5499 */
5501 }
5503 /*
5504 * ATParseTransformCmd: perform parse transformation for one subcommand
5505 *
5506 * Returns the transformed subcommand tree, if there is one, else NULL.
5507 *
5508 * The parser may hand back additional AlterTableCmd(s) and/or other
5509 * utility statements, either before or after the original subcommand.
5510 * Other AlterTableCmds are scheduled into the appropriate slot of the
5511 * AlteredTableInfo (they had better be for later passes than the current one).
5512 * Utility statements that are supposed to happen before the AlterTableCmd
5513 * are executed immediately. Those that are supposed to happen afterwards
5514 * are added to the tab->afterStmts list to be done at the very end.
5515 */
5520 {
5527 /* Gin up an AlterTableStmt with just this subcommand and this table */
5537 /* Transform the AlterTableStmt */
5539 atstmt,
5544 /* Execute any statements that should happen before these subcommand(s) */
5546 {
5551 }
5553 /* Examine the transformed subcommands and schedule them appropriately */
5555 {
5559 /*
5560 * This switch need only cover the subcommand types that can be added
5561 * by parse_utilcmd.c; otherwise, we'll use the default strategy of
5562 * executing the subcommand immediately, as a substitute for the
5563 * original subcommand. (Note, however, that this does cause
5564 * AT_AddConstraint subcommands to be rescheduled into later passes,
5565 * which is important for index and foreign key constraints.)
5566 *
5567 * We assume we needn't do any phase-1 checks for added subcommands.
5568 */
5570 {
5577 /*
5578 * A primary key on a inheritance parent needs supporting NOT
5579 * NULL constraint on its children; enqueue commands to create
5580 * those or mark them inherited if they already exist.
5581 */
5586 /* as above */
5591 /* Recursion occurs during execution phase */
5595 {
5604 }
5607 /* This command never recurses */
5608 /* No command-specific prep needed */
5614 }
5617 {
5618 /* Cannot schedule into a pass we already finished */
5620 pass);
5621 }
5623 {
5624 /* OK, queue it up for later */
5626 }
5627 else
5628 {
5629 /*
5630 * We should see at most one subcommand for the current pass,
5631 * which is the transformed version of the original subcommand.
5632 */
5634 {
5635 /* Found the transformed version of our subcommand */
5637 }
5638 else
5640 pass);
5641 }
5642 }
5644 /* Queue up any after-statements to happen at the end */
5648 }
5650 /*
5651 * ATRewriteTables: ALTER TABLE phase 3
5652 */
5653 static void
5656 {
5659 /* Go through each table that needs to be checked or rewritten */
5661 {
5664 /* Relations without storage may be ignored here */
5668 /*
5669 * If we change column data types, the operation has to be propagated
5670 * to tables that use this table's rowtype as a column type.
5671 * tab->newvals will also be non-NULL in the case where we're adding a
5672 * column with a default. We choose to forbid that case as well,
5673 * since composite types might eventually support defaults.
5674 *
5675 * (Eventually we'll probably need to check for composite type
5676 * dependencies even when we're just scanning the table without a
5677 * rewrite, but at the moment a composite type does not enforce any
5678 * constraints, so it's not necessary/appropriate to enforce them just
5679 * during ALTER.)
5680 */
5682 {
5683 Relation rel;
5688 }
5690 /*
5691 * We only need to rewrite the table if at least one column needs to
5692 * be recomputed, or we are changing its persistence or access method.
5693 *
5694 * There are two reasons for requiring a rewrite when changing
5695 * persistence: on one hand, we need to ensure that the buffers
5696 * belonging to each of the two relations are marked with or without
5697 * BM_PERMANENT properly. On the other hand, since rewriting creates
5698 * and assigns a new relfilenumber, we automatically create or drop an
5699 * init fork for the relation as appropriate.
5700 */
5702 {
5703 /* Build a temporary relation and copy data */
5704 Relation OldHeap;
5705 Oid OIDNewHeap;
5706 Oid NewAccessMethod;
5707 Oid NewTableSpace;
5712 /*
5713 * We don't support rewriting of system catalogs; there are too
5714 * many corner cases and too little benefit. In particular this
5715 * is certainly not going to work for mapped catalogs.
5716 */
5729 /*
5730 * Don't allow rewrite on temp tables of other backends ... their
5731 * local buffer manager is not going to cope.
5732 */
5738 /*
5739 * Select destination tablespace (same as original unless user
5740 * requested a change)
5741 */
5744 else
5747 /*
5748 * Select destination access method (same as original unless user
5749 * requested a change)
5750 */
5753 else
5756 /*
5757 * Select persistence of transient table (same as original unless
5758 * user requested a change)
5759 */
5765 /*
5766 * Fire off an Event Trigger now, before actually rewriting the
5767 * table.
5768 *
5769 * We don't support Event Trigger for nested commands anywhere,
5770 * here included, and parsetree is given NULL when coming from
5771 * AlterTableInternal.
5772 *
5773 * And fire it only once.
5774 */
5780 /*
5781 * Create transient table that will receive the modified data.
5782 *
5783 * Ensure it is marked correctly as logged or unlogged. We have
5784 * to do this here so that buffers for the new relfilenumber will
5785 * have the right persistence set, and at the same time ensure
5786 * that the original filenumbers's buffers will get read in with
5787 * the correct setting (i.e. the original one). Otherwise a
5788 * rollback after the rewrite would possibly result with buffers
5789 * for the original filenumbers having the wrong persistence
5790 * setting.
5791 *
5792 * NB: This relies on swap_relation_files() also swapping the
5793 * persistence. That wouldn't work for pg_class, but that can't be
5794 * unlogged anyway.
5795 */
5799 /*
5800 * Copy the heap data into the new table with the desired
5801 * modifications, and test the current data within the table
5802 * against new constraints generated by ALTER TABLE commands.
5803 */
5806 /*
5807 * Swap the physical files of the old and new heaps, then rebuild
5808 * indexes and discard the old heap. We can use RecentXmin for
5809 * the table's new relfrozenxid because we rewrote all the tuples
5810 * in ATRewriteTable, so no older Xid remains in the table. Also,
5811 * we never try to swap toast tables by content, since we have no
5812 * interest in letting this code work on system catalogs.
5813 */
5817 RecentXmin,
5819 persistence);
5822 }
5824 {
5827 }
5828 else
5829 {
5830 /*
5831 * If required, test the current data within the table against new
5832 * constraints generated by ALTER TABLE commands, but don't
5833 * rebuild data.
5834 */
5839 /*
5840 * If we had SET TABLESPACE but no reason to reconstruct tuples,
5841 * just do a block-by-block copy.
5842 */
5845 }
5847 /*
5848 * Also change persistence of owned sequences, so that it matches the
5849 * table persistence.
5850 */
5852 {
5857 {
5861 }
5862 }
5863 }
5865 /*
5866 * Foreign key constraints are checked in a final pass, since (a) it's
5867 * generally best to examine each one separately, and (b) it's at least
5868 * theoretically possible that we have changed both relations of the
5869 * foreign key, and we'd better have finished both rewrites before we try
5870 * to read the tables.
5871 */
5873 {
5878 /* Relations without storage may be ignored here too */
5883 {
5887 {
5889 Relation refrel;
5892 {
5893 /* Long since locked, no need for another */
5895 }
5903 /*
5904 * No need to mark the constraint row as validated, we did
5905 * that when we inserted the row earlier.
5906 */
5909 }
5910 }
5914 }
5916 /* Finally, run any afterStmts that were queued up */
5918 {
5923 {
5928 }
5929 }
5930 }
5932 /*
5933 * ATRewriteTable: scan or rewrite one table
5934 *
5935 * OIDNewHeap is InvalidOid if we don't need to rewrite
5936 */
5937 static void
5939 {
5940 Relation oldrel;
5941 Relation newrel;
5942 TupleDesc oldTupDesc;
5943 TupleDesc newTupDesc;
5949 CommandId mycid;
5950 BulkInsertState bistate;
5954 /*
5955 * Open the relation(s). We have surely already locked the existing
5956 * table.
5957 */
5964 else
5967 /*
5968 * Prepare a BulkInsertState and options for table_tuple_insert. The FSM
5969 * is empty, so don't bother using it.
5970 */
5972 {
5976 }
5977 else
5978 {
5979 /* keep compiler quiet about using these uninitialized */
5983 }
5985 /*
5986 * Generate the constraint and default execution states
5987 */
5991 /* Build the needed expression execution states */
5993 {
5997 {
6003 /* Nothing to do here */
6008 }
6009 }
6011 /* Build expression execution states for partition check quals */
6013 {
6016 }
6019 {
6022 /* expr already planned */
6024 }
6028 {
6029 /*
6030 * If we are rebuilding the tuples OR if we added any new but not
6031 * verified not-null constraints, check all not-null constraints. This
6032 * is a bit of overkill but it minimizes risk of bugs, and
6033 * heap_attisnull is a pretty cheap test anyway.
6034 */
6036 {
6041 }
6044 }
6047 {
6051 TableScanDesc scan;
6052 MemoryContext oldCxt;
6055 Snapshot snapshot;
6061 else
6067 {
6068 /*
6069 * All predicate locks on the tuples or pages are about to be made
6070 * invalid, because we move tuples around. Promote them to
6071 * relation locks.
6072 */
6074 }
6078 /*
6079 * Create necessary tuple slots. When rewriting, two slots are needed,
6080 * otherwise one suffices. In the case where one slot suffices, we
6081 * need to use the new tuple descriptor, otherwise some constraints
6082 * can't be evaluated. Note that even when the tuple layout is the
6083 * same and no rewrite is required, the tupDescs might not be
6084 * (consider ADD COLUMN without a default).
6085 */
6087 {
6094 /*
6095 * Set all columns in the new slot to NULL initially, to ensure
6096 * columns added as part of the rewrite are initialized to NULL.
6097 * That is necessary as tab->newvals will not contain an
6098 * expression for columns with a NULL default, e.g. when adding a
6099 * column without a default together with a column with a default
6100 * requiring an actual rewrite.
6101 */
6103 }
6104 else
6105 {
6109 }
6111 /*
6112 * Any attributes that are dropped according to the new tuple
6113 * descriptor can be set to NULL. We precompute the list of dropped
6114 * attributes to avoid needing to do so in the per-tuple loop.
6115 */
6117 {
6120 }
6122 /*
6123 * Scan through the rows, generating a new row if needed and then
6124 * checking all the constraints.
6125 */
6129 /*
6130 * Switch to per-tuple memory context and reset it for each tuple
6131 * produced, so we don't leak memory.
6132 */
6136 {
6140 {
6141 /* Extract data from old tuple */
6145 /* copy attributes */
6151 /* Set dropped attributes to null in new tuple */
6155 /*
6156 * Constraints and GENERATED expressions might reference the
6157 * tableoid column, so fill tts_tableOid with the desired
6158 * value. (We must do this each time, because it gets
6159 * overwritten with newrel's OID during storing.)
6160 */
6163 /*
6164 * Process supplied expressions to replace selected columns.
6165 *
6166 * First, evaluate expressions whose inputs come from the old
6167 * tuple.
6168 */
6172 {
6180 econtext,
6182 }
6186 /*
6187 * Now, evaluate any expressions whose inputs come from the
6188 * new tuple. We assume these columns won't reference each
6189 * other, so that there's no ordering dependency.
6190 */
6194 {
6202 econtext,
6204 }
6207 }
6208 else
6209 {
6210 /*
6211 * If there's no rewrite, old and new table are guaranteed to
6212 * have the same AM, so we can just use the old slot to verify
6213 * new constraints etc.
6214 */
6216 }
6218 /* Now check any constraints on the possibly-changed tuple */
6222 {
6226 {
6235 }
6236 }
6239 {
6243 {
6255 /* Nothing to do here */
6260 }
6261 }
6264 {
6268 errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
6271 else
6277 }
6279 /* Write the tuple out to the new relation */
6287 }
6296 }
6302 {
6308 }
6309 }
6311 /*
6312 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
6313 */
6316 {
6322 {
6326 }
6328 /*
6329 * Not there, so add it. Note that we make a copy of the relation's
6330 * existing descriptor before anything interesting can happen to it.
6331 */
6345 }
6349 {
6351 {
6478 }
6481 }
6483 /*
6484 * ATSimplePermissions
6485 *
6486 * - Ensure that it is a relation (or possibly a view)
6487 * - Ensure this user is the owner
6488 * - Ensure that it is not a system table
6489 */
6490 static void
6492 {
6496 {
6525 }
6527 /* Wrong target type? */
6529 {
6535 /* translator: %s is a group of some SQL keywords */
6539 else
6540 /* internal error? */
6543 }
6545 /* Permissions checks */
6555 }
6557 /*
6558 * ATSimpleRecursion
6559 *
6560 * Simple table recursion sufficient for most ALTER TABLE operations.
6561 * All direct and indirect children are processed in an unspecified order.
6562 * Note that if a child inherits from the original table via multiple
6563 * inheritance paths, it will be visited just once.
6564 */
6565 static void
6569 {
6570 /*
6571 * Propagate to children, if desired and if there are (or might be) any
6572 * children.
6573 */
6575 {
6582 /*
6583 * find_all_inheritors does the recursive search of the inheritance
6584 * hierarchy, so all we have to do is process all of the relids in the
6585 * list that it returns.
6586 */
6588 {
6590 Relation childrel;
6594 /* find_all_inheritors already got lock */
6599 }
6600 }
6601 }
6603 /*
6604 * Obtain list of partitions of the given table, locking them all at the given
6605 * lockmode and ensuring that they all pass CheckTableNotInUse.
6606 *
6607 * This function is a no-op if the given relation is not a partitioned table;
6608 * in particular, nothing is done if it's a legacy inheritance parent.
6609 */
6610 static void
6612 {
6614 {
6619 /* first element is the parent rel; must ignore it */
6621 {
6622 Relation childrel;
6624 /* find_all_inheritors already got lock */
6628 }
6630 }
6631 }
6633 /*
6634 * ATTypedTableRecursion
6635 *
6636 * Propagate ALTER TYPE operations to the typed tables of that type.
6637 * Also check the RESTRICT/CASCADE behavior. Given CASCADE, also permit
6638 * recursion to inheritance children of the typed tables.
6639 */
6640 static void
6643 {
6654 {
6656 Relation childrel;
6662 }
6663 }
6666 /*
6667 * find_composite_type_dependencies
6668 *
6669 * Check to see if the type "typeOid" is being used as a column in some table
6670 * (possibly nested several levels deep in composite types, arrays, etc!).
6671 * Eventually, we'd like to propagate the check or rewrite operation
6672 * into such tables, but for now, just error out if we find any.
6673 *
6674 * Caller should provide either the associated relation of a rowtype,
6675 * or a type name (not both) for use in the error message, if any.
6676 *
6677 * Note that "typeOid" is not necessarily a composite type; it could also be
6678 * another container type such as an array or range, or a domain over one of
6679 * these things. The name of this function is therefore somewhat historical,
6680 * but it's not worth changing.
6681 *
6682 * We assume that functions and views depending on the type are not reasons
6683 * to reject the ALTER. (How safe is this really?)
6684 */
6685 void
6688 {
6689 Relation depRel;
6691 SysScanDesc depScan;
6692 HeapTuple depTup;
6694 /* since this function recurses, it could be driven to stack overflow */
6697 /*
6698 * We scan pg_depend to find those things that depend on the given type.
6699 * (We assume we can ignore refobjsubid for a type.)
6700 */
6704 Anum_pg_depend_refclassid,
6708 Anum_pg_depend_refobjid,
6716 {
6718 Relation rel;
6719 TupleDesc tupleDesc;
6720 Form_pg_attribute att;
6722 /* Check for directly dependent types */
6724 {
6725 /*
6726 * This must be an array, domain, or range containing the given
6727 * type, so recursively check for uses of this type. Note that
6728 * any error message will mention the original type not the
6729 * container; this is intentional.
6730 */
6734 }
6736 /* Else, ignore dependees that aren't relations */
6743 /*
6744 * If objsubid identifies a specific column, refer to that in error
6745 * messages. Otherwise, search to see if there's a user column of the
6746 * type. (We assume system columns are never of interesting types.)
6747 * The search is needed because an index containing an expression
6748 * column of the target type will just be recorded as a whole-relation
6749 * dependency. If we do not find a column of the type, the dependency
6750 * must indicate that the type is transiently referenced in an index
6751 * expression but not stored on disk, which we assume is OK, just as
6752 * we do for references in views. (It could also be that the target
6753 * type is embedded in some container type that is stored in an index
6754 * column, but the previous recursion should catch such cases.)
6755 */
6758 else
6759 {
6762 {
6767 }
6769 {
6770 /* No such column, so assume OK */
6773 }
6774 }
6776 /*
6777 * We definitely should reject if the relation has storage. If it's
6778 * partitioned, then perhaps we don't have to reject: if there are
6779 * partitions then we'll fail when we find one, else there is no
6780 * stored data to worry about. However, it's possible that the type
6781 * change would affect conclusions about whether the type is sortable
6782 * or hashable and thus (if it's a partitioning column) break the
6783 * partitioning rule. For now, reject for partitioned rels too.
6784 */
6787 {
6792 origTypeName,
6809 else
6816 }
6818 {
6819 /*
6820 * A view or composite type itself isn't a problem, but we must
6821 * recursively check for indirect dependencies via its rowtype.
6822 */
6825 }
6828 }
6833 }
6836 /*
6837 * find_typed_table_dependencies
6838 *
6839 * Check to see if a composite type is being used as the type of a
6840 * typed table. Abort if any are found and behavior is RESTRICT.
6841 * Else return the list of tables.
6842 */
6845 {
6846 Relation classRel;
6848 TableScanDesc scan;
6849 HeapTuple tuple;
6855 Anum_pg_class_reloftype,
6862 {
6869 typeName),
6871 else
6873 }
6879 }
6882 /*
6883 * check_of_type
6884 *
6885 * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF. If it
6886 * isn't suitable, throw an error. Currently, we require that the type
6887 * originated with CREATE TYPE AS. We could support any row type, but doing so
6888 * would require handling a number of extra corner cases in the DDL commands.
6889 * (Also, allowing domain-over-composite would open up a can of worms about
6890 * whether and how the domain's constraints should apply to derived tables.)
6891 */
6892 void
6894 {
6899 {
6900 Relation typeRelation;
6906 /*
6907 * Close the parent rel, but keep our AccessShareLock on it until xact
6908 * commit. That will prevent someone else from deleting or ALTERing
6909 * the type before the typed table creation/conversion commits.
6910 */
6912 }
6918 }
6921 /*
6922 * ALTER TABLE ADD COLUMN
6923 *
6924 * Adds an additional attribute to a relation making the assumption that
6925 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
6926 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
6927 * AlterTableCmd's.
6928 *
6929 * ADD COLUMN cannot use the normal ALTER TABLE recursion mechanism, because we
6930 * have to decide at runtime whether to recurse or not depending on whether we
6931 * actually add a column or merely merge with an existing column. (We can't
6932 * check this in a static pre-pass because it won't handle multiple inheritance
6933 * situations correctly.)
6934 */
6935 static void
6939 {
6950 }
6952 /*
6953 * Add a column to a table. The return value is the address of the
6954 * new column in the parent relation.
6955 *
6956 * cmd is pass-by-ref so that we can replace it with the parse-transformed
6957 * copy (but that happens only after we check for IF NOT EXISTS).
6958 */
6959 static ObjectAddress
6964 {
6968 Relation pgclass,
6969 attrdesc;
6970 HeapTuple reltup;
6971 FormData_pg_attribute attribute;
6974 HeapTuple typeTuple;
6975 Oid typeOid;
6976 int32 typmod;
6977 Oid collOid;
6978 Form_pg_type tform;
6983 AclResult aclresult;
6984 ObjectAddress address;
6985 TupleDesc tupdesc;
6988 /* At top level, permission check was done in ATPrepCmd, else do it */
6999 /*
7000 * Are we adding the column to a recursion child? If so, check whether to
7001 * merge with an existing definition for the column. If we do merge, we
7002 * must not recurse. Children will already have the column, and recursing
7003 * into them would mess up attinhcount.
7004 */
7006 {
7007 HeapTuple tuple;
7009 /* Does child already have a column by this name? */
7012 {
7014 Oid ctypeId;
7015 int32 ctypmod;
7016 Oid ccollid;
7018 /* Child column must match on type, typmod, and collation */
7036 /* Bump the existing child att's inhcount */
7046 /* Inform the user about the merge */
7053 }
7054 }
7056 /* skip if the name already exists and if_not_exists is true */
7058 {
7061 }
7063 /*
7064 * Okay, we need to add the column, so go ahead and do parse
7065 * transformation. This can result in queueing up, or even immediately
7066 * executing, subsidiary operations (such as creation of unique indexes);
7067 * so we mustn't do it until we have made the if_not_exists check.
7068 *
7069 * When recursing, the command was already transformed and we needn't do
7070 * so again. Also, if context isn't given we can't transform. (That
7071 * currently happens only for AT_AddColumnToView; we expect that view.c
7072 * passed us a ColumnDef that doesn't need work.)
7073 */
7075 {
7080 }
7082 /*
7083 * Cannot add identity column if table has children, because identity does
7084 * not inherit. (Adding column and identity separately will work.)
7085 */
7087 recurse &&
7100 /* Determine the new attribute's number */
7106 MaxHeapAttributeNumber)));
7118 /* make sure datatype is legal for a column */
7123 /*
7124 * Construct new attribute's pg_attribute entry. (Variable-length fields
7125 * are handled by InsertPgAttributeTuples().)
7126 */
7143 else
7165 /*
7166 * Update pg_class tuple as appropriate
7167 */
7174 /* Post creation hook for new attribute */
7179 /* Make the attribute's catalog entry visible */
7182 /*
7183 * Store the DEFAULT, if any, in the catalogs
7184 */
7186 {
7193 /*
7194 * Attempt to skip a complete table rewrite by storing the specified
7195 * DEFAULT value outside of the heap. This may be disabled inside
7196 * AddRelationNewConstraints if the optimization cannot be applied.
7197 */
7202 /*
7203 * This function is intended for CREATE TABLE, so it processes a
7204 * _list_ of defaults, but we just do one.
7205 */
7209 /* Make the additional catalog changes visible */
7212 /*
7213 * Did the request for a missing value work? If not we'll have to do a
7214 * rewrite
7215 */
7218 }
7220 /*
7221 * Tell Phase 3 to fill in the default expression, if there is one.
7222 *
7223 * If there is no default, Phase 3 doesn't have to do anything, because
7224 * that effectively means that the default is NULL. The heap tuple access
7225 * routines always check for attnum > # of attributes in tuple, and return
7226 * NULL if so, so without any modification of the tuple data we will get
7227 * the effect of NULL values in the new column.
7228 *
7229 * An exception occurs when the new column is of a domain type: the domain
7230 * might have a not-null constraint, or a check constraint that indirectly
7231 * rejects nulls. If there are any domain constraints then we construct
7232 * an explicit NULL default value that will be passed through
7233 * CoerceToDomain processing. (This is a tad inefficient, since it causes
7234 * rewriting the table which we really don't have to do, but the present
7235 * design of domain processing doesn't offer any simple way of checking
7236 * the constraints more directly.)
7237 *
7238 * Note: we use build_column_default, and not just the cooked default
7239 * returned by AddRelationNewConstraints, so that the right thing happens
7240 * when a datatype's default applies.
7241 *
7242 * Note: it might seem that this should happen at the end of Phase 2, so
7243 * that the effects of subsequent subcommands can be taken into account.
7244 * It's intentional that we do it now, though. The new column should be
7245 * filled according to what is said in the ADD COLUMN subcommand, so that
7246 * the effects are the same as if this subcommand had been run by itself
7247 * and the later subcommands had been issued in new ALTER TABLE commands.
7248 *
7249 * We can skip this entirely for relations without storage, since Phase 3
7250 * is certainly not going to touch them. System attributes don't have
7251 * interesting defaults, either.
7252 */
7254 {
7255 /*
7256 * For an identity column, we can't use build_column_default(),
7257 * because the sequence ownership isn't set yet. So do it manually.
7258 */
7260 {
7268 /* must do a rewrite for identity columns */
7270 }
7271 else
7275 {
7276 Oid baseTypeId;
7277 int32 baseTypeMod;
7278 Oid baseTypeColl;
7286 baseTypeId,
7287 typeOid,
7288 typmod,
7289 COERCION_ASSIGNMENT,
7290 COERCE_IMPLICIT_CAST,
7294 }
7297 {
7306 }
7312 {
7313 /*
7314 * If the new column is NOT NULL, and there is no missing value,
7315 * tell Phase 3 it needs to check for NULLs.
7316 */
7318 }
7319 }
7321 /*
7322 * Add needed dependency entries for the new column.
7323 */
7327 /*
7328 * Propagate to children as appropriate. Unlike most other ALTER
7329 * routines, we have to do this one level of recursion at a time; we can't
7330 * use find_all_inheritors to do it in one pass.
7331 */
7332 children =
7335 /*
7336 * If we are told not to recurse, there had better not be any child
7337 * tables; else the addition would put them out of step.
7338 */
7344 /* Children should see column as singly inherited */
7346 {
7351 }
7352 else
7356 {
7358 Relation childrel;
7361 /* find_inheritance_children already got lock */
7365 /* Find or create work queue entry for this table */
7368 /* Recurse to child; return value is ignored */
7374 }
7378 }
7380 /*
7381 * If a new or renamed column will collide with the name of an existing
7382 * column and if_not_exists is false then error out, else do nothing.
7383 */
7384 static bool
7387 {
7388 HeapTuple attTuple;
7391 /*
7392 * this test is deliberately not attisdropped-aware, since if one tries to
7393 * add a column matching a dropped column name, it's gonna fail anyway.
7394 */
7404 /*
7405 * We throw a different error message for conflicts with system column
7406 * names, since they are normally not shown and the user might otherwise
7407 * be confused about the reason for the conflict.
7408 */
7413 colname)));
7414 else
7415 {
7417 {
7423 }
7429 }
7432 }
7434 /*
7435 * Install a column's dependency on its datatype.
7436 */
7437 static void
7439 {
7440 ObjectAddress myself,
7441 referenced;
7450 }
7452 /*
7453 * Install a column's dependency on its collation.
7454 */
7455 static void
7457 {
7458 ObjectAddress myself,
7459 referenced;
7461 /* We know the default collation is pinned, so don't bother recording it */
7463 {
7471 }
7472 }
7474 /*
7475 * ALTER TABLE ALTER COLUMN DROP NOT NULL
7476 *
7477 * Return the address of the modified column. If the column was already
7478 * nullable, InvalidObjectAddress is returned.
7479 */
7480 static ObjectAddress
7482 LOCKMODE lockmode)
7483 {
7484 HeapTuple tuple;
7485 HeapTuple conTup;
7486 Form_pg_attribute attTup;
7487 AttrNumber attnum;
7488 Relation attr_rel;
7489 ObjectAddress address;
7492 /*
7493 * lookup the attribute
7494 */
7508 /* If the column is already nullable there's nothing to do. */
7510 {
7513 }
7515 /* Prevent them from altering a system attribute */
7520 colName)));
7528 /*
7529 * It's not OK to remove a constraint only for the parent and leave it in
7530 * the children, so disallow that.
7531 */
7533 {
7535 {
7536 PartitionDesc partdesc;
7545 }
7548 {
7552 colName),
7554 }
7555 }
7557 /*
7558 * If rel is partition, shouldn't drop NOT NULL if parent has the same.
7559 */
7561 {
7565 AttrNumber parent_attnum;
7572 colName)));
7574 }
7576 /*
7577 * Find the constraint that makes this column NOT NULL.
7578 */
7581 {
7584 /*
7585 * There's no not-null constraint, so throw an error. If the column
7586 * is in a primary key, we can throw a specific error. Otherwise,
7587 * this is unexpected.
7588 */
7591 pkcols))
7596 /* this shouldn't happen */
7599 }
7613 }
7615 /*
7616 * Helper to set pg_attribute.attnotnull if it isn't set, and to tell phase 3
7617 * to verify it; recurses to apply the same to children.
7618 *
7619 * When called to alter an existing table, 'wqueue' must be given so that we can
7620 * queue a check that existing tuples pass the constraint. When called from
7621 * table creation, 'wqueue' should be passed as NULL.
7622 *
7623 * Returns true if the flag was set in any table, otherwise false.
7624 */
7625 static bool
7627 LOCKMODE lockmode)
7628 {
7629 HeapTuple tuple;
7630 Form_pg_attribute attForm;
7639 {
7640 Relation attr_rel;
7649 /*
7650 * And set up for existing values to be checked, unless another
7651 * constraint already proves this.
7652 */
7654 {
7659 }
7662 }
7665 {
7671 {
7673 Relation childrel;
7674 AttrNumber childattno;
7676 /* find_inheritance_children already got lock */
7686 }
7687 }
7690 }
7692 /*
7693 * ALTER TABLE ALTER COLUMN SET NOT NULL
7694 *
7695 * Add a not-null constraint to a single table and its children. Returns
7696 * the address of the constraint added to the parent relation, if one gets
7697 * added, or InvalidObjectAddress otherwise.
7698 *
7699 * We must recurse to child tables during execution, rather than using
7700 * ALTER TABLE's normal prep-time recursion.
7701 */
7702 static ObjectAddress
7705 LOCKMODE lockmode)
7706 {
7707 HeapTuple tuple;
7708 Relation constr_rel;
7709 ScanKeyData skey;
7710 SysScanDesc conscan;
7711 AttrNumber attnum;
7712 ObjectAddress address;
7719 /*
7720 * In cases of multiple inheritance, we might visit the same child more
7721 * than once. In the topmost call, set up a list that we fill with all
7722 * visited relations, to skip those.
7723 */
7725 {
7728 }
7733 /* At top level, permission check was done in ATPrepCmd, else do it */
7735 {
7738 }
7747 /* Prevent them from altering a system attribute */
7752 colName)));
7754 /* See if there's already a constraint */
7757 Anum_pg_constraint_conrelid,
7764 {
7767 HeapTuple copytup;
7778 /*
7779 * If we find an appropriate constraint, we're almost done, but just
7780 * need to change some properties on it: if we're recursing, increment
7781 * coninhcount; if not, set conislocal if not already set.
7782 */
7784 {
7787 }
7789 {
7792 }
7795 {
7798 }
7805 else
7807 }
7812 /*
7813 * If we're asked not to recurse, and children exist, raise an error for
7814 * partitioned tables. For inheritance, we act as if NO INHERIT had been
7815 * specified.
7816 */
7820 {
7826 else
7828 }
7830 /*
7831 * No constraint exists; we must add one. First determine a name to use,
7832 * if we haven't already.
7833 */
7835 {
7840 NIL);
7841 }
7854 /* and do it */
7863 /*
7864 * Mark pg_attribute.attnotnull for the column. Tell that function not to
7865 * recurse, because we're going to do it here.
7866 */
7869 /*
7870 * Recurse to propagate the constraint to children that don't have one.
7871 */
7873 {
7878 lockmode);
7881 {
7882 Relation childrel;
7891 }
7892 }
7895 }
7897 /*
7898 * ALTER TABLE ALTER COLUMN SET ATTNOTNULL
7899 *
7900 * This doesn't exist in the grammar; it's used when creating a
7901 * primary key and the column is not already marked attnotnull.
7902 */
7903 static ObjectAddress
7906 {
7907 AttrNumber attnum;
7917 /*
7918 * Make the change, if necessary, and only if so report the column as
7919 * changed
7920 */
7926 }
7928 /*
7929 * NotNullImpliedByRelConstraints
7930 * Does rel's existing constraints imply NOT NULL for the given attribute?
7931 */
7932 static bool
7934 {
7945 /*
7946 * argisrow = false is correct even for a composite column, because
7947 * attnotnull does not represent a SQL-spec IS NOT NULL test in such a
7948 * case, just IS DISTINCT FROM NULL.
7949 */
7954 {
7956 (errmsg_internal("existing constraints on column \"%s.%s\" are sufficient to prove that it does not contain nulls",
7959 }
7962 }
7964 /*
7965 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
7966 *
7967 * Return the address of the affected column.
7968 */
7969 static ObjectAddress
7972 {
7974 AttrNumber attnum;
7975 ObjectAddress address;
7977 /*
7978 * get the number of the attribute
7979 */
7987 /* Prevent them from altering a system attribute */
7992 colName)));
7999 /* translator: %s is an SQL ALTER command */
8008 newDefault || TupleDescAttr(tupdesc, attnum - 1)->attgenerated != ATTRIBUTE_GENERATED_STORED ? 0 :
8009 /* translator: %s is an SQL ALTER command */
8013 /*
8014 * Remove any old default for the column. We use RESTRICT here for
8015 * safety, but at present we do not expect anything to depend on the
8016 * default.
8017 *
8018 * We treat removing the existing default as an internal operation when it
8019 * is preparatory to adding a new default, but as a user-initiated
8020 * operation when the user asked for a drop.
8021 */
8026 {
8027 /* SET DEFAULT */
8036 /*
8037 * This function is intended for CREATE TABLE, so it processes a
8038 * _list_ of defaults, but we just do one.
8039 */
8042 }
8047 }
8049 /*
8050 * Add a pre-cooked default expression.
8051 *
8052 * Return the address of the affected column.
8053 */
8054 static ObjectAddress
8057 {
8058 ObjectAddress address;
8060 /* We assume no checking is required */
8062 /*
8063 * Remove any old default for the column. We use RESTRICT here for
8064 * safety, but at present we do not expect anything to depend on the
8065 * default. (In ordinary cases, there could not be a default in place
8066 * anyway, but it's possible when combining LIKE with inheritance.)
8067 */
8076 }
8078 /*
8079 * ALTER TABLE ALTER COLUMN ADD IDENTITY
8080 *
8081 * Return the address of the affected column.
8082 */
8083 static ObjectAddress
8086 {
8087 Relation attrelation;
8088 HeapTuple tuple;
8089 Form_pg_attribute attTup;
8090 AttrNumber attnum;
8091 ObjectAddress address;
8105 /* Can't alter a system attribute */
8110 colName)));
8112 /*
8113 * Creating a column as identity implies NOT NULL, so adding the identity
8114 * to an existing column that is not NOT NULL would create a state that
8115 * cannot be reproduced without contortions.
8116 */
8120 errmsg("column \"%s\" of relation \"%s\" must be declared NOT NULL before identity can be added",
8148 }
8150 /*
8151 * ALTER TABLE ALTER COLUMN SET { GENERATED or sequence options }
8152 *
8153 * Return the address of the affected column.
8154 */
8155 static ObjectAddress
8157 {
8160 HeapTuple tuple;
8161 Form_pg_attribute attTup;
8162 AttrNumber attnum;
8163 Relation attrelation;
8164 ObjectAddress address;
8167 {
8171 {
8177 }
8178 else
8181 }
8183 /*
8184 * Even if there is nothing to change here, we run all the checks. There
8185 * will be a subsequent ALTER SEQUENCE that relies on everything being
8186 * there.
8187 */
8204 colName)));
8213 {
8222 }
8223 else
8230 }
8232 /*
8233 * ALTER TABLE ALTER COLUMN DROP IDENTITY
8234 *
8235 * Return the address of the affected column.
8236 */
8237 static ObjectAddress
8239 {
8240 HeapTuple tuple;
8241 Form_pg_attribute attTup;
8242 AttrNumber attnum;
8243 Relation attrelation;
8244 ObjectAddress address;
8245 Oid seqid;
8246 ObjectAddress seqaddress;
8263 colName)));
8266 {
8272 else
8273 {
8280 }
8281 }
8295 /* drop the internal sequence */
8306 }
8308 /*
8309 * ALTER TABLE ALTER COLUMN DROP EXPRESSION
8310 */
8311 static void
8312 ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
8313 {
8314 /*
8315 * Reject ONLY if there are child tables. We could implement this, but it
8316 * is a bit complicated. GENERATED clauses must be attached to the column
8317 * definition and cannot be added later like DEFAULT, so if a child table
8318 * has a generation expression that the parent does not have, the child
8319 * column will necessarily be an attislocal column. So to implement ONLY
8320 * here, we'd need extra code to update attislocal of the direct child
8321 * tables, somewhat similar to how DROP COLUMN does it, so that the
8322 * resulting state can be properly dumped and restored.
8323 */
8330 /*
8331 * Cannot drop generation expression from inherited columns.
8332 */
8334 {
8335 HeapTuple tuple;
8336 Form_pg_attribute attTup;
8351 }
8352 }
8354 /*
8355 * Return the address of the affected column.
8356 */
8357 static ObjectAddress
8359 {
8360 HeapTuple tuple;
8361 Form_pg_attribute attTup;
8362 AttrNumber attnum;
8363 Relation attrelation;
8364 Oid attrdefoid;
8365 ObjectAddress address;
8382 colName)));
8385 {
8391 else
8392 {
8399 }
8400 }
8402 /*
8403 * Mark the column as no longer generated. (The atthasdef flag needs to
8404 * get cleared too, but RemoveAttrDefault will handle that.)
8405 */
8411 attnum);
8416 /*
8417 * Drop the dependency records of the GENERATED expression, in particular
8418 * its INTERNAL dependency on the column, which would otherwise cause
8419 * dependency.c to refuse to perform the deletion.
8420 */
8427 /* Make above changes visible */
8430 /*
8431 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8432 * safety, but at present we do not expect anything to depend on the
8433 * default.
8434 */
8441 }
8443 /*
8444 * ALTER TABLE ALTER COLUMN SET STATISTICS
8445 *
8446 * Return value is the address of the modified column
8447 */
8448 static ObjectAddress
8449 ATExecSetStatistics(Relation rel, const char *colName, int16 colNum, Node *newValue, LOCKMODE lockmode)
8450 {
8452 Relation attrelation;
8453 HeapTuple tuple;
8454 Form_pg_attribute attrtuple;
8455 AttrNumber attnum;
8456 ObjectAddress address;
8458 /*
8459 * We allow referencing columns by numbers only for indexes, since table
8460 * column numbers could contain gaps if columns are later dropped.
8461 */
8472 /*
8473 * Limit target to a sane range
8474 */
8476 {
8480 newtarget)));
8481 }
8483 {
8488 newtarget)));
8489 }
8494 {
8502 }
8503 else
8504 {
8512 }
8521 colName)));
8525 {
8537 }
8553 }
8555 /*
8556 * Return value is the address of the modified column
8557 */
8558 static ObjectAddress
8561 {
8562 Relation attrelation;
8563 HeapTuple tuple,
8564 newtuple;
8565 Form_pg_attribute attrtuple;
8566 AttrNumber attnum;
8567 Datum datum,
8568 newOptions;
8570 ObjectAddress address;
8591 colName)));
8593 /* Generate new proposed attoptions (text array) */
8599 /* Validate new options */
8602 /* Build new tuple. */
8607 else
8613 /* Update system catalog. */
8629 }
8631 /*
8632 * Helper function for ATExecSetStorage and ATExecSetCompression
8633 *
8634 * Set the attstorage and/or attcompression fields for index columns
8635 * associated with the specified table column.
8636 */
8637 static void
8639 AttrNumber attnum,
8642 LOCKMODE lockmode)
8643 {
8647 {
8649 Relation indrel;
8651 HeapTuple tuple;
8656 {
8658 {
8661 }
8662 }
8665 {
8668 }
8673 {
8689 }
8692 }
8693 }
8695 /*
8696 * ALTER TABLE ALTER COLUMN SET STORAGE
8697 *
8698 * Return value is the address of the modified column
8699 */
8700 static ObjectAddress
8702 {
8703 Relation attrelation;
8704 HeapTuple tuple;
8705 Form_pg_attribute attrtuple;
8706 AttrNumber attnum;
8707 ObjectAddress address;
8725 colName)));
8735 /*
8736 * Apply the change to indexes as well (only for simple index columns,
8737 * matching behavior of index.c ConstructTupleDescriptor()).
8738 */
8742 lockmode);
8751 }
8754 /*
8755 * ALTER TABLE DROP COLUMN
8756 *
8757 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
8758 * because we have to decide at runtime whether to recurse or not depending
8759 * on whether attinhcount goes to zero or not. (We can't check this in a
8760 * static pre-pass because it won't handle multiple inheritance situations
8761 * correctly.)
8762 */
8763 static void
8767 {
8778 }
8780 /*
8781 * Drops column 'colName' from relation 'rel' and returns the address of the
8782 * dropped column. The column is also dropped (or marked as no longer
8783 * inherited from relation) from the relation's inheritance children, if any.
8784 *
8785 * In the recursive invocations for inheritance child relations, instead of
8786 * dropping the column directly (if to be dropped at all), its object address
8787 * is added to 'addrs', which must be non-NULL in such invocations. All
8788 * columns are dropped at the same time after all the children have been
8789 * checked recursively.
8790 */
8791 static ObjectAddress
8793 DropBehavior behavior,
8797 {
8798 HeapTuple tuple;
8799 Form_pg_attribute targetatt;
8800 AttrNumber attnum;
8802 ObjectAddress object;
8805 /* At top level, permission check was done in ATPrepCmd, else do it */
8809 /* Initialize addrs on the first invocation */
8814 /*
8815 * get the number of the attribute
8816 */
8819 {
8821 {
8826 }
8827 else
8828 {
8833 }
8834 }
8839 /* Can't drop a system attribute */
8844 colName)));
8846 /*
8847 * Don't drop inherited columns, unless recursing (presumably from a drop
8848 * of the parent column)
8849 */
8854 colName)));
8856 /*
8857 * Don't drop columns used in the partition key, either. (If we let this
8858 * go through, the key column's dependencies would cause a cascaded drop
8859 * of the whole table, which is surely not what the user expected.)
8860 */
8871 /*
8872 * Propagate to children as appropriate. Unlike most other ALTER
8873 * routines, we have to do this one level of recursion at a time; we can't
8874 * use find_all_inheritors to do it in one pass.
8875 */
8876 children =
8880 {
8881 Relation attr_rel;
8884 /*
8885 * In case of a partitioned table, the column must be dropped from the
8886 * partitions as well.
8887 */
8896 {
8898 Relation childrel;
8899 Form_pg_attribute childatt;
8901 /* find_inheritance_children already got lock */
8916 {
8917 /*
8918 * If the child column has other definition sources, just
8919 * decrement its inheritance count; if not, recurse to delete
8920 * it.
8921 */
8923 {
8924 /* Time to delete this child column, too */
8928 }
8929 else
8930 {
8931 /* Child column must survive my deletion */
8936 /* Make update visible */
8938 }
8939 }
8940 else
8941 {
8942 /*
8943 * If we were told to drop ONLY in this table (no recursion),
8944 * we need to mark the inheritors' attributes as locally
8945 * defined rather than inherited.
8946 */
8952 /* Make update visible */
8954 }
8959 }
8961 }
8963 /* Add object to delete */
8970 {
8971 /* Recursion has ended, drop everything that was collected */
8974 }
8977 }
8979 /*
8980 * Prepare to add a primary key on an inheritance parent, by adding NOT NULL
8981 * constraint on its children.
8982 */
8983 static void
8986 {
8992 /* No work if not creating a primary key */
8999 /* No work if no legacy inheritance children are present */
9007 {
9025 }
9028 {
9038 {
9039 /* ATPrepCmd copies newcmd, so we can scribble on it here */
9044 }
9047 }
9048 }
9050 /*
9051 * ALTER TABLE ADD INDEX
9052 *
9053 * There is no such command in the grammar, but parse_utilcmd.c converts
9054 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
9055 * us schedule creation of the index at the appropriate time during ALTER.
9056 *
9057 * Return value is the address of the new index.
9058 */
9059 static ObjectAddress
9062 {
9066 ObjectAddress address;
9071 /* The IndexStmt has already been through transformIndexStmt */
9074 /* suppress schema rights check when rebuilding existing index */
9076 /* skip index build if phase 3 will do it or we're reusing an old one */
9078 /* suppress notices when rebuilding existing index */
9082 stmt,
9088 check_rights,
9090 skip_build,
9091 quiet);
9093 /*
9094 * If TryReuseIndex() stashed a relfilenumber for us, we used it for the
9095 * new index instead of building from scratch. Restore associated fields.
9096 * This may store InvalidSubTransactionId in both fields, in which case
9097 * relcache.c will assume it can rebuild the relcache entry. Hence, do
9098 * this after the CCI that made catalog rows visible to any rebuild. The
9099 * DROP of the old edition of this index will have scheduled the storage
9100 * for deletion at commit, so cancel that pending deletion.
9101 */
9103 {
9110 }
9113 }
9115 /*
9116 * ALTER TABLE ADD STATISTICS
9117 *
9118 * This is no such command in the grammar, but we use this internally to add
9119 * AT_ReAddStatistics subcommands to rebuild extended statistics after a table
9120 * column type change.
9121 */
9122 static ObjectAddress
9125 {
9126 ObjectAddress address;
9130 /* The CreateStatsStmt has already been through transformStatsStmt */
9136 }
9138 /*
9139 * ALTER TABLE ADD CONSTRAINT USING INDEX
9140 *
9141 * Returns the address of the new constraint.
9142 */
9143 static ObjectAddress
9146 {
9148 Relation indexRel;
9153 ObjectAddress address;
9154 bits16 flags;
9160 /*
9161 * Doing this on partitioned tables is not a simple feature to implement,
9162 * so let's punt for now.
9163 */
9175 /* this should have been checked at parse time */
9179 /*
9180 * Determine name to assign to constraint. We require a constraint to
9181 * have the same name as the underlying index; therefore, use the index's
9182 * existing name as the default constraint name, and if the user
9183 * explicitly gives some other name for the constraint, rename the index
9184 * to match.
9185 */
9190 {
9195 }
9197 /* Extra checks needed if making primary key */
9201 /* Note we currently don't support EXCLUSION constraints here */
9204 else
9207 /* Create the catalog entries for the constraint */
9209 INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
9215 index_oid,
9216 InvalidOid,
9217 indexInfo,
9218 constraintName,
9219 constraintType,
9220 flags,
9221 allowSystemTableMods,
9227 }
9229 /*
9230 * ALTER TABLE ADD CONSTRAINT
9231 *
9232 * Return value is the address of the new constraint; if no constraint was
9233 * added, InvalidObjectAddress is returned.
9234 */
9235 static ObjectAddress
9238 LOCKMODE lockmode)
9239 {
9244 /*
9245 * Currently, we only expect to see CONSTR_CHECK, CONSTR_NOTNULL and
9246 * CONSTR_FOREIGN nodes arriving here (see the preprocessing done in
9247 * parse_utilcmd.c).
9248 */
9250 {
9253 address =
9256 lockmode);
9261 /*
9262 * Assign or validate constraint name
9263 */
9265 {
9274 }
9275 else
9281 NIL);
9284 newConstraint,
9286 lockmode);
9292 }
9295 }
9297 /*
9298 * Generate the column-name portion of the constraint name for a new foreign
9299 * key given the list of column names that reference the referenced
9300 * table. This will be passed to ChooseConstraintName along with the parent
9301 * table name and the "fkey" suffix.
9302 *
9303 * We know that less than NAMEDATALEN characters will actually be used, so we
9304 * can truncate the result once we've generated that many.
9305 *
9306 * XXX see also ChooseExtendedStatisticNameAddition and
9307 * ChooseIndexNameAddition.
9308 */
9311 {
9318 {
9324 /*
9325 * At this point we have buflen <= NAMEDATALEN. name should be less
9326 * than NAMEDATALEN already, but use strlcpy for paranoia.
9327 */
9332 }
9334 }
9336 /*
9337 * Add a check or not-null constraint to a single table and its children.
9338 * Returns the address of the constraint added to the parent relation,
9339 * if one gets added, or InvalidObjectAddress otherwise.
9340 *
9341 * Subroutine for ATExecAddConstraint.
9342 *
9343 * We must recurse to child tables during execution, rather than using
9344 * ALTER TABLE's normal prep-time recursion. The reason is that all the
9345 * constraints *must* be given the same name, else they won't be seen as
9346 * related later. If the user didn't explicitly specify a name, then
9347 * AddRelationNewConstraints would normally assign different names to the
9348 * child constraints. To fix that, we must capture the name assigned at
9349 * the parent table and pass that down.
9350 */
9351 static ObjectAddress
9355 {
9362 /* At top level, permission check was done in ATPrepCmd, else do it */
9366 /*
9367 * Call AddRelationNewConstraints to do the work, making sure it works on
9368 * a copy of the Constraint so transformExpr can't modify the original. It
9369 * returns a list of cooked constraints.
9370 *
9371 * If the constraint ends up getting merged with a pre-existing one, it's
9372 * omitted from the returned list, which is what we want: we do not need
9373 * to do any validation work. That can only happen at child tables,
9374 * though, since we disallow merging at the top level.
9375 */
9382 * here */
9384 /* we don't expect more than one constraint here */
9387 /* Add each to-be-validated constraint to Phase 3's queue */
9389 {
9393 {
9402 }
9404 /* Save the actually assigned name if it was defaulted */
9408 /*
9409 * If adding a not-null constraint, set the pg_attribute flag and tell
9410 * phase 3 to verify existing rows, if needed.
9411 */
9417 }
9419 /* At this point we must have a locked-down name to use */
9422 /* Advance command counter in case same table is visited multiple times */
9425 /*
9426 * If the constraint got merged with an existing constraint, we're done.
9427 * We mustn't recurse to child tables in this case, because they've
9428 * already got the constraint, and visiting them again would lead to an
9429 * incorrect value for coninhcount.
9430 */
9434 /*
9435 * If adding a NO INHERIT constraint, no need to find our children.
9436 */
9440 /*
9441 * Propagate to children as appropriate. Unlike most other ALTER
9442 * routines, we have to do this one level of recursion at a time; we can't
9443 * use find_all_inheritors to do it in one pass.
9444 */
9445 children =
9448 /*
9449 * Check if ONLY was specified with ALTER TABLE. If so, allow the
9450 * constraint creation only if there are no children currently. Error out
9451 * otherwise.
9452 */
9458 /*
9459 * The constraint must appear as inherited in children, so create a
9460 * modified constraint object to use.
9461 */
9465 {
9467 Relation childrel;
9470 /* find_inheritance_children already got lock */
9474 /* Find or create work queue entry for this table */
9477 /*
9478 * Recurse to child. XXX if we didn't create a constraint on the
9479 * parent because it already existed, and we do create one on a child,
9480 * should we return that child's constraint ObjectAddress here?
9481 */
9486 }
9489 }
9491 /*
9492 * Add a foreign-key constraint to a single table; return the new constraint's
9493 * address.
9494 *
9495 * Subroutine for ATExecAddConstraint. Must already hold exclusive
9496 * lock on the rel, and have done appropriate validity checks for it.
9497 * We do permissions checks here, however.
9498 *
9499 * When the referenced or referencing tables (or both) are partitioned,
9500 * multiple pg_constraint rows are required -- one for each partitioned table
9501 * and each partition on each side (fortunately, not one for every combination
9502 * thereof). We also need action triggers on each leaf partition on the
9503 * referenced side, and check triggers on each leaf partition on the
9504 * referencing side.
9505 */
9506 static ObjectAddress
9510 {
9511 Relation pkrel;
9523 numpks,
9524 numfkdelsetcols;
9525 Oid indexOid;
9527 ObjectAddress address;
9530 /*
9531 * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
9532 * delete rows out from under us.
9533 */
9536 else
9539 /*
9540 * Validity checks (permission checks wait till we have the column
9541 * numbers)
9542 */
9544 {
9548 errmsg("cannot use ONLY for foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9554 errmsg("cannot add NOT VALID foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9558 }
9573 /*
9574 * References from permanent or unlogged tables to temp tables, and from
9575 * permanent tables to unlogged tables, are disallowed because the
9576 * referenced data can vanish out from under us. References from temp
9577 * tables to any other table type are also disallowed, because other
9578 * backends might need to run the RI triggers on the perm table, but they
9579 * can't reliably see tuples in the local buffers of other backends.
9580 */
9582 {
9606 }
9608 /*
9609 * Look up the referencing attributes to make sure they exist, and record
9610 * their attnums and type OIDs.
9611 */
9623 /*
9624 * If the attribute list for the referenced table was omitted, lookup the
9625 * definition of the primary key and use it. Otherwise, validate the
9626 * supplied attribute list. In either case, discover the index OID and
9627 * index opclasses, and the attnums and type OIDs of the attributes.
9628 */
9630 {
9634 opclasses);
9635 }
9636 else
9637 {
9641 /* Look for an index matching the column list */
9643 opclasses);
9644 }
9646 /*
9647 * Now we can check permissions.
9648 */
9651 /*
9652 * Check some things for generated columns.
9653 */
9655 {
9659 {
9660 /*
9661 * Check restrictions on UPDATE/DELETE actions, per SQL standard
9662 */
9676 }
9677 }
9679 /*
9680 * Look up the equality operators to use in the constraint.
9681 *
9682 * Note that we have to be careful about the difference between the actual
9683 * PK column type and the opclass' declared input type, which might be
9684 * only binary-compatible with it. The declared opcintype is the right
9685 * thing to probe pg_amop with.
9686 */
9692 /*
9693 * On the strength of a previous constraint, we might avoid scanning
9694 * tables to validate this one. See below.
9695 */
9700 {
9703 Oid fktyped;
9704 HeapTuple cla_ht;
9705 Form_pg_opclass cla_tup;
9706 Oid amid;
9707 Oid opfamily;
9708 Oid opcintype;
9709 Oid pfeqop;
9710 Oid ppeqop;
9711 Oid ffeqop;
9712 int16 eqstrategy;
9713 Oid pfeqop_right;
9715 /* We need several fields out of the pg_opclass entry */
9725 /*
9726 * Check it's a btree; currently this can never fail since no other
9727 * index AMs support unique indexes. If we ever did have other types
9728 * of unique indexes, we'd need a way to determine which operator
9729 * strategy number is equality. (Is it reasonable to insist that
9730 * every such index AM use btree's number for equality?)
9731 */
9736 /*
9737 * There had better be a primary equality operator for the index.
9738 * We'll use it for PK = PK comparisons.
9739 */
9741 eqstrategy);
9747 /*
9748 * Are there equality operators that take exactly the FK type? Assume
9749 * we should look through any domain here.
9750 */
9754 eqstrategy);
9756 {
9759 eqstrategy);
9760 }
9761 else
9762 {
9763 /* keep compiler quiet */
9766 }
9769 {
9770 /*
9771 * Otherwise, look for an implicit cast from the FK type to the
9772 * opcintype, and if found, use the primary equality operator.
9773 * This is a bit tricky because opcintype might be a polymorphic
9774 * type such as ANYARRAY or ANYENUM; so what we have to test is
9775 * whether the two actual column types can be concurrently cast to
9776 * that type. (Otherwise, we'd fail to reject combinations such
9777 * as int[] and point[].)
9778 */
9787 COERCION_IMPLICIT))
9788 {
9791 }
9792 }
9807 {
9808 /*
9809 * When a pfeqop changes, revalidate the constraint. We could
9810 * permit intra-opfamily changes, but that adds subtle complexity
9811 * without any concrete benefit for core types. We need not
9812 * assess ppeqop or ffeqop, which RI_Initial_Check() does not use.
9813 */
9816 old_pfeqop_item);
9817 }
9819 {
9820 Oid old_fktype;
9821 Oid new_fktype;
9822 CoercionPathType old_pathtype;
9823 CoercionPathType new_pathtype;
9824 Oid old_castfunc;
9825 Oid new_castfunc;
9829 /*
9830 * Identify coercion pathways from each of the old and new FK-side
9831 * column types to the right (foreign) operand type of the pfeqop.
9832 * We may assume that pg_constraint.conkey is not changing.
9833 */
9841 /*
9842 * Upon a change to the cast from the FK column to its pfeqop
9843 * operand, revalidate the constraint. For this evaluation, a
9844 * binary coercion cast is equivalent to no cast at all. While
9845 * type implementors should design implicit casts with an eye
9846 * toward consistency of operations like equality, we cannot
9847 * assume here that they have done so.
9848 *
9849 * A function with a polymorphic argument could change behavior
9850 * arbitrarily in response to get_fn_expr_argtype(). Therefore,
9851 * when the cast destination is polymorphic, we only avoid
9852 * revalidation if the input type has not changed at all. Given
9853 * just the core data types and operator classes, this requirement
9854 * prevents no would-be optimizations.
9855 *
9856 * If the cast converts from a base type to a domain thereon, then
9857 * that domain type must be the opcintype of the unique index.
9858 * Necessarily, the primary key column must then be of the domain
9859 * type. Since the constraint was previously valid, all values on
9860 * the foreign side necessarily exist on the primary side and in
9861 * turn conform to the domain. Consequently, we need not treat
9862 * domains specially here.
9863 *
9864 * Since we require that all collations share the same notion of
9865 * equality (which they do, because texteq reduces to bitwise
9866 * equality), we don't compare collation here.
9867 *
9868 * We need not directly consider the PK type. It's necessarily
9869 * binary coercible to the opcintype of the unique index column,
9870 * and ri_triggers.c will only deal with PK datums in terms of
9871 * that opcintype. Changing the opcintype also changes pfeqop.
9872 */
9877 }
9882 }
9884 /*
9885 * Create all the constraint and trigger objects, recursing to partitions
9886 * as necessary. First handle the referenced side.
9887 */
9889 indexOid,
9891 numfks,
9892 pkattnum,
9893 fkattnum,
9894 pfeqoperators,
9895 ppeqoperators,
9896 ffeqoperators,
9897 numfkdelsetcols,
9898 fkdelsetcols,
9899 old_check_ok,
9902 /* Now handle the referencing side. */
9904 indexOid,
9906 numfks,
9907 pkattnum,
9908 fkattnum,
9909 pfeqoperators,
9910 ppeqoperators,
9911 ffeqoperators,
9912 numfkdelsetcols,
9913 fkdelsetcols,
9914 old_check_ok,
9915 lockmode,
9918 /*
9919 * Done. Close pk table, but keep lock until we've committed.
9920 */
9924 }
9926 /*
9927 * validateFkOnDeleteSetColumns
9928 * Verifies that columns used in ON DELETE SET NULL/DEFAULT (...)
9929 * column lists are valid.
9930 */
9931 void
9935 {
9937 {
9942 {
9944 {
9947 }
9948 }
9951 {
9957 }
9958 }
9959 }
9961 /*
9962 * addFkRecurseReferenced
9963 * subroutine for ATAddForeignKeyConstraint; recurses on the referenced
9964 * side of the constraint
9965 *
9966 * Create pg_constraint rows for the referenced side of the constraint,
9967 * referencing the parent of the referencing side; also create action triggers
9968 * on leaf partitions. If the table is partitioned, recurse to handle each
9969 * partition.
9970 *
9971 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
9972 * of an ALTER TABLE sequence.
9973 * fkconstraint is the constraint being added.
9974 * rel is the root referencing relation.
9975 * pkrel is the referenced relation; might be a partition, if recursing.
9976 * indexOid is the OID of the index (on pkrel) implementing this constraint.
9977 * parentConstr is the OID of a parent constraint; InvalidOid if this is a
9978 * top-level constraint.
9979 * numfks is the number of columns in the foreign key
9980 * pkattnum is the attnum array of referenced attributes.
9981 * fkattnum is the attnum array of referencing attributes.
9982 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
9983 * (...) clause
9984 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
9985 * NULL/DEFAULT clause
9986 * pf/pp/ffeqoperators are OID array of operators between columns.
9987 * old_check_ok signals that this constraint replaces an existing one that
9988 * was already validated (thus this one doesn't need validation).
9989 * parentDelTrigger and parentUpdTrigger, when being recursively called on
9990 * a partition, are the OIDs of the parent action triggers for DELETE and
9991 * UPDATE respectively.
9992 */
9993 static ObjectAddress
10002 {
10003 ObjectAddress address;
10004 Oid constrOid;
10009 Oid deleteTriggerOid,
10010 updateTriggerOid;
10012 /*
10013 * Verify relkind for each referenced partition. At the top level, this
10014 * is redundant with a previous check, but we need it when recursing.
10015 */
10023 /*
10024 * Caller supplies us with a constraint name; however, it may be used in
10025 * this partition, so come up with a different one in that case.
10026 */
10034 else
10038 {
10042 }
10043 else
10044 {
10048 /*
10049 * always inherit for partitioned tables, never for legacy inheritance
10050 */
10052 }
10054 /*
10055 * Record the FK constraint in pg_constraint.
10056 */
10059 CONSTRAINT_FOREIGN,
10063 parentConstr,
10065 fkattnum,
10066 numfks,
10067 numfks,
10069 indexOid,
10071 pkattnum,
10072 pfeqoperators,
10073 ppeqoperators,
10074 ffeqoperators,
10075 numfks,
10078 fkdelsetcols,
10079 numfkdelsetcols,
10083 NULL,
10091 /*
10092 * Mark the child constraint as part of the parent constraint; it must not
10093 * be dropped on its own. (This constraint is deleted when the partition
10094 * is detached, but a special check needs to occur that the partition
10095 * contains no referenced values.)
10096 */
10098 {
10099 ObjectAddress referenced;
10103 }
10105 /* make new constraint visible, in case we add more */
10108 /*
10109 * Create the action triggers that enforce the constraint.
10110 */
10112 fkconstraint,
10117 /*
10118 * If the referenced table is partitioned, recurse on ourselves to handle
10119 * each partition. We need one pg_constraint row created for each
10120 * partition in addition to the pg_constraint row for the parent table.
10121 */
10123 {
10127 {
10128 Relation partRel;
10131 Oid partIndexId;
10135 /*
10136 * Map the attribute numbers in the referenced side of the FK
10137 * definition to match the partition's column layout.
10138 */
10143 {
10147 }
10148 else
10151 /* do the deed */
10161 old_check_ok,
10164 /* Done -- clean up (but keep the lock) */
10167 {
10170 }
10171 }
10172 }
10175 }
10177 /*
10178 * addFkRecurseReferencing
10179 * subroutine for ATAddForeignKeyConstraint and CloneFkReferencing
10180 *
10181 * If the referencing relation is a plain relation, create the necessary check
10182 * triggers that implement the constraint, and set up for Phase 3 constraint
10183 * verification. If the referencing relation is a partitioned table, then
10184 * we create a pg_constraint row for it and recurse on this routine for each
10185 * partition.
10186 *
10187 * We assume that the referenced relation is locked against concurrent
10188 * deletions. If it's a partitioned relation, every partition must be so
10189 * locked.
10190 *
10191 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10192 * of an ALTER TABLE sequence.
10193 * fkconstraint is the constraint being added.
10194 * rel is the referencing relation; might be a partition, if recursing.
10195 * pkrel is the root referenced relation.
10196 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10197 * parentConstr is the OID of the parent constraint (there is always one).
10198 * numfks is the number of columns in the foreign key
10199 * pkattnum is the attnum array of referenced attributes.
10200 * fkattnum is the attnum array of referencing attributes.
10201 * pf/pp/ffeqoperators are OID array of operators between columns.
10202 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10203 * (...) clause
10204 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10205 * NULL/DEFAULT clause
10206 * old_check_ok signals that this constraint replaces an existing one that
10207 * was already validated (thus this one doesn't need validation).
10208 * lockmode is the lockmode to acquire on partitions when recursing.
10209 * parentInsTrigger and parentUpdTrigger, when being recursively called on
10210 * a partition, are the OIDs of the parent check triggers for INSERT and
10211 * UPDATE respectively.
10212 */
10213 static void
10221 {
10222 Oid insertTriggerOid,
10223 updateTriggerOid;
10232 /*
10233 * Add the check triggers to it and, if necessary, schedule it to be
10234 * checked in Phase 3.
10235 *
10236 * If the relation is partitioned, drill down to do it to its partitions.
10237 */
10240 fkconstraint,
10241 parentConstr,
10242 indexOid,
10247 {
10248 /*
10249 * Tell Phase 3 to check that the constraint is satisfied by existing
10250 * rows. We can skip this during table creation, when requested
10251 * explicitly by specifying NOT VALID in an ADD FOREIGN KEY command,
10252 * and when we're recreating a constraint following a SET DATA TYPE
10253 * operation that did not impugn its validity.
10254 */
10256 {
10271 }
10272 }
10274 {
10276 Relation trigrel;
10278 /*
10279 * Triggers of the foreign keys will be manipulated a bunch of times
10280 * in the loop below. To avoid repeatedly opening/closing the trigger
10281 * catalog relation, we open it here and pass it to the subroutines
10282 * called below.
10283 */
10286 /*
10287 * Recurse to take appropriate action on each partition; either we
10288 * find an existing constraint to reparent to ours, or we create a new
10289 * one.
10290 */
10292 {
10300 Oid constrOid;
10301 ObjectAddress address,
10302 referenced;
10313 /* Check whether an existing constraint can be repurposed */
10317 {
10322 partitionId,
10323 parentConstr,
10324 numfks,
10325 mapped_fkattnum,
10326 pkattnum,
10327 pfeqoperators,
10328 insertTriggerOid,
10329 updateTriggerOid,
10330 trigrel))
10331 {
10334 }
10335 }
10337 {
10340 }
10342 /*
10343 * No luck finding a good constraint to reuse; create our own.
10344 */
10352 else
10354 constrOid =
10357 CONSTRAINT_FOREIGN,
10361 parentConstr,
10362 partitionId,
10363 mapped_fkattnum,
10364 numfks,
10365 numfks,
10366 InvalidOid,
10367 indexOid,
10369 pkattnum,
10370 pfeqoperators,
10371 ppeqoperators,
10372 ffeqoperators,
10373 numfks,
10376 fkdelsetcols,
10377 numfkdelsetcols,
10379 NULL,
10380 NULL,
10381 NULL,
10387 /*
10388 * Give this constraint partition-type dependencies on the parent
10389 * constraint as well as the table.
10390 */
10397 /* Make all this visible before recursing */
10400 /* call ourselves to finalize the creation and we're done */
10402 indexOid,
10403 constrOid,
10404 numfks,
10405 pkattnum,
10406 mapped_fkattnum,
10407 pfeqoperators,
10408 ppeqoperators,
10409 ffeqoperators,
10410 numfkdelsetcols,
10411 fkdelsetcols,
10412 old_check_ok,
10413 lockmode,
10414 insertTriggerOid,
10415 updateTriggerOid);
10418 }
10421 }
10422 }
10424 /*
10425 * CloneForeignKeyConstraints
10426 * Clone foreign keys from a partitioned table to a newly acquired
10427 * partition.
10428 *
10429 * partitionRel is a partition of parentRel, so we can be certain that it has
10430 * the same columns with the same datatypes. The columns may be in different
10431 * order, though.
10432 *
10433 * wqueue must be passed to set up phase 3 constraint checking, unless the
10434 * referencing-side partition is known to be empty (such as in CREATE TABLE /
10435 * PARTITION OF).
10436 */
10437 static void
10439 Relation partitionRel)
10440 {
10441 /* This only works for declarative partitioning */
10444 /*
10445 * Clone constraints for which the parent is on the referenced side.
10446 */
10449 /*
10450 * Now clone constraints where the parent is on the referencing side.
10451 */
10453 }
10455 /*
10456 * CloneFkReferenced
10457 * Subroutine for CloneForeignKeyConstraints
10458 *
10459 * Find all the FKs that have the parent relation on the referenced side;
10460 * clone those constraints to the given partition. This is to be called
10461 * when the partition is being created or attached.
10462 *
10463 * This ignores self-referencing FKs; those are handled by CloneFkReferencing.
10464 *
10465 * This recurses to partitions, if the relation being attached is partitioned.
10466 * Recursion is done by calling addFkRecurseReferenced.
10467 */
10468 static void
10470 {
10471 Relation pg_constraint;
10474 SysScanDesc scan;
10476 HeapTuple tuple;
10478 Relation trigrel;
10480 /*
10481 * Search for any constraints where this partition's parent is in the
10482 * referenced side. However, we must not clone any constraint whose
10483 * parent constraint is also going to be cloned, to avoid duplicates. So
10484 * do it in two steps: first construct the list of constraints to clone,
10485 * then go over that list cloning those whose parents are not in the list.
10486 * (We must not rely on the parent being seen first, since the catalog
10487 * scan could return children first.)
10488 */
10496 /* This is a seqscan, as we don't have a usable index ... */
10500 {
10504 }
10508 /*
10509 * Triggers of the foreign keys will be manipulated a bunch of times in
10510 * the loop below. To avoid repeatedly opening/closing the trigger
10511 * catalog relation, we open it here and pass it to the subroutines called
10512 * below.
10513 */
10520 {
10522 Form_pg_constraint constrForm;
10523 Relation fkRel;
10524 Oid indexOid;
10525 Oid partIndexId;
10536 Oid deleteTriggerOid,
10537 updateTriggerOid;
10544 /*
10545 * As explained above: don't try to clone a constraint for which we're
10546 * going to clone the parent.
10547 */
10549 {
10552 }
10554 /*
10555 * Don't clone self-referencing foreign keys, which can be in the
10556 * partitioned table or in the partition-to-be.
10557 */
10560 {
10563 }
10565 /*
10566 * Because we're only expanding the key space at the referenced side,
10567 * we don't need to prevent any operation in the referencing table, so
10568 * AccessShareLock suffices (assumes that dropping the constraint
10569 * acquires AEL).
10570 */
10576 conkey,
10577 confkey,
10578 conpfeqop,
10579 conppeqop,
10580 conffeqop,
10582 confdelsetcols);
10594 /* ->fk_attrs determined below */
10605 /* set up colnames that are used to generate the constraint name */
10607 {
10608 Form_pg_attribute att;
10614 }
10616 /*
10617 * Add the new foreign key constraint pointing to the new partition.
10618 * Because this new partition appears in the referenced side of the
10619 * constraint, we don't need to set up for Phase 3 check.
10620 */
10626 /*
10627 * Get the "action" triggers belonging to the constraint to pass as
10628 * parent OIDs for similar triggers that will be created on the
10629 * partition in addFkRecurseReferenced().
10630 */
10636 fkconstraint,
10637 fkRel,
10638 partitionRel,
10639 partIndexId,
10640 constrOid,
10641 numfks,
10642 mapped_confkey,
10643 conkey,
10644 conpfeqop,
10645 conppeqop,
10646 conffeqop,
10647 numfkdelsetcols,
10648 confdelsetcols,
10650 deleteTriggerOid,
10651 updateTriggerOid);
10655 }
10658 }
10660 /*
10661 * CloneFkReferencing
10662 * Subroutine for CloneForeignKeyConstraints
10663 *
10664 * For each FK constraint of the parent relation in the given list, find an
10665 * equivalent constraint in its partition relation that can be reparented;
10666 * if one cannot be found, create a new constraint in the partition as its
10667 * child.
10668 *
10669 * If wqueue is given, it is used to set up phase-3 verification for each
10670 * cloned constraint; if omitted, we assume that such verification is not
10671 * needed (example: the partition is being created anew).
10672 */
10673 static void
10675 {
10680 Relation trigrel;
10682 /* obtain a list of constraints that we need to clone */
10684 {
10688 }
10690 /*
10691 * Silently do nothing if there's nothing to do. In particular, this
10692 * avoids throwing a spurious error for foreign tables.
10693 */
10702 /*
10703 * Triggers of the foreign keys will be manipulated a bunch of times in
10704 * the loop below. To avoid repeatedly opening/closing the trigger
10705 * catalog relation, we open it here and pass it to the subroutines called
10706 * below.
10707 */
10710 /*
10711 * The constraint key may differ, if the columns in the partition are
10712 * different. This map is used to convert them.
10713 */
10721 {
10723 Form_pg_constraint constrForm;
10724 Relation pkrel;
10725 HeapTuple tuple;
10737 Oid indexOid;
10738 Oid constrOid;
10739 ObjectAddress address,
10740 referenced;
10742 Oid insertTriggerOid,
10743 updateTriggerOid;
10748 parentConstrOid);
10751 /* Don't clone constraints whose parents are being cloned */
10753 {
10756 }
10758 /*
10759 * Need to prevent concurrent deletions. If pkrel is a partitioned
10760 * relation, that means to lock all partitions.
10761 */
10773 /*
10774 * Get the "check" triggers belonging to the constraint to pass as
10775 * parent OIDs for similar triggers that will be created on the
10776 * partition in addFkRecurseReferencing(). They are also passed to
10777 * tryAttachPartitionForeignKey() below to simply assign as parents to
10778 * the partition's existing "check" triggers, that is, if the
10779 * corresponding constraints is deemed attachable to the parent
10780 * constraint.
10781 */
10786 /*
10787 * Before creating a new constraint, see whether any existing FKs are
10788 * fit for the purpose. If one is, attach the parent constraint to
10789 * it, and don't clone anything. This way we avoid the expensive
10790 * verification step and don't end up with a duplicate FK, and we
10791 * don't need to recurse to partitions for this constraint.
10792 */
10795 {
10800 parentConstrOid,
10801 numfks,
10802 mapped_conkey,
10803 confkey,
10804 conpfeqop,
10805 insertTriggerOid,
10806 updateTriggerOid,
10807 trigrel))
10808 {
10812 }
10813 }
10815 {
10818 }
10820 /* No dice. Set up to create our own constraint */
10823 /* ->conname determined below */
10828 /* ->fk_attrs determined below */
10839 {
10840 Form_pg_attribute att;
10846 }
10855 else
10859 constrOid =
10862 CONSTRAINT_FOREIGN,
10866 parentConstrOid,
10868 mapped_conkey,
10869 numfks,
10870 numfks,
10872 indexOid,
10874 confkey,
10875 conpfeqop,
10876 conppeqop,
10877 conffeqop,
10878 numfks,
10881 confdelsetcols,
10882 numfkdelsetcols,
10884 NULL,
10885 NULL,
10886 NULL,
10892 /* Set up partition dependencies for the new constraint */
10900 /* Done with the cloned constraint's tuple */
10903 /* Make all this visible before recursing */
10907 fkconstraint,
10908 partRel,
10909 pkrel,
10910 indexOid,
10911 constrOid,
10912 numfks,
10913 confkey,
10914 mapped_conkey,
10915 conpfeqop,
10916 conppeqop,
10917 conffeqop,
10918 numfkdelsetcols,
10919 confdelsetcols,
10921 AccessExclusiveLock,
10922 insertTriggerOid,
10923 updateTriggerOid);
10925 }
10928 }
10930 /*
10931 * When the parent of a partition receives [the referencing side of] a foreign
10932 * key, we must propagate that foreign key to the partition. However, the
10933 * partition might already have an equivalent foreign key; this routine
10934 * compares the given ForeignKeyCacheInfo (in the partition) to the FK defined
10935 * by the other parameters. If they are equivalent, create the link between
10936 * the two constraints and return true.
10937 *
10938 * If the given FK does not match the one defined by rest of the params,
10939 * return false.
10940 */
10941 static bool
10943 Oid partRelid,
10944 Oid parentConstrOid,
10949 Oid parentInsTrigger,
10950 Oid parentUpdTrigger,
10951 Relation trigrel)
10952 {
10953 HeapTuple parentConstrTup;
10954 Form_pg_constraint parentConstr;
10955 HeapTuple partcontup;
10956 Form_pg_constraint partConstr;
10957 ScanKeyData key;
10958 SysScanDesc scan;
10959 HeapTuple trigtup;
10960 Oid insertTriggerOid,
10961 updateTriggerOid;
10969 /*
10970 * Do some quick & easy initial checks. If any of these fail, we cannot
10971 * use this constraint.
10972 */
10974 {
10977 }
10979 {
10983 {
10986 }
10987 }
10989 /*
10990 * Looks good so far; do some more extensive checks. Presumably the check
10991 * for 'convalidated' could be dropped, since we don't really care about
10992 * that, but let's be careful for now.
10993 */
11006 {
11010 }
11015 /*
11016 * Looks good! Attach this constraint. The action triggers in the new
11017 * partition become redundant -- the parent table already has equivalent
11018 * ones, and those will be able to reach the partition. Remove the ones
11019 * in the partition. We identify them because they have our constraint
11020 * OID, as well as being on the referenced rel.
11021 */
11023 Anum_pg_trigger_tgconstraint,
11029 {
11031 ObjectAddress trigger;
11038 /*
11039 * The constraint is originally set up to contain this trigger as an
11040 * implementation object, so there's a dependency record that links
11041 * the two; however, since the trigger is no longer needed, we remove
11042 * the dependency link in order to be able to drop the trigger while
11043 * keeping the constraint intact.
11044 */
11048 /* make dependency deletion visible to performDeletion */
11053 /* make trigger drop visible, in case the loop iterates */
11055 }
11061 /*
11062 * Like the constraint, attach partition's "check" triggers to the
11063 * corresponding parent triggers.
11064 */
11070 partRelid);
11073 partRelid);
11077 }
11079 /*
11080 * GetForeignKeyActionTriggers
11081 * Returns delete and update "action" triggers of the given relation
11082 * belonging to the given constraint
11083 */
11084 static void
11089 {
11090 ScanKeyData key;
11091 SysScanDesc scan;
11092 HeapTuple trigtup;
11096 Anum_pg_trigger_tgconstraint,
11103 {
11110 /* Only ever look at "action" triggers on the PK side. */
11114 {
11117 }
11119 {
11122 }
11123 #ifndef USE_ASSERT_CHECKING
11124 /* In an assert-enabled build, continue looking to find duplicates */
11127 #endif
11128 }
11132 conoid);
11135 conoid);
11138 }
11140 /*
11141 * GetForeignKeyCheckTriggers
11142 * Returns insert and update "check" triggers of the given relation
11143 * belonging to the given constraint
11144 */
11145 static void
11150 {
11151 ScanKeyData key;
11152 SysScanDesc scan;
11153 HeapTuple trigtup;
11157 Anum_pg_trigger_tgconstraint,
11164 {
11171 /* Only ever look at "check" triggers on the FK side. */
11175 {
11178 }
11180 {
11183 }
11184 #ifndef USE_ASSERT_CHECKING
11185 /* In an assert-enabled build, continue looking to find duplicates. */
11188 #endif
11189 }
11193 conoid);
11196 conoid);
11199 }
11201 /*
11202 * ALTER TABLE ALTER CONSTRAINT
11203 *
11204 * Update the attributes of a constraint.
11205 *
11206 * Currently only works for Foreign Key constraints.
11207 *
11208 * If the constraint is modified, returns its address; otherwise, return
11209 * InvalidObjectAddress.
11210 */
11211 static ObjectAddress
11214 {
11216 Relation conrel;
11217 Relation tgrel;
11218 SysScanDesc scan;
11220 HeapTuple contuple;
11221 Form_pg_constraint currcon;
11222 ObjectAddress address;
11231 /*
11232 * Find and check the target constraint
11233 */
11235 Anum_pg_constraint_conrelid,
11239 Anum_pg_constraint_contypid,
11243 Anum_pg_constraint_conname,
11249 /* There can be at most one matching row */
11263 /*
11264 * If it's not the topmost constraint, raise an error.
11265 *
11266 * Altering a non-topmost constraint leaves some triggers untouched, since
11267 * they are not directly connected to this constraint; also, pg_dump would
11268 * ignore the deferrability status of the individual constraint, since it
11269 * only dumps topmost constraints. Avoid these problems by refusing this
11270 * operation and telling the user to alter the parent constraint instead.
11271 */
11273 {
11274 HeapTuple tp;
11279 /* Loop to find the topmost constraint */
11281 {
11284 /* If no parent, this is the constraint we want */
11286 {
11291 }
11295 }
11304 }
11306 /*
11307 * Do the actual catalog work. We can skip changing if already in the
11308 * desired state, but not if a partitioned table: partitions need to be
11309 * processed regardless, in case they had the constraint locally changed.
11310 */
11315 {
11319 }
11321 /*
11322 * ATExecAlterConstrRecurse already invalidated relcache for the relations
11323 * having the constraint itself; here we also invalidate for relations
11324 * that have any triggers that are part of the constraint.
11325 */
11335 }
11337 /*
11338 * Recursive subroutine of ATExecAlterConstraint. Returns true if the
11339 * constraint is altered.
11340 *
11341 * *otherrelids is appended OIDs of relations containing affected triggers.
11342 *
11343 * Note that we must recurse even when the values are correct, in case
11344 * indirect descendants have had their constraints altered locally.
11345 * (This could be avoided if we forbade altering constraints in partitions
11346 * but existing releases don't do that.)
11347 */
11348 static bool
11351 LOCKMODE lockmode)
11352 {
11353 Form_pg_constraint currcon;
11354 Oid conoid;
11355 Oid refrelid;
11362 /*
11363 * Update pg_constraint with the flags from cmdcon.
11364 *
11365 * If called to modify a constraint that's already in the desired state,
11366 * silently do nothing.
11367 */
11370 {
11371 HeapTuple copyTuple;
11372 Form_pg_constraint copy_con;
11373 HeapTuple tgtuple;
11374 ScanKeyData tgkey;
11375 SysScanDesc tgscan;
11389 /* Make new constraint flags visible to others */
11392 /*
11393 * Now we need to update the multiple entries in pg_trigger that
11394 * implement the constraint.
11395 */
11397 Anum_pg_trigger_tgconstraint,
11403 {
11405 Form_pg_trigger copy_tg;
11406 HeapTuple tgCopyTuple;
11408 /*
11409 * Remember OIDs of other relation(s) involved in FK constraint.
11410 * (Note: it's likely that we could skip forcing a relcache inval
11411 * for other rels that don't have a trigger whose properties
11412 * change, but let's be conservative.)
11413 */
11418 /*
11419 * Update deferrability of RI_FKey_noaction_del,
11420 * RI_FKey_noaction_upd, RI_FKey_check_ins and RI_FKey_check_upd
11421 * triggers, but not others; see createForeignKeyActionTriggers
11422 * and CreateFKCheckTrigger.
11423 */
11440 }
11443 }
11445 /*
11446 * If the table at either end of the constraint is partitioned, we need to
11447 * recurse and handle every constraint that is a child of this one.
11448 *
11449 * (This assumes that the recurse flag is forcibly set for partitioned
11450 * tables, and not set for legacy inheritance, though we don't check for
11451 * that here.)
11452 */
11455 {
11456 ScanKeyData pkey;
11457 SysScanDesc pscan;
11458 HeapTuple childtup;
11461 Anum_pg_constraint_conparentid,
11469 {
11471 Relation childrel;
11477 }
11480 }
11483 }
11485 /*
11486 * ALTER TABLE VALIDATE CONSTRAINT
11487 *
11488 * XXX The reason we handle recursion here rather than at Phase 1 is because
11489 * there's no good way to skip recursing when handling foreign keys: there is
11490 * no need to lock children in that case, yet we wouldn't be able to avoid
11491 * doing so at that level.
11492 *
11493 * Return value is the address of the validated constraint. If the constraint
11494 * was already validated, InvalidObjectAddress is returned.
11495 */
11496 static ObjectAddress
11499 {
11500 Relation conrel;
11501 SysScanDesc scan;
11503 HeapTuple tuple;
11504 Form_pg_constraint con;
11505 ObjectAddress address;
11509 /*
11510 * Find and check the target constraint
11511 */
11513 Anum_pg_constraint_conrelid,
11517 Anum_pg_constraint_contypid,
11521 Anum_pg_constraint_conname,
11527 /* There can be at most one matching row */
11543 {
11545 HeapTuple copyTuple;
11546 Form_pg_constraint copy_con;
11549 {
11553 /* Queue validation for phase 3 */
11555 /* for now this is all we need */
11566 /* Find or create work queue entry for this table */
11570 /*
11571 * We disallow creating invalid foreign keys to or from
11572 * partitioned tables, so ignoring the recursion bit is okay.
11573 */
11574 }
11576 {
11580 Datum val;
11583 /*
11584 * If we're recursing, the parent has already done this, so skip
11585 * it. Also, if the constraint is a NO INHERIT constraint, we
11586 * shouldn't try to look for it in the children.
11587 */
11592 /*
11593 * For CHECK constraints, we must ensure that we only mark the
11594 * constraint as validated on the parent if it's already validated
11595 * on the children.
11596 *
11597 * We recurse before validating on the parent, to reduce risk of
11598 * deadlocks.
11599 */
11601 {
11603 Relation childrel;
11608 /*
11609 * If we are told not to recurse, there had better not be any
11610 * child tables, because we can't mark the constraint on the
11611 * parent valid unless it is valid for all child tables.
11612 */
11618 /* find_all_inheritors already got lock */
11624 }
11626 /* Queue validation for phase 3 */
11635 Anum_pg_constraint_conbin);
11639 /* Find or create work queue entry for this table */
11643 /*
11644 * Invalidate relcache so that others see the new validated
11645 * constraint.
11646 */
11648 }
11650 /*
11651 * Now update the catalog, while we have the door open.
11652 */
11663 }
11664 else
11672 }
11675 /*
11676 * transformColumnNameList - transform list of column names
11677 *
11678 * Lookup each name and return its attnum and, optionally, type OID
11679 *
11680 * Note: the name of this function suggests that it's general-purpose,
11681 * but actually it's only used to look up names appearing in foreign-key
11682 * clauses. The error messages would need work to use it in other cases,
11683 * and perhaps the validity checks as well.
11684 */
11685 static int
11688 {
11694 {
11696 HeapTuple atttuple;
11697 Form_pg_attribute attform;
11704 attname)));
11714 INDEX_MAX_KEYS)));
11719 attnum++;
11720 }
11723 }
11725 /*
11726 * transformFkeyGetPrimaryKey -
11727 *
11728 * Look up the names, attnums, and types of the primary key attributes
11729 * for the pkrel. Also return the index OID and index opclasses of the
11730 * index supporting the primary key.
11731 *
11732 * All parameters except pkrel are output parameters. Also, the function
11733 * return value is the number of attributes in the primary key.
11734 *
11735 * Used when the column list in the REFERENCES specification is omitted.
11736 */
11737 static int
11742 {
11747 Datum indclassDatum;
11751 /*
11752 * Get the list of index OIDs for the table from the relcache, and look up
11753 * each one in the pg_index syscache until we find one marked primary key
11754 * (hopefully there isn't more than one such). Insist it's valid, too.
11755 */
11761 {
11769 {
11770 /*
11771 * Refuse to use a deferrable primary key. This is per SQL spec,
11772 * and there would be a lot of interesting semantic problems if we
11773 * tried to allow it.
11774 */
11783 }
11785 }
11789 /*
11790 * Check that we found it
11791 */
11798 /* Must get indclass the hard way */
11800 Anum_pg_index_indclass);
11803 /*
11804 * Now build the list of PK attributes from the indkey definition (we
11805 * assume a primary key cannot have expressional elements)
11806 */
11809 {
11817 }
11822 }
11824 /*
11825 * transformFkeyCheckAttrs -
11826 *
11827 * Make sure that the attributes of a referenced table belong to a unique
11828 * (or primary key) constraint. Return the OID of the index supporting
11829 * the constraint, as well as the opclasses associated with the index
11830 * columns.
11831 */
11832 static Oid
11836 {
11843 j;
11845 /*
11846 * Reject duplicate appearances of columns in the referenced-columns list.
11847 * Such a case is forbidden by the SQL standard, and even if we thought it
11848 * useful to allow it, there would be ambiguity about how to match the
11849 * list to unique indexes (in particular, it'd be unclear which index
11850 * opclass goes with which FK column).
11851 */
11853 {
11855 {
11860 }
11861 }
11863 /*
11864 * Get the list of index OIDs for the table from the relcache, and look up
11865 * each one in the pg_index syscache, and match unique indexes to the list
11866 * of attnums we are given.
11867 */
11871 {
11872 HeapTuple indexTuple;
11873 Form_pg_index indexStruct;
11881 /*
11882 * Must have the right number of columns; must be unique and not a
11883 * partial index; forget it if there are any expressions, too. Invalid
11884 * indexes are out as well.
11885 */
11891 {
11892 Datum indclassDatum;
11895 /* Must get indclass the hard way */
11897 Anum_pg_index_indclass);
11900 /*
11901 * The given attnum list may match the index columns in any order.
11902 * Check for a match, and extract the appropriate opclasses while
11903 * we're at it.
11904 *
11905 * We know that attnums[] is duplicate-free per the test at the
11906 * start of this function, and we checked above that the number of
11907 * index columns agrees, so if we find a match for each attnums[]
11908 * entry then we must have a one-to-one match in some order.
11909 */
11911 {
11914 {
11916 {
11920 }
11921 }
11924 }
11926 /*
11927 * Refuse to use a deferrable unique/primary key. This is per SQL
11928 * spec, and there would be a lot of interesting semantic problems
11929 * if we tried to allow it.
11930 */
11932 {
11933 /*
11934 * Remember that we found an otherwise matching index, so that
11935 * we can generate a more appropriate error message.
11936 */
11939 }
11940 }
11944 }
11947 {
11953 else
11958 }
11963 }
11965 /*
11966 * findFkeyCast -
11967 *
11968 * Wrapper around find_coercion_pathway() for ATAddForeignKeyConstraint().
11969 * Caller has equal regard for binary coercibility and for an exact match.
11970 */
11971 static CoercionPathType
11973 {
11974 CoercionPathType ret;
11977 {
11980 }
11981 else
11982 {
11986 /* A previously-relied-upon cast is now gone. */
11989 }
11992 }
11994 /*
11995 * Permissions checks on the referenced table for ADD FOREIGN KEY
11996 *
11997 * Note: we have already checked that the user owns the referencing table,
11998 * else we'd have failed much earlier; no additional checks are needed for it.
11999 */
12000 static void
12002 {
12004 AclResult aclresult;
12007 /* Okay if we have relation-level REFERENCES permission */
12009 ACL_REFERENCES);
12012 /* Else we must have REFERENCES on each column */
12014 {
12020 }
12021 }
12023 /*
12024 * Scan the existing rows in a table to verify they meet a proposed FK
12025 * constraint.
12026 *
12027 * Caller must have opened and locked both relations appropriately.
12028 */
12029 static void
12031 Relation rel,
12032 Relation pkrel,
12033 Oid pkindOid,
12034 Oid constraintOid)
12035 {
12037 TableScanDesc scan;
12039 Snapshot snapshot;
12040 MemoryContext oldcxt;
12041 MemoryContext perTupCxt;
12046 /*
12047 * Build a trigger call structure; we'll need it either way.
12048 */
12058 /* we needn't fill in remaining fields */
12060 /*
12061 * See if we can do it with a single LEFT JOIN query. A false result
12062 * indicates we must proceed with the fire-the-trigger method.
12063 */
12067 /*
12068 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
12069 * if that tuple had just been inserted. If any of those fail, it should
12070 * ereport(ERROR) and that's that.
12071 */
12078 ALLOCSET_SMALL_SIZES);
12082 {
12088 /*
12089 * Make a call to the trigger function
12090 *
12091 * No parameters are passed, but we do set a context
12092 */
12095 /*
12096 * We assume RI_FKey_check_ins won't look at flinfo...
12097 */
12110 }
12117 }
12119 /*
12120 * CreateFKCheckTrigger
12121 * Creates the insert (on_insert=true) or update "check" trigger that
12122 * implements a given foreign key
12123 *
12124 * Returns the OID of the so created trigger.
12125 */
12126 static Oid
12130 {
12131 ObjectAddress trigAddress;
12134 /*
12135 * Note: for a self-referential FK (referencing and referenced tables are
12136 * the same), it is important that the ON UPDATE action fires before the
12137 * CHECK action, since both triggers will fire on the same row during an
12138 * UPDATE event; otherwise the CHECK trigger will be checking a non-final
12139 * state of the row. Triggers fire in name order, so we ensure this by
12140 * using names like "RI_ConstraintTrigger_a_NNNN" for the action triggers
12141 * and "RI_ConstraintTrigger_c_NNNN" for the check triggers.
12142 */
12149 /* Either ON INSERT or ON UPDATE */
12151 {
12154 }
12155 else
12156 {
12159 }
12175 /* Make changes-so-far visible */
12179 }
12181 /*
12182 * createForeignKeyActionTriggers
12183 * Create the referenced-side "action" triggers that implement a foreign
12184 * key.
12185 *
12186 * Returns the OIDs of the so created triggers in *deleteTrigOid and
12187 * *updateTrigOid.
12188 */
12189 static void
12194 {
12196 ObjectAddress trigAddress;
12198 /*
12199 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12200 * DELETE action on the referenced table.
12201 */
12216 {
12246 }
12255 /* Make changes-so-far visible */
12258 /*
12259 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12260 * UPDATE action on the referenced table.
12261 */
12276 {
12306 }
12314 }
12316 /*
12317 * createForeignKeyCheckTriggers
12318 * Create the referencing-side "check" triggers that implement a foreign
12319 * key.
12320 *
12321 * Returns the OIDs of the so created triggers in *insertTrigOid and
12322 * *updateTrigOid.
12323 */
12324 static void
12327 Oid indexOid,
12330 {
12337 }
12339 /*
12340 * ALTER TABLE DROP CONSTRAINT
12341 *
12342 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
12343 */
12344 static void
12348 {
12349 Relation conrel;
12350 SysScanDesc scan;
12352 HeapTuple tuple;
12357 /*
12358 * Find and drop the target constraint
12359 */
12361 Anum_pg_constraint_conrelid,
12365 Anum_pg_constraint_contypid,
12369 Anum_pg_constraint_conname,
12375 /* There can be at most one matching row */
12377 {
12383 }
12388 {
12394 else
12398 }
12401 }
12403 /*
12404 * Remove a constraint, using its pg_constraint tuple
12405 *
12406 * Implementation for ALTER TABLE DROP CONSTRAINT and ALTER TABLE ALTER COLUMN
12407 * DROP NOT NULL.
12408 *
12409 * Returns the address of the constraint being removed.
12410 */
12411 static ObjectAddress
12414 LOCKMODE lockmode)
12415 {
12416 Relation conrel;
12417 Form_pg_constraint con;
12418 ObjectAddress conobj;
12431 /* At top level, permission check was done in ATPrepCmd, else do it */
12440 /* Don't allow drop of inherited constraints */
12447 /*
12448 * See if we have a not-null constraint or a PRIMARY KEY. If so, we have
12449 * more checks and actions below, so obtain the list of columns that are
12450 * constrained by the constraint being dropped.
12451 */
12453 {
12458 }
12460 {
12461 Datum adatum;
12484 }
12488 /*
12489 * If it's a foreign-key constraint, we'd better lock the referenced table
12490 * and check that that's not in use, just as we've already done for the
12491 * constrained table (else we might, eg, be dropping a trigger that has
12492 * unfired events). But we can/must skip that in the self-referential
12493 * case.
12494 */
12497 {
12498 Relation frel;
12500 /* Must match lock taken by RemoveTriggerById: */
12504 }
12506 /*
12507 * Perform the actual constraint deletion
12508 */
12512 /*
12513 * If this was a NOT NULL or the primary key, the constrained columns must
12514 * have had pg_attribute.attnotnull set. See if we need to reset it, and
12515 * do so.
12516 */
12518 {
12519 Relation attrel;
12524 /* Make the above deletion visible */
12529 /*
12530 * We want to test columns for their presence in the primary key, but
12531 * only if we're not dropping it.
12532 */
12535 INDEX_ATTR_BITMAP_PRIMARY_KEY);
12539 {
12541 HeapTuple atttup;
12542 HeapTuple contup;
12543 Form_pg_attribute attForm;
12545 /*
12546 * Obtain pg_attribute tuple and verify conditions on it. We use
12547 * a copy we can scribble on.
12548 */
12555 /*
12556 * Since the above deletion has been made visible, we can now
12557 * search for any remaining constraints on this column (or these
12558 * columns, in the case we're dropping a multicol primary key.)
12559 * Then, verify whether any further NOT NULL or primary key
12560 * exists, and reset attnotnull if none.
12561 *
12562 * However, if this is a generated identity column, abort the
12563 * whole thing with a specific error message, because the
12564 * constraint is required in that case.
12565 */
12569 pkcols))
12572 /*
12573 * It's not valid to drop the not-null constraint for a GENERATED
12574 * AS IDENTITY column.
12575 */
12584 /*
12585 * It's not valid to drop the not-null constraint for a column in
12586 * the replica identity index, either. (FULL is not affected.)
12587 */
12594 /* Reset attnotnull */
12596 {
12599 }
12600 }
12602 }
12604 /*
12605 * For partitioned tables, non-CHECK, non-NOT-NULL inherited constraints
12606 * are dropped via the dependency mechanism, so we're done here.
12607 */
12611 {
12614 }
12616 /*
12617 * Propagate to children as appropriate. Unlike most other ALTER
12618 * routines, we have to do this one level of recursion at a time; we can't
12619 * use find_all_inheritors to do it in one pass.
12620 */
12623 else
12626 /*
12627 * For a partitioned table, if partitions exist and we are told not to
12628 * recurse, it's a user error. It doesn't make sense to have a constraint
12629 * be defined only on the parent, especially if it's a partitioned table.
12630 */
12638 /* For not-null constraints we recurse by column name */
12642 else
12646 {
12648 Relation childrel;
12649 HeapTuple tuple;
12650 Form_pg_constraint childcon;
12655 /* find_inheritance_children already got lock */
12659 /*
12660 * We search for not-null constraint by column number, and other
12661 * constraints by name.
12662 */
12664 {
12669 }
12670 else
12671 {
12672 SysScanDesc scan;
12676 Anum_pg_constraint_conrelid,
12680 Anum_pg_constraint_contypid,
12684 Anum_pg_constraint_conname,
12689 /* There can only be one, so no need to loop */
12695 constrName,
12699 }
12703 /* Right now only CHECK and not-null constraints can be inherited */
12713 {
12714 /*
12715 * If the child constraint has other definition sources, just
12716 * decrement its inheritance count; if not, recurse to delete it.
12717 */
12719 {
12720 /* Time to delete this child constraint, too */
12723 lockmode);
12724 }
12725 else
12726 {
12727 /* Child constraint must survive my deletion */
12731 /* Make update visible */
12733 }
12734 }
12735 else
12736 {
12737 /*
12738 * If we were told to drop ONLY in this table (no recursion) and
12739 * there are no further parents for this constraint, we need to
12740 * mark the inheritors' constraints as locally defined rather than
12741 * inherited.
12742 */
12749 /* Make update visible */
12751 }
12756 }
12758 /*
12759 * In addition, when dropping a primary key from a legacy-inheritance
12760 * parent table, we must recurse to children to mark the corresponding NOT
12761 * NULL constraint as no longer inherited, or drop it if this its last
12762 * reference.
12763 */
12767 {
12772 /*
12773 * Because primary keys are always marked as NO INHERIT, we don't have
12774 * a list of children yet, so obtain one now.
12775 */
12778 /*
12779 * Find out the list of column names to process. Fortunately, we
12780 * already have the list of column numbers.
12781 */
12783 {
12786 }
12789 {
12791 Relation childrel;
12796 /* find_inheritance_children already got lock */
12801 {
12802 HeapTuple contup;
12813 lockmode);
12815 }
12820 }
12821 }
12826 }
12828 /*
12829 * ALTER COLUMN TYPE
12830 *
12831 * Unlike other subcommand types, we do parse transformation for ALTER COLUMN
12832 * TYPE during phase 1 --- the AlterTableCmd passed in here is already
12833 * transformed (and must be, because we rely on some transformed fields).
12834 *
12835 * The point of this is that the execution of all ALTER COLUMN TYPEs for a
12836 * table will be done "in parallel" during phase 3, so all the USING
12837 * expressions should be parsed assuming the original column types. Also,
12838 * this allows a USING expression to refer to a field that will be dropped.
12839 *
12840 * To make this work safely, AT_PASS_DROP then AT_PASS_ALTER_TYPE must be
12841 * the first two execution steps in phase 2; they must not see the effects
12842 * of any other subcommand types, since the USING expressions are parsed
12843 * against the unmodified table's state.
12844 */
12845 static void
12851 {
12856 HeapTuple tuple;
12857 Form_pg_attribute attTup;
12858 AttrNumber attnum;
12859 Oid targettype;
12860 int32 targettypmod;
12861 Oid targetcollid;
12864 AclResult aclresult;
12872 /* lookup the attribute so we can check inheritance status */
12882 /* Can't alter a system attribute */
12887 colName)));
12889 /*
12890 * Don't alter inherited columns. At outer level, there had better not be
12891 * any inherited definition; when recursing, we assume this was checked at
12892 * the parent level (see below).
12893 */
12898 colName)));
12900 /* Don't alter columns used in the partition key */
12906 errmsg("cannot alter column \"%s\" because it is part of the partition key of relation \"%s\"",
12909 /* Look up the target type */
12916 /* And the collation */
12919 /* make sure datatype is legal for a column */
12926 {
12927 /*
12928 * Set up an expression to transform the old data value to the new
12929 * type. If a USING option was given, use the expression as
12930 * transformed by transformAlterTableStmt, else just take the old
12931 * value and try to coerce it. We do this first so that type
12932 * incompatibility can be detected before we waste effort, and because
12933 * we need the expression to be parsed against the original table row
12934 * type.
12935 */
12937 {
12942 }
12947 COERCION_ASSIGNMENT,
12948 COERCE_IMPLICIT_CAST,
12951 {
12952 /* error text depends on whether USING was specified or not */
12960 else
12965 /* translator: USING is SQL, don't translate it */
12969 targettypmod))));
12970 }
12972 /* Fix collations after all else */
12975 /* Plan the expr now so we can accurately assess the need to rewrite. */
12978 /*
12979 * Add a work queue item to make ATRewriteTable update the column
12980 * contents.
12981 */
12990 }
12998 {
12999 /*
13000 * For relations without storage, do this check now. Regular tables
13001 * will check it later when the table is being rewritten.
13002 */
13004 }
13008 /*
13009 * Recurse manually by queueing a new command for each child, if
13010 * necessary. We cannot apply ATSimpleRecursion here because we need to
13011 * remap attribute numbers in the USING expression, if any.
13012 *
13013 * If we are told not to recurse, there had better not be any child
13014 * tables; else the alter would put them out of step.
13015 */
13017 {
13027 /*
13028 * find_all_inheritors does the recursive search of the inheritance
13029 * hierarchy, so all we have to do is process all of the relids in the
13030 * list that it returns.
13031 */
13033 {
13036 Relation childrel;
13037 HeapTuple childtuple;
13038 Form_pg_attribute childattTup;
13043 /* find_all_inheritors already got lock */
13047 /*
13048 * Verify that the child doesn't have any inherited definitions of
13049 * this column that came from outside this inheritance hierarchy.
13050 * (renameatt makes a similar test, though in a different way
13051 * because of its different recursion mechanism.)
13052 */
13054 colName);
13070 /*
13071 * Remap the attribute numbers. If no USING expression was
13072 * specified, there is no need for this step.
13073 */
13075 {
13079 /* create a copy to scribble on */
13088 attmap,
13096 }
13099 }
13100 }
13106 colName)));
13110 }
13112 /*
13113 * When the data type of a column is changed, a rewrite might not be required
13114 * if the new type is sufficiently identical to the old one, and the USING
13115 * clause isn't trying to insert some other value. It's safe to skip the
13116 * rewrite in these cases:
13117 *
13118 * - the old type is binary coercible to the new type
13119 * - the new type is an unconstrained domain over the old type
13120 * - {NEW,OLD} or {OLD,NEW} is {timestamptz,timestamp} and the timezone is UTC
13121 *
13122 * In the case of a constrained domain, we could get by with scanning the
13123 * table and checking the constraint rather than actually rewriting it, but we
13124 * don't currently try to do that.
13125 */
13126 static bool
13128 {
13132 {
13133 /* only one varno, so no need to check that */
13139 {
13145 }
13147 {
13151 {
13156 else
13161 }
13162 }
13163 else
13165 }
13166 }
13168 /*
13169 * ALTER COLUMN .. SET DATA TYPE
13170 *
13171 * Return the address of the modified column.
13172 */
13173 static ObjectAddress
13176 {
13180 HeapTuple heapTup;
13181 Form_pg_attribute attTup,
13182 attOldTup;
13183 AttrNumber attnum;
13184 HeapTuple typeTuple;
13185 Form_pg_type tform;
13186 Oid targettype;
13187 int32 targettypmod;
13188 Oid targetcollid;
13190 Relation attrelation;
13191 Relation depRel;
13193 SysScanDesc scan;
13194 HeapTuple depTup;
13195 ObjectAddress address;
13197 /*
13198 * Clear all the missing values if we're rewriting the table, since this
13199 * renders them pointless.
13200 */
13202 {
13203 Relation newrel;
13208 /* make sure we don't conflict with later attribute modifications */
13210 }
13214 /* Look up the target column */
13225 /* Check for multiple ALTER TYPE on same column --- can't cope */
13231 colName)));
13233 /* Look up the target type (should not fail, since prep found it) */
13237 /* And the collation */
13240 /*
13241 * If there is a default expression for the column, get it and ensure we
13242 * can coerce it to the new datatype. (We must do this before changing
13243 * the column type, because build_column_default itself will try to
13244 * coerce, and will not issue the error message we want if it fails.)
13245 *
13246 * We remove any implicit coercion steps at the top level of the old
13247 * default expression; this has been agreed to satisfy the principle of
13248 * least surprise. (The conversion to the new column type should act like
13249 * it started from what the user sees as the stored expression, and the
13250 * implicit coercions aren't going to be shown.)
13251 */
13253 {
13260 COERCION_ASSIGNMENT,
13261 COERCE_IMPLICIT_CAST,
13264 {
13270 else
13275 }
13276 }
13277 else
13280 /*
13281 * Find everything that depends on the column (constraints, indexes, etc),
13282 * and record enough information to let us recreate the objects.
13283 *
13284 * The actual recreation does not happen here, but only after we have
13285 * performed all the individual ALTER TYPE operations. We have to save
13286 * the info before executing ALTER TYPE, though, else the deparser will
13287 * get confused.
13288 */
13292 Anum_pg_depend_refclassid,
13296 Anum_pg_depend_refobjid,
13300 Anum_pg_depend_refobjsubid,
13308 {
13310 ObjectAddress foundObject;
13317 {
13319 {
13324 {
13327 }
13329 {
13330 /*
13331 * This must be a SERIAL column's sequence. We need
13332 * not do anything to it.
13333 */
13335 }
13336 else
13337 {
13338 /* Not expecting any other direct dependencies... */
13341 }
13343 }
13351 /* XXX someday see if we can cope with revising views */
13357 colName)));
13362 /*
13363 * A trigger can depend on a column because the column is
13364 * specified as an update target, or because the column is
13365 * used in the trigger's WHEN condition. The first case would
13366 * not require any extra work, but the second case would
13367 * require updating the WHEN expression, which will take a
13368 * significant amount of new code. Since we can't easily tell
13369 * which case applies, we punt for both. FIXME someday.
13370 */
13376 colName)));
13381 /*
13382 * A policy can depend on a column because the column is
13383 * specified in the policy's USING or WITH CHECK qual
13384 * expressions. It might be possible to rewrite and recheck
13385 * the policy expression, but punt for now. It's certainly
13386 * easy enough to remove and recreate the policy; still, FIXME
13387 * someday.
13388 */
13394 colName)));
13398 {
13403 {
13404 /*
13405 * Ignore the column's own default expression, which
13406 * we will deal with below.
13407 */
13409 }
13410 else
13411 {
13412 /*
13413 * This must be a reference from the expression of a
13414 * generated column elsewhere in the same table.
13415 * Changing the type of a column that is used by a
13416 * generated column is not allowed by SQL standard, so
13417 * just punt for now. It might be doable with some
13418 * thinking and effort.
13419 */
13424 colName,
13428 }
13430 }
13434 /*
13435 * Give the extended-stats machinery a chance to fix anything
13436 * that this column type change would break.
13437 */
13476 /*
13477 * We don't expect any of these sorts of objects to depend on
13478 * a column.
13479 */
13484 /*
13485 * There's intentionally no default: case here; we want the
13486 * compiler to warn if a new OCLASS hasn't been handled above.
13487 */
13488 }
13489 }
13493 /*
13494 * Now scan for dependencies of this column on other things. The only
13495 * things we should find are the dependency on the column datatype and
13496 * possibly a collation dependency. Those can be removed.
13497 */
13499 Anum_pg_depend_classid,
13503 Anum_pg_depend_objid,
13507 Anum_pg_depend_objsubid,
13515 {
13517 ObjectAddress foundObject;
13534 }
13540 /*
13541 * Here we go --- change the recorded column type and collation. (Note
13542 * heapTup is a copy of the syscache entry, so okay to scribble on.) First
13543 * fix up the missing value if any.
13544 */
13546 {
13547 Datum missingval;
13550 /* if rewrite is true the missing value should already be cleared */
13553 /* Get the missing value datum */
13555 Anum_pg_attribute_attmissingval,
13559 /* if it's a null array there is nothing to do */
13562 {
13563 /*
13564 * Get the datum out of the array and repack it in a new array
13565 * built with the new type data. We assume that since the table
13566 * doesn't need rewriting, the actual Datum doesn't need to be
13567 * changed, only the array metadata.
13568 */
13575 HeapTuple newTup;
13587 targettype,
13601 }
13602 }
13624 /* Install dependencies on new datatype and collation */
13628 /*
13629 * Drop any pg_statistic entry for the column, since it's now wrong type
13630 */
13636 /*
13637 * Update the default, if present, by brute force --- remove and re-add
13638 * the default. Probably unsafe to take shortcuts, since the new version
13639 * may well have additional dependencies. (It's okay to do this now,
13640 * rather than after other ALTER TYPE commands, since the default won't
13641 * depend on other column types.)
13642 */
13644 {
13645 /*
13646 * If it's a GENERATED default, drop its dependency records, in
13647 * particular its INTERNAL dependency on the column, which would
13648 * otherwise cause dependency.c to refuse to perform the deletion.
13649 */
13651 {
13658 }
13660 /*
13661 * Make updates-so-far visible, particularly the new pg_attribute row
13662 * which will be updated again.
13663 */
13666 /*
13667 * We use RESTRICT here for safety, but at present we do not expect
13668 * anything to depend on the default.
13669 */
13674 }
13679 /* Cleanup */
13683 }
13685 /*
13686 * Subroutine for ATExecAlterColumnType: remember that a replica identity
13687 * needs to be reset.
13688 */
13689 static void
13691 {
13699 }
13701 /*
13702 * Subroutine for ATExecAlterColumnType: remember any clustered index.
13703 */
13704 static void
13706 {
13714 }
13716 /*
13717 * Subroutine for ATExecAlterColumnType: remember that a constraint needs
13718 * to be rebuilt (which we might already know).
13719 */
13720 static void
13722 {
13723 /*
13724 * This de-duplication check is critical for two independent reasons: we
13725 * mustn't try to recreate the same constraint twice, and if a constraint
13726 * depends on more than one column whose type is to be altered, we must
13727 * capture its definition string before applying any of the column type
13728 * changes. ruleutils.c will get confused if we ask again later.
13729 */
13731 {
13732 /* OK, capture the constraint's existing definition string */
13734 Oid indoid;
13737 conoid);
13739 defstring);
13741 /*
13742 * For the index of a constraint, if any, remember if it is used for
13743 * the table's replica identity or if it is a clustered index, so that
13744 * ATPostAlterTypeCleanup() can queue up commands necessary to restore
13745 * those properties.
13746 */
13749 {
13752 }
13753 }
13754 }
13756 /*
13757 * Subroutine for ATExecAlterColumnType: remember that an index needs
13758 * to be rebuilt (which we might already know).
13759 */
13760 static void
13762 {
13763 /*
13764 * This de-duplication check is critical for two independent reasons: we
13765 * mustn't try to recreate the same index twice, and if an index depends
13766 * on more than one column whose type is to be altered, we must capture
13767 * its definition string before applying any of the column type changes.
13768 * ruleutils.c will get confused if we ask again later.
13769 */
13771 {
13772 /*
13773 * Before adding it as an index-to-rebuild, we'd better see if it
13774 * belongs to a constraint, and if so rebuild the constraint instead.
13775 * Typically this check fails, because constraint indexes normally
13776 * have only dependencies on their constraint. But it's possible for
13777 * such an index to also have direct dependencies on table columns,
13778 * for example with a partial exclusion constraint.
13779 */
13783 {
13785 }
13786 else
13787 {
13788 /* OK, capture the index's existing definition string */
13792 indoid);
13794 defstring);
13796 /*
13797 * Remember if this index is used for the table's replica identity
13798 * or if it is a clustered index, so that ATPostAlterTypeCleanup()
13799 * can queue up commands necessary to restore those properties.
13800 */
13803 }
13804 }
13805 }
13807 /*
13808 * Subroutine for ATExecAlterColumnType: remember that a statistics object
13809 * needs to be rebuilt (which we might already know).
13810 */
13811 static void
13813 {
13814 /*
13815 * This de-duplication check is critical for two independent reasons: we
13816 * mustn't try to recreate the same statistics object twice, and if the
13817 * statistics object depends on more than one column whose type is to be
13818 * altered, we must capture its definition string before applying any of
13819 * the type changes. ruleutils.c will get confused if we ask again later.
13820 */
13822 {
13823 /* OK, capture the statistics object's existing definition string */
13827 stxoid);
13829 defstring);
13830 }
13831 }
13833 /*
13834 * Cleanup after we've finished all the ALTER TYPE operations for a
13835 * particular relation. We have to drop and recreate all the indexes
13836 * and constraints that depend on the altered columns. We do the
13837 * actual dropping here, but re-creation is managed by adding work
13838 * queue entries to do those steps later.
13839 */
13840 static void
13842 {
13843 ObjectAddress obj;
13848 /*
13849 * Collect all the constraints and indexes to drop so we can process them
13850 * in a single call. That way we don't have to worry about dependencies
13851 * among them.
13852 */
13855 /*
13856 * Re-parse the index and constraint definitions, and attach them to the
13857 * appropriate work queue entries. We do this before dropping because in
13858 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
13859 * lock on the table the constraint is attached to, and we need to get
13860 * that before reparsing/dropping.
13861 *
13862 * We can't rely on the output of deparsing to tell us which relation to
13863 * operate on, because concurrent activity might have made the name
13864 * resolve differently. Instead, we've got to use the OID of the
13865 * constraint or index we're processing to figure out which relation to
13866 * operate on.
13867 */
13870 {
13872 HeapTuple tup;
13873 Form_pg_constraint con;
13874 Oid relid;
13875 Oid confrelid;
13885 else
13886 {
13887 /* must be a domain constraint */
13891 }
13900 /*
13901 * If the constraint is inherited (only), we don't want to inject a
13902 * new definition here; it'll get recreated when
13903 * ATAddCheckNNConstraint recurses from adding the parent table's
13904 * constraint. But we had to carry the info this far so that we can
13905 * drop the constraint below.
13906 */
13910 /*
13911 * When rebuilding an FK constraint that references the table we're
13912 * modifying, we might not yet have any lock on the FK's table, so get
13913 * one now. We'll need AccessExclusiveLock for the DROP CONSTRAINT
13914 * step, so there's no value in asking for anything weaker.
13915 */
13922 }
13925 {
13927 Oid relid;
13936 }
13938 /* add dependencies for new statistics */
13941 {
13943 Oid relid;
13952 }
13954 /*
13955 * Queue up command to restore replica identity index marking
13956 */
13958 {
13967 /* do it after indexes and constraints */
13970 }
13972 /*
13973 * Queue up command to restore marking of index used for cluster.
13974 */
13976 {
13982 /* do it after indexes and constraints */
13985 }
13987 /*
13988 * It should be okay to use DROP_RESTRICT here, since nothing else should
13989 * be depending on these objects.
13990 */
13995 /*
13996 * The objects will get recreated during subsequent passes over the work
13997 * queue.
13998 */
13999 }
14001 /*
14002 * Parse the previously-saved definition string for a constraint, index or
14003 * statistics object against the newly-established column data type(s), and
14004 * queue up the resulting command parsetrees for execution.
14005 *
14006 * This might fail if, for example, you have a WHERE clause that uses an
14007 * operator that's not available for the new column type.
14008 */
14009 static void
14012 {
14016 Relation rel;
14018 /*
14019 * We expect that we will get only ALTER TABLE and CREATE INDEX
14020 * statements. Hence, there is no need to pass them through
14021 * parse_analyze_*() or the rewriter, but instead we need to pass them
14022 * through parse_utilcmd.c to make them ready for execution.
14023 */
14027 {
14035 cmd));
14037 {
14043 cmd,
14049 }
14054 cmd));
14055 else
14057 }
14059 /* Caller should already have acquired whatever lock we need. */
14062 /*
14063 * Attach each generated command to the proper place in the work queue.
14064 * Note this could result in creation of entirely new work-queue entries.
14065 *
14066 * Also note that we have to tweak the command subtypes, because it turns
14067 * out that re-creation of indexes and constraints has to act a bit
14068 * differently from initial creation.
14069 */
14071 {
14078 {
14085 /* keep the index's comment */
14093 }
14095 {
14100 {
14104 {
14106 Oid indoid;
14113 /* keep any comment on the index */
14122 /* recreate any comment on the constraint */
14124 AT_PASS_OLD_INDEX,
14125 oldId,
14126 rel,
14127 NIL,
14129 }
14131 {
14135 /* rewriting neither side of a FK */
14144 /* recreate any comment on the constraint */
14146 AT_PASS_OLD_CONSTR,
14147 oldId,
14148 rel,
14149 NIL,
14151 }
14153 {
14154 /*
14155 * The parser will create AT_AttSetNotNull subcommands for
14156 * columns of PRIMARY KEY indexes/constraints, but we need
14157 * not do anything with them here, because the columns'
14158 * NOT NULL marks will already have been propagated into
14159 * the new table definition.
14160 */
14161 }
14162 else
14165 }
14166 }
14168 {
14172 {
14181 /* recreate any comment on the constraint */
14183 AT_PASS_OLD_CONSTR,
14184 oldId,
14185 NULL,
14188 }
14189 else
14192 }
14194 {
14198 /* keep the statistics object's comment */
14206 }
14207 else
14210 }
14213 }
14215 /*
14216 * Subroutine for ATPostAlterTypeParse() to recreate any existing comment
14217 * for a table or domain constraint that is being rebuilt.
14218 *
14219 * objid is the OID of the constraint.
14220 * Pass "rel" for a table constraint, or "domname" (domain's qualified name
14221 * as a string list) for a domain constraint.
14222 * (We could dig that info, as well as the conname, out of the pg_constraint
14223 * entry; but callers already have them so might as well pass them.)
14224 */
14225 static void
14229 {
14234 /* Look for comment for object wanted, and leave if none */
14239 /* Build CommentStmt node, copying all input data for safety */
14242 {
14248 }
14249 else
14250 {
14255 }
14258 /* Append it to list of commands */
14263 }
14265 /*
14266 * Subroutine for ATPostAlterTypeParse(). Calls out to CheckIndexCompatible()
14267 * for the real analysis, then mutates the IndexStmt based on that verdict.
14268 */
14269 static void
14271 {
14276 {
14279 /* If it's a partitioned index, there is no storage to share. */
14281 {
14285 }
14287 }
14288 }
14290 /*
14291 * Subroutine for ATPostAlterTypeParse().
14292 *
14293 * Stash the old P-F equality operator into the Constraint node, for possible
14294 * use by ATAddForeignKeyConstraint() in determining whether revalidation of
14295 * this constraint can be skipped.
14296 */
14297 static void
14299 {
14300 HeapTuple tup;
14301 Datum adatum;
14315 Anum_pg_constraint_conpfeqop);
14318 /* test follows the one in ri_FetchConstraintInfo() */
14325 /* stash a List of the operator Oids in our Constraint node */
14330 }
14332 /*
14333 * ALTER COLUMN .. OPTIONS ( ... )
14334 *
14335 * Returns the address of the modified column
14336 */
14337 static ObjectAddress
14341 LOCKMODE lockmode)
14342 {
14343 Relation ftrel;
14344 Relation attrel;
14347 HeapTuple tuple;
14348 HeapTuple newtuple;
14353 Datum datum;
14354 Form_pg_foreign_table fttableform;
14355 Form_pg_attribute atttableform;
14356 AttrNumber attnum;
14357 ObjectAddress address;
14362 /* First, determine FDW validator associated to the foreign table. */
14385 /* Prevent them from altering a system attribute */
14394 /* Initialize buffers for new tuple values */
14399 /* Extract the current options */
14401 tuple,
14402 Anum_pg_attribute_attfdwoptions,
14407 /* Transform the options */
14409 datum,
14410 options,
14415 else
14420 /* Everything looks good - update the tuple */
14440 }
14442 /*
14443 * ALTER TABLE OWNER
14444 *
14445 * recursing is true if we are recursing from a table to its indexes,
14446 * sequences, or toast table. We don't allow the ownership of those things to
14447 * be changed separately from the parent table. Also, we can skip permission
14448 * checks (this is necessary not just an optimization, else we'd fail to
14449 * handle toast tables properly).
14450 *
14451 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
14452 * free-standing composite type.
14453 */
14454 void
14456 {
14457 Relation target_rel;
14458 Relation class_rel;
14459 HeapTuple tuple;
14460 Form_pg_class tuple_class;
14462 /*
14463 * Get exclusive lock till end of transaction on the target table. Use
14464 * relation_open so that we can work on indexes and sequences.
14465 */
14468 /* Get its pg_class tuple, too */
14476 /* Can we change the ownership of this tuple? */
14478 {
14484 /* ok to change owner */
14488 {
14489 /*
14490 * Because ALTER INDEX OWNER used to be allowed, and in fact
14491 * is generated by old versions of pg_dump, we give a warning
14492 * and do nothing rather than erroring out. Also, to avoid
14493 * unnecessary chatter while restoring those old dumps, say
14494 * nothing at all if the command would be a no-op anyway.
14495 */
14502 /* quick hack to exit via the no-op path */
14504 }
14518 {
14519 /* if it's an owned sequence, disallow changing it by itself */
14520 Oid tableId;
14521 int32 colId;
14532 }
14541 /* translator: %s is an SQL ALTER command */
14548 /* FALL THRU */
14555 }
14557 /*
14558 * If the new owner is the same as the existing owner, consider the
14559 * command to have succeeded. This is for dump restoration purposes.
14560 */
14562 {
14567 Datum aclDatum;
14569 HeapTuple newtuple;
14571 /* skip permission checks when recursing to index or toast table */
14573 {
14574 /* Superusers can always do it */
14576 {
14578 AclResult aclresult;
14580 /* Otherwise, must be owner of the existing object */
14585 /* Must be able to become new owner */
14588 /* New owner must have CREATE privilege on namespace */
14590 ACL_CREATE);
14594 }
14595 }
14603 /*
14604 * Determine the modified ACL for the new owner. This is only
14605 * necessary when the ACL is non-null.
14606 */
14608 Anum_pg_class_relacl,
14611 {
14616 }
14618 newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
14624 /*
14625 * We must similarly update any per-column ACLs to reflect the new
14626 * owner; for neatness reasons that's split out as a subroutine.
14627 */
14630 newOwnerId);
14632 /*
14633 * Update owner dependency reference, if any. A composite type has
14634 * none, because it's tracked for the pg_type entry instead of here;
14635 * indexes and TOAST tables don't have their own entries either.
14636 */
14642 newOwnerId);
14644 /*
14645 * Also change the ownership of the table's row type, if it has one
14646 */
14650 /*
14651 * If we are operating on a table or materialized view, also change
14652 * the ownership of any indexes and sequences that belong to the
14653 * relation, as well as its toast table (if it has one).
14654 */
14659 {
14663 /* Find all the indexes belonging to this relation */
14666 /* For each index, recursively change its ownership */
14671 }
14673 /* If it has a toast table, recurse to change its ownership */
14678 /* If it has dependent sequences, recurse to change them too */
14680 }
14687 }
14689 /*
14690 * change_owner_fix_column_acls
14691 *
14692 * Helper function for ATExecChangeOwner. Scan the columns of the table
14693 * and fix any non-null column ACLs to reflect the new owner.
14694 */
14695 static void
14697 {
14698 Relation attRelation;
14699 SysScanDesc scan;
14701 HeapTuple attributeTuple;
14705 Anum_pg_attribute_attrelid,
14711 {
14717 Datum aclDatum;
14719 HeapTuple newtuple;
14721 /* Ignore dropped columns */
14726 Anum_pg_attribute_attacl,
14729 /* Null ACLs do not require changes */
14748 }
14751 }
14753 /*
14754 * change_owner_recurse_to_sequences
14755 *
14756 * Helper function for ATExecChangeOwner. Examines pg_depend searching
14757 * for sequences that are dependent on serial columns, and changes their
14758 * ownership.
14759 */
14760 static void
14762 {
14763 Relation depRel;
14764 SysScanDesc scan;
14766 HeapTuple tup;
14768 /*
14769 * SERIAL sequences are those having an auto dependency on one of the
14770 * table's columns (we don't care *which* column, exactly).
14771 */
14775 Anum_pg_depend_refclassid,
14779 Anum_pg_depend_refobjid,
14782 /* we leave refobjsubid unspecified */
14788 {
14790 Relation seqRel;
14792 /* skip dependencies other than auto dependencies on columns */
14799 /* Use relation_open just in case it's an index */
14802 /* skip non-sequence relations */
14804 {
14805 /* No need to keep the lock */
14808 }
14810 /* We don't need to close the sequence while we alter it. */
14813 /* Now we can close it. Keep the lock till end of transaction. */
14815 }
14820 }
14822 /*
14823 * ALTER TABLE CLUSTER ON
14824 *
14825 * The only thing we have to do is to change the indisclustered bits.
14826 *
14827 * Return the address of the new clustering index.
14828 */
14829 static ObjectAddress
14831 {
14832 Oid indexOid;
14833 ObjectAddress address;
14843 /* Check index is valid to cluster on */
14846 /* And do the work */
14853 }
14855 /*
14856 * ALTER TABLE SET WITHOUT CLUSTER
14857 *
14858 * We have to find any indexes on the table that have indisclustered bit
14859 * set and turn it off.
14860 */
14861 static void
14863 {
14865 }
14867 /*
14868 * Preparation phase for SET ACCESS METHOD
14869 *
14870 * Check that access method exists. If it is the same as the table's current
14871 * access method, it is a no-op. Otherwise, a table rewrite is necessary.
14872 */
14873 static void
14875 {
14876 Oid amoid;
14878 /* Check that the table access method exists */
14884 /* Save info for Phase 3 to do the real work */
14887 }
14889 /*
14890 * ALTER TABLE SET TABLESPACE
14891 */
14892 static void
14893 ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, const char *tablespacename, LOCKMODE lockmode)
14894 {
14895 Oid tablespaceId;
14897 /* Check that the tablespace exists */
14900 /* Check permissions except when moving to database's default */
14902 {
14903 AclResult aclresult;
14908 }
14910 /* Save info for Phase 3 to do the real work */
14917 }
14919 /*
14920 * Set, reset, or replace reloptions.
14921 */
14922 static void
14924 LOCKMODE lockmode)
14925 {
14926 Oid relid;
14927 Relation pgclass;
14928 HeapTuple tuple;
14929 HeapTuple newtuple;
14930 Datum datum;
14932 Datum newOptions;
14943 /* Fetch heap tuple */
14950 {
14951 /*
14952 * If we're supposed to replace the reloptions list, we just pretend
14953 * there were none before.
14954 */
14957 }
14958 else
14959 {
14960 /* Get the old reloptions */
14963 }
14965 /* Generate new proposed reloptions (text array) */
14970 /* Validate */
14972 {
14995 }
14997 /* Special-case validation of view options */
14999 {
15006 {
15011 }
15013 /*
15014 * If the check option is specified, look to see if the view is
15015 * actually auto-updatable or not.
15016 */
15018 {
15027 }
15028 }
15030 /*
15031 * All we need do here is update the pg_class row; the new options will be
15032 * propagated into relcaches during post-commit cache inval.
15033 */
15040 else
15056 /* repeat the whole exercise for the toast table, if there's one */
15058 {
15059 Relation toastrel;
15064 /* Fetch heap tuple */
15070 {
15071 /*
15072 * If we're supposed to replace the reloptions list, we just
15073 * pretend there were none before.
15074 */
15077 }
15078 else
15079 {
15080 /* Get the old reloptions */
15083 }
15097 else
15116 }
15119 }
15121 /*
15122 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
15123 * rewriting to be done, so we just want to copy the data as fast as possible.
15124 */
15125 static void
15127 {
15128 Relation rel;
15129 Oid reltoastrelid;
15130 RelFileNumber newrelfilenumber;
15131 RelFileLocator newrlocator;
15135 /*
15136 * Need lock here in case we are recursing to toast table or index
15137 */
15140 /* Check first if relation can be moved to new tablespace */
15142 {
15147 }
15150 /* Fetch the list of indexes on toast relation if necessary */
15152 {
15157 }
15159 /*
15160 * Relfilenumbers are not unique in databases across tablespaces, so we
15161 * need to allocate a new one in the new tablespace.
15162 */
15166 /* Open old and new relation */
15171 /* hand off to AM to actually create new rel storage and copy the data */
15173 {
15175 }
15176 else
15177 {
15180 }
15182 /*
15183 * Update the pg_class row.
15184 *
15185 * NB: This wouldn't work if ATExecSetTableSpace() were allowed to be
15186 * executed on pg_class or its indexes (the above copy wouldn't contain
15187 * the updated pg_class entry), but that's forbidden with
15188 * CheckRelationTableSpaceMove().
15189 */
15198 /* Make sure the reltablespace change is visible */
15201 /* Move associated toast relation and/or indexes, too */
15207 /* Clean up */
15209 }
15211 /*
15212 * Special handling of ALTER TABLE SET TABLESPACE for relations with no
15213 * storage that have an interest in preserving tablespace.
15214 *
15215 * Since these have no storage the tablespace can be updated with a simple
15216 * metadata only operation to update the tablespace.
15217 */
15218 static void
15220 {
15221 /*
15222 * Shouldn't be called on relations having storage; these are processed in
15223 * phase 3.
15224 */
15227 /* check if relation can be moved to its new tablespace */
15229 {
15234 }
15236 /* Update can be done, so change reltablespace */
15241 /* Make sure the reltablespace change is visible */
15243 }
15245 /*
15246 * Alter Table ALL ... SET TABLESPACE
15247 *
15248 * Allows a user to move all objects of some type in a given tablespace in the
15249 * current database to another tablespace. Objects can be chosen based on the
15250 * owner of the object also, to allow users to move only their objects.
15251 * The user must have CREATE rights on the new tablespace, as usual. The main
15252 * permissions handling is done by the lower-level table move function.
15253 *
15254 * All to-be-moved objects are locked first. If NOWAIT is specified and the
15255 * lock can't be acquired then we ereport(ERROR).
15256 */
15257 Oid
15259 {
15263 Relation rel;
15264 TableScanDesc scan;
15265 HeapTuple tuple;
15266 Oid orig_tablespaceoid;
15267 Oid new_tablespaceoid;
15270 /* Ensure we were not asked to move something we can't */
15277 /* Get the orig and new tablespace OIDs */
15281 /* Can't move shared relations in to or out of pg_global */
15282 /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
15289 /*
15290 * Must have CREATE rights on the new tablespace, unless it is the
15291 * database default tablespace (which all users implicitly have CREATE
15292 * rights on).
15293 */
15295 {
15296 AclResult aclresult;
15299 ACL_CREATE);
15303 }
15305 /*
15306 * Now that the checks are done, check if we should set either to
15307 * InvalidOid because it is our database's default tablespace.
15308 */
15315 /* no-op */
15319 /*
15320 * Walk the list of objects in the tablespace and move them. This will
15321 * only find objects in our database, of course.
15322 */
15324 Anum_pg_class_reltablespace,
15331 {
15335 /*
15336 * Do not move objects in pg_catalog as part of this, if an admin
15337 * really wishes to do so, they can issue the individual ALTER
15338 * commands directly.
15339 *
15340 * Also, explicitly avoid any shared tables, temp tables, or TOAST
15341 * (TOAST will be moved with the main table).
15342 */
15349 /* Only move the object type requested */
15360 /* Check if we are only moving objects owned by certain roles */
15364 /*
15365 * Handle permissions-checking here since we are locking the tables
15366 * and also to avoid doing a bunch of work only to fail part-way. Note
15367 * that permissions will also be checked by AlterTableInternal().
15368 *
15369 * Caller must be considered an owner on the table to move it.
15370 */
15382 else
15385 /* Add to our list of objects to move */
15387 }
15399 /* Everything is locked, loop through and move all of the relations. */
15401 {
15411 /* OID is set by AlterTableInternal */
15414 }
15417 }
15419 static void
15421 {
15422 SMgrRelation dstrel;
15426 /*
15427 * Since we copy the file directly without looking at the shared buffers,
15428 * we'd better first flush out any pages of the source relation that are
15429 * in shared buffers. We assume no new changes will be made while we are
15430 * holding exclusive lock on the rel.
15431 */
15434 /*
15435 * Create and copy all forks of the relation, and schedule unlinking of
15436 * old physical files.
15437 *
15438 * NOTE: any conflict in relfilenumber value will be caught in
15439 * RelationCreateStorage().
15440 */
15443 /* copy main fork */
15447 /* copy those extra forks that exist */
15450 {
15452 {
15455 /*
15456 * WAL log creation if the relation is persistent, or this is the
15457 * init fork of an unlogged relation.
15458 */
15465 }
15466 }
15468 /* drop old relation, and close new one */
15471 }
15473 /*
15474 * ALTER TABLE ENABLE/DISABLE TRIGGER
15475 *
15476 * We just pass this off to trigger.c.
15477 */
15478 static void
15481 LOCKMODE lockmode)
15482 {
15485 lockmode);
15489 }
15491 /*
15492 * ALTER TABLE ENABLE/DISABLE RULE
15493 *
15494 * We just pass this off to rewriteDefine.c.
15495 */
15496 static void
15499 {
15504 }
15506 /*
15507 * ALTER TABLE INHERIT
15508 *
15509 * Add a parent to the child's parents. This verifies that all the columns and
15510 * check constraints of the parent appear in the child and that they have the
15511 * same data types and expressions.
15512 */
15513 static void
15515 {
15530 }
15532 /*
15533 * Return the address of the new parent relation.
15534 */
15535 static ObjectAddress
15537 {
15538 Relation parent_rel;
15540 ObjectAddress address;
15543 /*
15544 * A self-exclusive lock is needed here. See the similar case in
15545 * MergeAttributes() for a full explanation.
15546 */
15549 /*
15550 * Must be owner of both parent and child -- child was checked by
15551 * ATSimplePermissions call in ATPrepCmd
15552 */
15555 /* Permanent rels cannot inherit from temporary ones */
15563 /* If parent rel is temp, it must belong to this session */
15570 /* Ditto for the child */
15577 /* Prevent partitioned tables from becoming inheritance parents */
15584 /* Likewise for partitions */
15590 /*
15591 * Prevent circularity by seeing if proposed parent inherits from child.
15592 * (In particular, this disallows making a rel inherit from itself.)
15593 *
15594 * This is not completely bulletproof because of race conditions: in
15595 * multi-level inheritance trees, someone else could concurrently be
15596 * making another inheritance link that closes the loop but does not join
15597 * either of the rels we have locked. Preventing that seems to require
15598 * exclusive locks on the entire inheritance tree, which is a cure worse
15599 * than the disease. find_all_inheritors() will cope with circularity
15600 * anyway, so don't sweat it too much.
15601 *
15602 * We use weakest lock we can on child's children, namely AccessShareLock.
15603 */
15615 /*
15616 * If child_rel has row-level triggers with transition tables, we
15617 * currently don't allow it to become an inheritance child. See also
15618 * prohibitions in ATExecAttachPartition() and CreateTrigger().
15619 */
15626 errdetail("ROW triggers with transition tables are not supported in inheritance hierarchies.")));
15628 /* OK to create inheritance */
15631 /*
15632 * If parent_rel has a primary key, then child_rel has not-null
15633 * constraints that make these columns as non nullable. Make those
15634 * constraints as inherited.
15635 */
15641 /* keep our lock on the parent relation until commit */
15645 }
15647 /*
15648 * CreateInheritance
15649 * Catalog manipulation portion of creating inheritance between a child
15650 * table and a parent table.
15651 *
15652 * Common to ATExecAddInherit() and ATExecAttachPartition().
15653 */
15654 static void
15656 {
15657 Relation catalogRelation;
15658 SysScanDesc scan;
15659 ScanKeyData key;
15660 HeapTuple inheritsTuple;
15661 int32 inhseqno;
15663 /* Note: get RowExclusiveLock because we will write pg_inherits below. */
15666 /*
15667 * Check for duplicates in the list of parents, and determine the highest
15668 * inhseqno already present; we'll use the next one for the new parent.
15669 * Also, if proposed child is a partition, it cannot already be
15670 * inheriting.
15671 *
15672 * Note: we do not reject the case where the child already inherits from
15673 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
15674 */
15676 Anum_pg_inherits_inhrelid,
15682 /* inhseqno sequences start at 1 */
15685 {
15696 }
15699 /* Match up the columns and bump attinhcount as needed */
15702 /* Match up the constraints and bump coninhcount as needed */
15705 /*
15706 * OK, it looks valid. Make the catalog entries that show inheritance.
15707 */
15711 catalogRelation,
15713 RELKIND_PARTITIONED_TABLE);
15715 /* Now we're done with pg_inherits */
15717 }
15719 /*
15720 * Obtain the source-text form of the constraint expression for a check
15721 * constraint, given its pg_constraint tuple
15722 */
15725 {
15726 Form_pg_constraint con;
15728 Datum attr;
15729 Datum expr;
15739 }
15741 /*
15742 * Determine whether two check constraints are functionally equivalent
15743 *
15744 * The test we apply is to see whether they reverse-compile to the same
15745 * source string. This insulates us from issues like whether attributes
15746 * have the same physical column numbers in parent and child relations.
15747 */
15748 static bool
15750 {
15759 else
15761 }
15763 /*
15764 * Check columns in child table match up with columns in parent, and increment
15765 * their attinhcount.
15766 *
15767 * Called by CreateInheritance
15768 *
15769 * Currently all parent columns must be found in child. Missing columns are an
15770 * error. One day we might consider creating new columns like CREATE TABLE
15771 * does. However, that is widely unpopular --- in the common use case of
15772 * partitioned tables it's a foot-gun.
15773 *
15774 * The data type must match exactly. If the parent column is NOT NULL then
15775 * the child must be as well. Defaults are not compared, however.
15776 */
15777 static void
15779 {
15780 Relation attrrel;
15781 TupleDesc parent_desc;
15787 {
15790 HeapTuple tuple;
15792 /* Ignore dropped columns in the parent. */
15796 /* Find same column in child (matching on column name). */
15799 {
15815 /*
15816 * If the parent has a not-null constraint that's not NO INHERIT,
15817 * make sure the child has one too.
15818 *
15819 * Other constraints are checked elsewhere.
15820 */
15822 {
15823 HeapTuple contup;
15832 parent_attname));
15833 }
15835 /*
15836 * Child column must be generated if and only if parent column is.
15837 */
15847 /*
15848 * OK, bump the child column's inheritance count. (If we fail
15849 * later on, this change will just roll back.)
15850 */
15857 /*
15858 * In case of partitions, we must enforce that value of attislocal
15859 * is same in all partitions. (Note: there are only inherited
15860 * attributes in partitions)
15861 */
15863 {
15866 }
15870 }
15871 else
15872 {
15876 }
15877 }
15880 }
15882 /*
15883 * Check constraints in child table match up with constraints in parent,
15884 * and increment their coninhcount.
15885 *
15886 * Constraints that are marked ONLY in the parent are ignored.
15887 *
15888 * Called by CreateInheritance
15889 *
15890 * Currently all constraints in parent must be present in the child. One day we
15891 * may consider adding new constraints like CREATE TABLE does.
15892 *
15893 * XXX This is O(N^2) which may be an issue with tables with hundreds of
15894 * constraints. As long as tables have more like 10 constraints it shouldn't be
15895 * a problem though. Even 100 constraints ought not be the end of the world.
15896 *
15897 * XXX See MergeWithExistingConstraint too if you change this code.
15898 */
15899 static void
15901 {
15902 Relation constraintrel;
15903 SysScanDesc parent_scan;
15904 ScanKeyData parent_key;
15905 HeapTuple parent_tuple;
15910 /* Outer loop scans through the parent's constraint definitions */
15912 Anum_pg_constraint_conrelid,
15919 {
15921 SysScanDesc child_scan;
15922 ScanKeyData child_key;
15923 HeapTuple child_tuple;
15930 /* if the parent's constraint is marked NO INHERIT, it's not inherited */
15934 /* Search for a child constraint matching this one */
15936 Anum_pg_constraint_conrelid,
15943 {
15945 HeapTuple child_copy;
15950 /*
15951 * CHECK constraint are matched by name, NOT NULL ones by
15952 * attribute number
15953 */
15955 {
15959 }
15961 {
15969 }
15978 /*
15979 * If the CHECK child constraint is "no inherit" then cannot
15980 * merge.
15981 *
15982 * This is not desirable for not-null constraints, mostly because
15983 * it breaks our pg_upgrade strategy, but it also makes sense on
15984 * its own: if a child has its own not-null constraint and then
15985 * acquires a parent with the same constraint, then we start to
15986 * enforce that constraint for all the descendants of that child
15987 * too, if any.
15988 */
15996 /*
15997 * If the child constraint is "not valid" then cannot merge with a
15998 * valid parent constraint
15999 */
16006 /*
16007 * OK, bump the child constraint's inheritance count. (If we fail
16008 * later on, this change will just roll back.)
16009 */
16021 /*
16022 * In case of partitions, an inherited constraint must be
16023 * inherited only once since it cannot have multiple parents and
16024 * it is never considered local.
16025 */
16027 {
16030 }
16037 }
16042 {
16055 }
16056 }
16060 }
16062 /*
16063 * ALTER TABLE NO INHERIT
16064 *
16065 * Return value is the address of the relation that is no longer parent.
16066 */
16067 static ObjectAddress
16069 {
16070 ObjectAddress address;
16071 Relation parent_rel;
16078 /*
16079 * AccessShareLock on the parent is probably enough, seeing that DROP
16080 * TABLE doesn't lock parent tables at all. We need some lock since we'll
16081 * be inspecting the parent's schema.
16082 */
16085 /*
16086 * We don't bother to check ownership of the parent table --- ownership of
16087 * the child is presumed enough rights.
16088 */
16090 /* Off to RemoveInheritance() where most of the work happens */
16093 /*
16094 * If parent_rel has a primary key, then child_rel has not-null
16095 * constraints that make these columns as non nullable. Mark those
16096 * constraints as no longer inherited by this parent.
16097 */
16100 /*
16101 * If the parent has a primary key, then we decrement counts for all NOT
16102 * NULL constraints
16103 */
16108 /* keep our lock on the parent relation until commit */
16112 }
16114 /*
16115 * MarkInheritDetached
16116 *
16117 * Set inhdetachpending for a partition, for ATExecDetachPartition
16118 * in concurrent mode. While at it, verify that no other partition is
16119 * already pending detach.
16120 */
16121 static void
16123 {
16124 Relation catalogRelation;
16125 SysScanDesc scan;
16126 ScanKeyData key;
16127 HeapTuple inheritsTuple;
16132 /*
16133 * Find pg_inherits entries by inhparent. (We need to scan them all in
16134 * order to verify that no other partition is pending detach.)
16135 */
16138 Anum_pg_inherits_inhparent,
16145 {
16146 Form_pg_inherits inhForm;
16156 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
16159 {
16160 HeapTuple newtup;
16167 newtup);
16170 /* keep looking, to ensure we catch others pending detach */
16171 }
16172 }
16174 /* Done */
16184 }
16186 /*
16187 * RemoveInheritance
16188 *
16189 * Drop a parent from the child's parents. This just adjusts the attinhcount
16190 * and attislocal of the columns and removes the pg_inherit and pg_depend
16191 * entries. expect_detached is passed down to DeleteInheritsTuple, q.v..
16192 *
16193 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
16194 * up attislocal stays true, which means if a child is ever removed from a
16195 * parent then its columns will never be automatically dropped which may
16196 * surprise. But at least we'll never surprise by dropping columns someone
16197 * isn't expecting to be dropped which would actually mean data loss.
16198 *
16199 * coninhcount and conislocal for inherited constraints are adjusted in
16200 * exactly the same way.
16201 *
16202 * Common to ATExecDropInherit() and ATExecDetachPartition().
16203 */
16204 static void
16206 {
16207 Relation catalogRelation;
16208 SysScanDesc scan;
16210 HeapTuple attributeTuple,
16211 constraintTuple;
16221 expect_detached,
16224 {
16231 else
16237 }
16239 /*
16240 * Search through child columns looking for ones matching parent rel
16241 */
16244 Anum_pg_attribute_attrelid,
16250 {
16253 /* Ignore if dropped or not inherited */
16261 {
16262 /* Decrement inhcount and possibly set islocal to true */
16272 }
16273 }
16277 /*
16278 * Likewise, find inherited check constraints and disinherit them. To do
16279 * this, we first need a list of the names of the parent's check
16280 * constraints. (We cheat a bit by only checking for name matches,
16281 * assuming that the expressions will match.)
16282 *
16283 * For NOT NULL columns, we store column numbers to match.
16284 */
16287 Anum_pg_constraint_conrelid,
16297 {
16304 }
16308 /* Now scan the child's constraints */
16310 Anum_pg_constraint_conrelid,
16317 {
16322 /*
16323 * Match CHECK constraints by name, not-null constraints by column
16324 * number, and ignore all others.
16325 */
16327 {
16329 {
16332 {
16335 }
16336 }
16337 }
16339 {
16343 {
16345 {
16348 }
16349 }
16350 }
16351 else
16355 {
16356 /* Decrement inhcount and possibly set islocal to true */
16370 }
16371 }
16377 RelationRelationId,
16381 /*
16382 * Post alter hook of this inherits. Since object_access_hook doesn't take
16383 * multiple object identifiers, we relay oid of parent relation using
16384 * auxiliary_id argument.
16385 */
16389 }
16391 /*
16392 * Adjust coninhcount of not-null constraints upwards or downwards when a
16393 * table is marked as inheriting or no longer doing so a table with a primary
16394 * key.
16395 *
16396 * Note: these constraints are not dropped, even if their inhcount goes to zero
16397 * and conislocal is false. Instead we mark the constraints as locally defined.
16398 * This is seen as more useful behavior, with no downsides. The user can always
16399 * drop them afterwards.
16400 */
16401 static void
16403 {
16406 /* Quick exit when parent has no PK */
16411 INDEX_ATTR_BITMAP_PRIMARY_KEY);
16413 {
16423 {
16426 }
16428 /*
16429 * CCI is needed in case there's a NOT NULL PRIMARY KEY column in the
16430 * parent: the relevant not-null constraint in the child already had
16431 * its inhcount modified earlier.
16432 */
16435 inhcount);
16436 }
16437 }
16439 /*
16440 * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE
16441 * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or
16442 * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will
16443 * be TypeRelationId). There's no convenient way to do this, so go trawling
16444 * through pg_depend.
16445 */
16446 static void
16448 DependencyType deptype)
16449 {
16450 Relation catalogRelation;
16451 SysScanDesc scan;
16453 HeapTuple depTuple;
16458 Anum_pg_depend_classid,
16462 Anum_pg_depend_objid,
16466 Anum_pg_depend_objsubid,
16474 {
16482 }
16486 }
16488 /*
16489 * ALTER TABLE OF
16490 *
16491 * Attach a table to a composite type, as though it had been created with CREATE
16492 * TABLE OF. All attname, atttypid, atttypmod and attcollation must match. The
16493 * subject table must not have inheritance parents. These restrictions ensure
16494 * that you cannot create a configuration impossible with CREATE TABLE OF alone.
16495 *
16496 * The address of the type is returned.
16497 */
16498 static ObjectAddress
16500 {
16502 Type typetuple;
16503 Form_pg_type typeform;
16505 Relation inheritsRelation,
16506 relationRelation;
16507 SysScanDesc scan;
16508 ScanKeyData key;
16509 AttrNumber table_attno,
16510 type_attno;
16511 TupleDesc typeTupleDesc,
16512 tableTupleDesc;
16513 ObjectAddress tableobj,
16514 typeobj;
16515 HeapTuple classtuple;
16517 /* Validate the type. */
16523 /* Fail if the table has any inheritance parents. */
16526 Anum_pg_inherits_inhrelid,
16538 /*
16539 * Check the tuple descriptors for compatibility. Unlike inheritance, we
16540 * require that the order also match. However, attnotnull need not match.
16541 */
16546 {
16547 Form_pg_attribute type_attr,
16548 table_attr;
16552 /* Get the next non-dropped type attribute. */
16558 /* Get the next non-dropped table attribute. */
16559 do
16560 {
16565 type_attname)));
16567 table_attno++;
16571 /* Compare name. */
16578 /* Compare type. */
16586 }
16589 /* Any remaining columns at the end of the table had better be dropped. */
16591 {
16600 }
16602 /* If the table was already typed, drop the existing dependency. */
16605 DEPENDENCY_NORMAL);
16607 /* Record a dependency on the new type. */
16616 /* Update pg_class.reloftype */
16632 }
16634 /*
16635 * ALTER TABLE NOT OF
16636 *
16637 * Detach a typed table from its originating type. Just clear reloftype and
16638 * remove the dependency.
16639 */
16640 static void
16642 {
16644 Relation relationRelation;
16645 HeapTuple tuple;
16653 /*
16654 * We don't bother to check ownership of the type --- ownership of the
16655 * table is presumed enough rights. No lock required on the type, either.
16656 */
16659 DEPENDENCY_NORMAL);
16661 /* Clear pg_class.reloftype */
16673 }
16675 /*
16676 * relation_mark_replica_identity: Update a table's replica identity
16677 *
16678 * Iff ri_type = REPLICA_IDENTITY_INDEX, indexOid must be the Oid of a suitable
16679 * index. Otherwise, it must be InvalidOid.
16680 *
16681 * Caller had better hold an exclusive lock on the relation, as the results
16682 * of running two of these concurrently wouldn't be pretty.
16683 */
16684 static void
16687 {
16688 Relation pg_index;
16689 Relation pg_class;
16690 HeapTuple pg_class_tuple;
16691 HeapTuple pg_index_tuple;
16692 Form_pg_class pg_class_form;
16693 Form_pg_index pg_index_form;
16696 /*
16697 * Check whether relreplident has changed, and update it if so.
16698 */
16707 {
16710 }
16714 /*
16715 * Update the per-index indisreplident flags correctly.
16716 */
16719 {
16730 {
16731 /* Set the bit if not already set. */
16733 {
16736 }
16737 }
16738 else
16739 {
16740 /* Unset the bit if set. */
16742 {
16745 }
16746 }
16749 {
16754 /*
16755 * Invalidate the relcache for the table, so that after we commit
16756 * all sessions will refresh the table's replica identity index
16757 * before attempting any UPDATE or DELETE on the table. (If we
16758 * changed the table's pg_class row above, then a relcache inval
16759 * is already queued due to that; but we might not have.)
16760 */
16762 }
16764 }
16767 }
16769 /*
16770 * ALTER TABLE <name> REPLICA IDENTITY ...
16771 */
16772 static void
16774 {
16775 Oid indexOid;
16776 Relation indexRel;
16780 {
16783 }
16785 {
16788 }
16790 {
16793 }
16795 {
16797 }
16798 else
16801 /* Check that the index exists */
16811 /* Check that the index is on the relation we're altering. */
16819 /* The AM must support uniqueness, and the index must in fact be unique. */
16826 /* Deferred indexes are not guaranteed to be always unique. */
16832 /* Expression indexes aren't supported. */
16838 /* Predicate indexes aren't supported. */
16845 /* Check index for nullable columns. */
16847 {
16849 Form_pg_attribute attr;
16851 /*
16852 * Reject any other system columns. (Going forward, we'll disallow
16853 * indexes containing such columns in the first place, but they might
16854 * exist in older branches.)
16855 */
16859 errmsg("index \"%s\" cannot be used as replica identity because column %d is a system column",
16869 }
16871 /* This index is suitable for use as a replica identity. Mark it. */
16875 }
16877 /*
16878 * ALTER TABLE ENABLE/DISABLE ROW LEVEL SECURITY
16879 */
16880 static void
16882 {
16883 Relation pg_class;
16884 Oid relid;
16885 HeapTuple tuple;
16889 /* Pull the record for this relation and update it */
16905 }
16907 /*
16908 * ALTER TABLE FORCE/NO FORCE ROW LEVEL SECURITY
16909 */
16910 static void
16912 {
16913 Relation pg_class;
16914 Oid relid;
16915 HeapTuple tuple;
16934 }
16936 /*
16937 * ALTER FOREIGN TABLE <name> OPTIONS (...)
16938 */
16939 static void
16941 {
16942 Relation ftrel;
16945 HeapTuple tuple;
16950 Datum datum;
16951 Form_pg_foreign_table tableform;
16973 /* Extract the current options */
16975 tuple,
16976 Anum_pg_foreign_table_ftoptions,
16981 /* Transform the options */
16983 datum,
16984 options,
16989 else
16994 /* Everything looks good - update the tuple */
17001 /*
17002 * Invalidate relcache so that all sessions will refresh any cached plans
17003 * that might depend on the old options.
17004 */
17013 }
17015 /*
17016 * ALTER TABLE ALTER COLUMN SET COMPRESSION
17017 *
17018 * Return value is the address of the modified column
17019 */
17020 static ObjectAddress
17024 LOCKMODE lockmode)
17025 {
17026 Relation attrel;
17027 HeapTuple tuple;
17028 Form_pg_attribute atttableform;
17029 AttrNumber attnum;
17032 ObjectAddress address;
17038 /* copy the cache entry so we can scribble on it below */
17046 /* prevent them from altering a system attribute */
17054 /*
17055 * Check that column type is compressible, then get the attribute
17056 * compression method code
17057 */
17060 /* update pg_attribute entry */
17066 attnum);
17068 /*
17069 * Apply the change to indexes as well (only for simple index columns,
17070 * matching behavior of index.c ConstructTupleDescriptor()).
17071 */
17075 lockmode);
17081 /* make changes visible */
17087 }
17090 /*
17091 * Preparation phase for SET LOGGED/UNLOGGED
17092 *
17093 * This verifies that we're not trying to change a temp table. Also,
17094 * existing foreign key constraints are checked to avoid ending up with
17095 * permanent tables referencing unlogged tables.
17096 *
17097 * Return value is false if the operation is a no-op (in which case the
17098 * checks are skipped), otherwise true.
17099 */
17100 static bool
17102 {
17103 Relation pg_constraint;
17104 HeapTuple tuple;
17105 SysScanDesc scan;
17108 /*
17109 * Disallow changing status for a temp table. Also verify whether we can
17110 * get away with doing nothing; in such cases we don't need to run the
17111 * checks below, either.
17112 */
17114 {
17124 /* nothing to do */
17129 /* nothing to do */
17132 }
17134 /*
17135 * Check that the table is not part of any publication when changing to
17136 * UNLOGGED, as UNLOGGED tables can't be published.
17137 */
17146 /*
17147 * Check existing foreign key constraints to preserve the invariant that
17148 * permanent tables cannot reference unlogged ones. Self-referencing
17149 * foreign keys can safely be ignored.
17150 */
17153 /*
17154 * Scan conrelid if changing to permanent, else confrelid. This also
17155 * determines whether a useful index exists.
17156 */
17159 Anum_pg_constraint_confrelid,
17167 {
17171 {
17172 Oid foreignrelid;
17173 Relation foreignrel;
17175 /* the opposite end of what we used as scankey */
17178 /* ignore if self-referencing */
17185 {
17193 }
17194 else
17195 {
17203 }
17206 }
17207 }
17214 }
17216 /*
17217 * Execute ALTER TABLE SET SCHEMA
17218 */
17219 ObjectAddress
17221 {
17222 Relation rel;
17223 Oid relid;
17224 Oid oldNspOid;
17225 Oid nspOid;
17228 ObjectAddress myself;
17232 RangeVarCallbackForAlterRelation,
17236 {
17241 }
17247 /* If it's an owned sequence, disallow moving it by itself. */
17249 {
17250 Oid tableId;
17251 int32 colId;
17261 }
17263 /* Get and lock schema OID and check its permissions. */
17267 /* common checks on switching namespaces */
17279 /* close rel, but keep lock until commit */
17283 }
17285 /*
17286 * The guts of relocating a table or materialized view to another namespace:
17287 * besides moving the relation itself, its dependent objects are relocated to
17288 * the new schema.
17289 */
17290 void
17293 {
17294 Relation classRel;
17298 /* OK, modify the pg_class row and pg_depend entry */
17304 /* Fix the table's row type too, if it has one */
17309 /* Fix other dependent stuff */
17313 {
17319 }
17322 }
17324 /*
17325 * The guts of relocating a relation to another namespace: fix the pg_class
17326 * entry, and the pg_depend entry if any. Caller must already have
17327 * opened and write-locked pg_class.
17328 */
17329 void
17334 {
17335 HeapTuple classTup;
17336 Form_pg_class classForm;
17337 ObjectAddress thisobj;
17351 /*
17352 * If the object has already been moved, don't move it again. If it's
17353 * already in the right place, don't move it, but still fire the object
17354 * access hook.
17355 */
17358 {
17359 /* check for duplicate name (more friendly than unique-index failure) */
17368 /* classTup is a copy, so OK to scribble on */
17373 /* Update dependency on schema if caller said so */
17376 relOid,
17377 NamespaceRelationId,
17378 oldNspOid,
17382 }
17384 {
17388 }
17391 }
17393 /*
17394 * Move all indexes for the specified relation to another namespace.
17395 *
17396 * Note: we assume adequate permission checking was done by the caller,
17397 * and that the caller has a suitable lock on the owning relation.
17398 */
17399 static void
17402 {
17409 {
17411 ObjectAddress thisobj;
17417 /*
17418 * Note: currently, the index will not have its own dependency on the
17419 * namespace, so we don't need to do changeDependencyFor(). There's no
17420 * row type in pg_type, either.
17421 *
17422 * XXX this objsMoved test may be pointless -- surely we have a single
17423 * dependency link from a relation to each index?
17424 */
17426 {
17431 }
17432 }
17435 }
17437 /*
17438 * Move all identity and SERIAL-column sequences of the specified relation to another
17439 * namespace.
17440 *
17441 * Note: we assume adequate permission checking was done by the caller,
17442 * and that the caller has a suitable lock on the owning relation.
17443 */
17444 static void
17447 LOCKMODE lockmode)
17448 {
17449 Relation depRel;
17450 SysScanDesc scan;
17452 HeapTuple tup;
17454 /*
17455 * SERIAL sequences are those having an auto dependency on one of the
17456 * table's columns (we don't care *which* column, exactly).
17457 */
17461 Anum_pg_depend_refclassid,
17465 Anum_pg_depend_refobjid,
17468 /* we leave refobjsubid unspecified */
17474 {
17476 Relation seqRel;
17478 /* skip dependencies other than auto dependencies on columns */
17485 /* Use relation_open just in case it's an index */
17488 /* skip non-sequence relations */
17490 {
17491 /* No need to keep the lock */
17494 }
17496 /* Fix the pg_class and pg_depend entries */
17501 /*
17502 * Sequences used to have entries in pg_type, but no longer do. If we
17503 * ever re-instate that, we'll need to move the pg_type entry to the
17504 * new namespace, too (using AlterTypeNamespaceInternal).
17505 */
17508 /* Now we can close it. Keep the lock till end of transaction. */
17510 }
17515 }
17518 /*
17519 * This code supports
17520 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
17521 *
17522 * Because we only support this for TEMP tables, it's sufficient to remember
17523 * the state in a backend-local data structure.
17524 */
17526 /*
17527 * Register a newly-created relation's ON COMMIT action.
17528 */
17529 void
17531 {
17533 MemoryContext oldcxt;
17535 /*
17536 * We needn't bother registering the relation unless there is an ON COMMIT
17537 * action we need to take.
17538 */
17550 /*
17551 * We use lcons() here so that ON COMMIT actions are processed in reverse
17552 * order of registration. That might not be essential but it seems
17553 * reasonable.
17554 */
17558 }
17560 /*
17561 * Unregister any ON COMMIT action when a relation is deleted.
17562 *
17563 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
17564 */
17565 void
17567 {
17571 {
17575 {
17578 }
17579 }
17580 }
17582 /*
17583 * Perform ON COMMIT actions.
17584 *
17585 * This is invoked just before actually committing, since it's possible
17586 * to encounter errors.
17587 */
17588 void
17590 {
17596 {
17599 /* Ignore entry if already dropped in this xact */
17604 {
17607 /* Do nothing (there shouldn't be such entries, actually) */
17611 /*
17612 * If this transaction hasn't accessed any temporary
17613 * relations, we can skip truncating ON COMMIT DELETE ROWS
17614 * tables, as they must still be empty.
17615 */
17622 }
17623 }
17625 /*
17626 * Truncate relations before dropping so that all dependencies between
17627 * relations are removed after they are worked on. Doing it like this
17628 * might be a waste as it is possible that a relation being truncated will
17629 * be dropped anyway due to its parent being dropped, but this makes the
17630 * code more robust because of not having to re-check that the relation
17631 * exists at truncation time.
17632 */
17637 {
17641 {
17642 ObjectAddress object;
17651 }
17653 /*
17654 * Object deletion might involve toast table access (to clean up
17655 * toasted catalog entries), so ensure we have a valid snapshot.
17656 */
17659 /*
17660 * Since this is an automatic drop, rather than one directly initiated
17661 * by the user, we pass the PERFORM_DELETION_INTERNAL flag.
17662 */
17668 #ifdef USE_ASSERT_CHECKING
17670 /*
17671 * Note that table deletion will call remove_on_commit_action, so the
17672 * entry should get marked as deleted.
17673 */
17675 {
17682 }
17683 #endif
17684 }
17685 }
17687 /*
17688 * Post-commit or post-abort cleanup for ON COMMIT management.
17689 *
17690 * All we do here is remove no-longer-needed OnCommitItem entries.
17691 *
17692 * During commit, remove entries that were deleted during this transaction;
17693 * during abort, remove those created during this transaction.
17694 */
17695 void
17697 {
17701 {
17706 {
17707 /* cur_item must be removed */
17710 }
17711 else
17712 {
17713 /* cur_item must be preserved */
17716 }
17717 }
17718 }
17720 /*
17721 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
17722 *
17723 * During subabort, we can immediately remove entries created during this
17724 * subtransaction. During subcommit, just relabel entries marked during
17725 * this subtransaction as being the parent's responsibility.
17726 */
17727 void
17729 SubTransactionId parentSubid)
17730 {
17734 {
17738 {
17739 /* cur_item must be removed */
17742 }
17743 else
17744 {
17745 /* cur_item must be preserved */
17750 }
17751 }
17752 }
17754 /*
17755 * This is intended as a callback for RangeVarGetRelidExtended(). It allows
17756 * the relation to be locked only if (1) it's a plain or partitioned table,
17757 * materialized view, or TOAST table and (2) the current user is the owner (or
17758 * the superuser). This meets the permission-checking needs of CLUSTER,
17759 * REINDEX TABLE, and REFRESH MATERIALIZED VIEW; we expose it here so that it
17760 * can be used by all.
17761 */
17762 void
17765 {
17768 /* Nothing to do if the relation was not found. */
17772 /*
17773 * If the relation does exist, check whether it's an index. But note that
17774 * the relation might have been dropped between the time we did the name
17775 * lookup and now. In that case, there's nothing to do.
17776 */
17786 /* Check permissions */
17788 aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relId)), relation->relname);
17789 }
17791 /*
17792 * Callback to RangeVarGetRelidExtended() for TRUNCATE processing.
17793 */
17794 static void
17797 {
17798 HeapTuple tuple;
17800 /* Nothing to do if the relation was not found. */
17812 }
17814 /*
17815 * Callback for RangeVarGetRelidExtended(). Checks that the current user is
17816 * the owner of the relation, or superuser.
17817 */
17818 void
17821 {
17822 HeapTuple tuple;
17824 /* Nothing to do if the relation was not found. */
17844 }
17846 /*
17847 * Common RangeVarGetRelid callback for rename, set schema, and alter table
17848 * processing.
17849 */
17850 static void
17853 {
17855 ObjectType reltype;
17856 HeapTuple tuple;
17857 Form_pg_class classform;
17858 AclResult aclresult;
17867 /* Must own relation. */
17871 /* No system table modifications unless explicitly allowed. */
17878 /*
17879 * Extract the specified relation type from the statement parse tree.
17880 *
17881 * Also, for ALTER .. RENAME, check permissions: the user must (still)
17882 * have CREATE rights on the containing namespace.
17883 */
17885 {
17892 }
17898 else
17899 {
17902 }
17904 /*
17905 * For compatibility with prior releases, we allow ALTER TABLE to be used
17906 * with most other types of relations (but not composite types). We allow
17907 * similar flexibility for ALTER INDEX in the case of RENAME, but not
17908 * otherwise. Otherwise, the user must select the correct form of the
17909 * command for the relation at issue.
17910 */
17937 relkind != RELKIND_PARTITIONED_INDEX
17943 /*
17944 * Don't allow ALTER TABLE on composite types. We want people to use ALTER
17945 * TYPE for that.
17946 */
17951 /* translator: %s is an SQL ALTER command */
17955 /*
17956 * Don't allow ALTER TABLE .. SET SCHEMA on relations that can't be moved
17957 * to a different schema, such as indexes and TOAST tables.
17958 */
17960 {
17972 /* translator: %s is an SQL ALTER command */
17981 }
17984 }
17986 /*
17987 * Transform any expressions present in the partition key
17988 *
17989 * Returns a transformed PartitionSpec.
17990 */
17993 {
18005 /* Check valid number of columns for strategy */
18012 /*
18013 * Create a dummy ParseState and insert the target relation as its sole
18014 * rangetable entry. We need a ParseState for transformExpr.
18015 */
18021 /* take care of any partition expressions */
18023 {
18027 {
18028 /* Copy, to avoid scribbling on the input */
18031 /* Now do parse transformation of the expression */
18033 EXPR_KIND_PARTITION_EXPRESSION);
18035 /* we have to fix its collations too */
18037 }
18040 }
18043 }
18045 /*
18046 * Compute per-partition-column information from a list of PartitionElems.
18047 * Expressions in the PartitionElems must be parse-analyzed already.
18048 */
18049 static void
18050 ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
18052 PartitionStrategy strategy)
18053 {
18056 Oid am_oid;
18060 {
18062 Oid atttype;
18063 Oid attcollation;
18066 {
18067 /* Simple attribute reference */
18068 HeapTuple atttuple;
18069 Form_pg_attribute attform;
18088 /*
18089 * Generated columns cannot work: They are computed after BEFORE
18090 * triggers, but partition routing is done before all triggers.
18091 */
18104 }
18105 else
18106 {
18107 /* Expression */
18115 /*
18116 * The expression must be of a storable type (e.g., not RECORD).
18117 * The test is the same as for whether a table column is of a safe
18118 * type (which is why we needn't check for the non-expression
18119 * case).
18120 */
18126 /*
18127 * Strip any top-level COLLATE clause. This ensures that we treat
18128 * "x COLLATE y" and "(x COLLATE y)" alike.
18129 */
18135 {
18136 /*
18137 * User wrote "(column)" or "(column COLLATE something)".
18138 * Treat it like simple attribute anyway.
18139 */
18141 }
18142 else
18143 {
18150 /*
18151 * Try to simplify the expression before checking for
18152 * mutability. The main practical value of doing it in this
18153 * order is that an inline-able SQL-language function will be
18154 * accepted if its expansion is immutable, whether or not the
18155 * function itself is marked immutable.
18156 *
18157 * Note that expression_planner does not change the passed in
18158 * expression destructively and we have already saved the
18159 * expression to be stored into the catalog above.
18160 */
18163 /*
18164 * Partition expression cannot contain mutable functions,
18165 * because a given row must always map to the same partition
18166 * as long as there is no change in the partition boundary
18167 * structure.
18168 */
18174 /*
18175 * transformPartitionSpec() should have already rejected
18176 * subqueries, aggregates, window functions, and SRFs, based
18177 * on the EXPR_KIND_ for partition expressions.
18178 */
18180 /*
18181 * Cannot allow system column references, since that would
18182 * make partition routing impossible: their values won't be
18183 * known yet when we need to do that.
18184 */
18187 {
18189 expr_attrs))
18193 }
18195 /*
18196 * Generated columns cannot work: They are computed after
18197 * BEFORE triggers, but partition routing is done before all
18198 * triggers.
18199 */
18202 {
18213 }
18215 /*
18216 * While it is not exactly *wrong* for a partition expression
18217 * to be a constant, it seems better to reject such keys.
18218 */
18223 }
18224 }
18226 /*
18227 * Apply collation override if any
18228 */
18232 /*
18233 * Check we have a collation iff it's a collatable type. The only
18234 * expected failures here are (1) COLLATE applied to a noncollatable
18235 * type, or (2) partition expression had an unresolved collation. But
18236 * we might as well code this to be a complete consistency check.
18237 */
18239 {
18245 }
18246 else
18247 {
18253 }
18257 /*
18258 * Identify the appropriate operator class. For list and range
18259 * partitioning, we use a btree operator class; hash partitioning uses
18260 * a hash operator class.
18261 */
18264 else
18268 {
18272 {
18278 errhint("You must specify a hash operator class or define a default hash operator class for the data type.")));
18279 else
18284 errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
18285 }
18286 }
18287 else
18289 atttype,
18291 am_oid);
18293 attn++;
18294 }
18295 }
18297 /*
18298 * PartConstraintImpliedByRelConstraint
18299 * Do scanrel's existing constraints imply the partition constraint?
18300 *
18301 * "Existing constraints" include its check constraints and column-level
18302 * not-null constraints. partConstraint describes the partition constraint,
18303 * in implicit-AND form.
18304 */
18305 bool
18308 {
18314 {
18318 {
18322 {
18326 i,
18333 /*
18334 * argisrow=false is correct even for a composite column,
18335 * because attnotnull does not represent a SQL-spec IS NOT
18336 * NULL test in such a case, just IS DISTINCT FROM NULL.
18337 */
18341 }
18342 }
18343 }
18346 }
18348 /*
18349 * ConstraintImpliedByRelConstraint
18350 * Do scanrel's existing constraints imply the given constraint?
18351 *
18352 * testConstraint is the constraint to validate. provenConstraint is a
18353 * caller-provided list of conditions which this function may assume
18354 * to be true. Both provenConstraint and testConstraint must be in
18355 * implicit-AND form, must only contain immutable clauses, and must
18356 * contain only Vars with varno = 1.
18357 */
18358 bool
18359 ConstraintImpliedByRelConstraint(Relation scanrel, List *testConstraint, List *provenConstraint)
18360 {
18364 i;
18368 {
18371 /*
18372 * If this constraint hasn't been fully validated yet, we must ignore
18373 * it here.
18374 */
18380 /*
18381 * Run each expression through const-simplification and
18382 * canonicalization. It is necessary, because we will be comparing it
18383 * to similarly-processed partition constraint expressions, and may
18384 * fail to detect valid matches without this.
18385 */
18391 }
18393 /*
18394 * Try to make the proof. Since we are comparing CHECK constraints, we
18395 * need to use weak implication, i.e., we assume existConstraint is
18396 * not-false and try to prove the same for testConstraint.
18397 *
18398 * Note that predicate_implied_by assumes its first argument is known
18399 * immutable. That should always be true for both NOT NULL and partition
18400 * constraints, so we don't test it here.
18401 */
18403 }
18405 /*
18406 * QueuePartitionConstraintValidation
18407 *
18408 * Add an entry to wqueue to have the given partition constraint validated by
18409 * Phase 3, for the given relation, and all its children.
18410 *
18411 * We first verify whether the given constraint is implied by pre-existing
18412 * relation constraints; if it is, there's no need to scan the table to
18413 * validate, so don't queue in that case.
18414 */
18415 static void
18419 {
18420 /*
18421 * Based on the table's existing constraints, determine whether or not we
18422 * may skip scanning the table.
18423 */
18425 {
18430 else
18432 (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
18435 }
18437 /*
18438 * Constraints proved insufficient. For plain relations, queue a
18439 * validation item now; for partitioned tables, recurse to process each
18440 * partition.
18441 */
18443 {
18446 /* Grab a work queue entry. */
18451 }
18453 {
18458 {
18459 Relation part_rel;
18462 /*
18463 * This is the minimum lock we need to prevent deadlocks.
18464 */
18467 /*
18468 * Adjust the constraint for scanrel so that it matches this
18469 * partition's attribute numbers.
18470 */
18471 thisPartConstraint =
18476 thisPartConstraint,
18477 validate_default);
18479 }
18480 }
18481 }
18483 /*
18484 * ALTER TABLE <name> ATTACH PARTITION <partition-name> FOR VALUES
18485 *
18486 * Return the address of the newly attached partition.
18487 */
18488 static ObjectAddress
18491 {
18492 Relation attachrel,
18493 catalog;
18496 SysScanDesc scan;
18497 ScanKeyData skey;
18498 AttrNumber attno;
18500 TupleDesc tupleDesc;
18501 ObjectAddress address;
18503 Oid defaultPartOid;
18509 /*
18510 * We must lock the default partition if one exists, because attaching a
18511 * new partition will change its partition constraint.
18512 */
18513 defaultPartOid =
18520 /*
18521 * XXX I think it'd be a good idea to grab locks on all tables referenced
18522 * by FKs at this point also.
18523 */
18525 /*
18526 * Must be owner of both parent and source table -- parent was checked by
18527 * ATSimplePermissions call in ATPrepCmd
18528 */
18531 /* A partition can only have one parent */
18543 /*
18544 * Table being attached should not already be part of inheritance; either
18545 * as a child table...
18546 */
18549 Anum_pg_inherits_inhrelid,
18560 /* ...or as a parent table (except the case when it is partitioned) */
18562 Anum_pg_inherits_inhparent,
18575 /*
18576 * Prevent circularity by seeing if rel is a partition of attachrel. (In
18577 * particular, this disallows making a rel a partition of itself.)
18578 *
18579 * We do that by checking if rel is a member of the list of attachrel's
18580 * partitions provided the latter is partitioned at all. We want to avoid
18581 * having to construct this list again, so we request the strongest lock
18582 * on all partitions. We need the strongest lock, because we may decide
18583 * to scan them if we find out that the table being attached (or its leaf
18584 * partitions) may contain rows that violate the partition constraint. If
18585 * the table has a constraint that would prevent such rows, which by
18586 * definition is present in all the partitions, we need not scan the
18587 * table, nor its partitions. But we cannot risk a deadlock by taking a
18588 * weaker lock now and the stronger one only when needed.
18589 */
18600 /* If the parent is permanent, so must be all of its partitions. */
18608 /* Temp parent cannot have a partition that is itself not a temp */
18616 /* If the parent is temp, it must belong to this session */
18623 /* Ditto for the partition */
18630 /* Check if there are any columns in attachrel that aren't in the parent */
18634 {
18638 /* Ignore dropped */
18642 /* Try to find the column in parent (matching on column name) */
18652 }
18654 /*
18655 * If child_rel has row-level triggers with transition tables, we
18656 * currently don't allow it to become a partition. See also prohibitions
18657 * in ATExecAddInherit() and CreateTrigger().
18658 */
18667 /*
18668 * Check that the new partition's bound is valid and does not overlap any
18669 * of existing partitions of the parent - note that it does not return on
18670 * error.
18671 */
18675 /* OK to create inheritance. Rest of the checks performed there */
18678 /* Update the pg_class entry. */
18681 /* Ensure there exists a correct set of indexes in the partition. */
18684 /* and triggers */
18687 /*
18688 * Clone foreign key constraints. Callee is responsible for setting up
18689 * for phase 3 constraint verification.
18690 */
18693 /*
18694 * Generate partition constraint from the partition bound specification.
18695 * If the parent itself is a partition, make sure to include its
18696 * constraint as well.
18697 */
18702 /* Skip validation if there are no constraints to validate. */
18704 {
18705 /*
18706 * Run the partition quals through const-simplification similar to
18707 * check constraints. We skip canonicalize_qual, though, because
18708 * partition quals should be in canonical form already.
18709 */
18710 partConstraint =
18714 /* XXX this sure looks wrong */
18717 /*
18718 * Adjust the generated constraint to match this partition's attribute
18719 * numbers.
18720 */
18722 rel);
18724 /* Validate partition constraints against the table being attached. */
18727 }
18729 /*
18730 * If we're attaching a partition other than the default partition and a
18731 * default one exists, then that partition's partition constraint changes,
18732 * so add an entry to the work queue to validate it, too. (We must not do
18733 * this when the partition being attached is the default one; we already
18734 * did it above!)
18735 */
18737 {
18738 Relation defaultrel;
18743 /* we already hold a lock on the default partition */
18745 defPartConstraint =
18748 /*
18749 * Map the Vars in the constraint expression from rel's attnos to
18750 * defaultrel's.
18751 */
18752 defPartConstraint =
18758 /* keep our lock until commit. */
18760 }
18764 /*
18765 * If the partition we just attached is partitioned itself, invalidate
18766 * relcache for all descendent partitions too to ensure that their
18767 * rd_partcheck expression trees are rebuilt; partitions already locked at
18768 * the beginning of this function.
18769 */
18771 {
18775 {
18777 }
18778 }
18780 /* keep our lock until commit */
18784 }
18786 /*
18787 * AttachPartitionEnsureIndexes
18788 * subroutine for ATExecAttachPartition to create/match indexes
18789 *
18790 * Enforce the indexing rule for partitioned tables during ALTER TABLE / ATTACH
18791 * PARTITION: every partition must have an index attached to each index on the
18792 * partitioned table.
18793 */
18794 static void
18796 {
18802 MemoryContext cxt;
18803 MemoryContext oldcxt;
18807 ALLOCSET_DEFAULT_SIZES);
18815 /* Build arrays of all existing indexes and their IndexInfos */
18817 {
18823 }
18825 /*
18826 * If we're attaching a foreign table, we must fail if any of the indexes
18827 * is a constraint index; otherwise, there's nothing to do here. Do this
18828 * before starting work, to avoid wasting the effort of building a few
18829 * non-unique indexes before coming across a unique one.
18830 */
18832 {
18834 {
18848 }
18851 }
18853 /*
18854 * For each index on the partitioned table, find a matching one in the
18855 * partition-to-be; if one is not found, create one.
18856 */
18858 {
18864 Oid constraintOid;
18866 /*
18867 * Ignore indexes in the partitioned table other than partitioned
18868 * indexes.
18869 */
18871 {
18874 }
18876 /* construct an indexinfo to compare existing indexes against */
18883 /*
18884 * Scan the list of existing indexes in the partition-to-be, and mark
18885 * the first matching, valid, unattached one we find, if any, as
18886 * partition of the parent index. If we find one, we're done.
18887 */
18889 {
18893 /* does this index have a parent? if so, can't use it */
18897 /* If this index is invalid, can't use it */
18906 attmap))
18907 {
18908 /*
18909 * If this index is being created in the parent because of a
18910 * constraint, then the child needs to have a constraint also,
18911 * so look for one. If there is no such constraint, this
18912 * index is no good, so keep looking.
18913 */
18915 {
18916 cldConstrOid =
18918 cldIdxId);
18919 /* no dice */
18922 }
18924 /* bingo. */
18933 }
18934 }
18936 /*
18937 * If no suitable index was found in the partition-to-be, create one
18938 * now.
18939 */
18941 {
18943 Oid conOid;
18949 /*
18950 * If the index is a primary key, mark all columns as NOT NULL if
18951 * they aren't already.
18952 */
18954 {
18957 {
18958 AttrNumber childattno;
18966 }
18968 }
18972 conOid,
18975 }
18978 }
18980 out:
18981 /* Clean up. */
18986 }
18988 /*
18989 * CloneRowTriggersToPartition
18990 * subroutine for ATExecAttachPartition/DefineRelation to create row
18991 * triggers on partitions
18992 */
18993 static void
18995 {
18996 Relation pg_trigger;
18997 ScanKeyData key;
18998 SysScanDesc scan;
18999 HeapTuple tuple;
19000 MemoryContext perTupCxt;
19012 {
19016 Datum value;
19020 MemoryContext oldcxt;
19022 /*
19023 * Ignore statement-level triggers; those are not cloned.
19024 */
19028 /*
19029 * Don't clone internal triggers, because the constraint cloning code
19030 * will.
19031 */
19035 /*
19036 * Complain if we find an unexpected trigger type.
19037 */
19043 /* Use short-lived context for CREATE TRIGGER */
19046 /*
19047 * If there is a WHEN clause, generate a 'cooked' version of it that's
19048 * appropriate for the partition.
19049 */
19053 {
19059 }
19061 /*
19062 * If there is a column list, transform it to a list of column names.
19063 * Note we don't need to map this list in any way ...
19064 */
19066 {
19070 {
19071 Form_pg_attribute col;
19077 }
19078 }
19080 /* Reconstruct trigger arguments list. */
19082 {
19094 {
19097 }
19098 }
19124 }
19130 }
19132 /*
19133 * ALTER TABLE DETACH PARTITION
19134 *
19135 * Return the address of the relation that is no longer a partition of rel.
19136 *
19137 * If concurrent mode is requested, we run in two transactions. A side-
19138 * effect is that this command cannot run in a multi-part ALTER TABLE.
19139 * Currently, that's enforced by the grammar.
19140 *
19141 * The strategy for concurrency is to first modify the partition's
19142 * pg_inherit catalog row to make it visible to everyone that the
19143 * partition is detached, lock the partition against writes, and commit
19144 * the transaction; anyone who requests the partition descriptor from
19145 * that point onwards has to ignore such a partition. In a second
19146 * transaction, we wait until all transactions that could have seen the
19147 * partition as attached are gone, then we remove the rest of partition
19148 * metadata (pg_inherits and pg_class.relpartbounds).
19149 */
19150 static ObjectAddress
19153 {
19154 Relation partRel;
19155 ObjectAddress address;
19156 Oid defaultPartOid;
19158 /*
19159 * We must lock the default partition, because detaching this partition
19160 * will change its partition constraint.
19161 */
19162 defaultPartOid =
19165 {
19166 /*
19167 * Concurrent detaching when a default partition exists is not
19168 * supported. The main problem is that the default partition
19169 * constraint would change. And there's a definitional problem: what
19170 * should happen to the tuples that are being inserted that belong to
19171 * the partition being detached? Putting them on the partition being
19172 * detached would be wrong, since they'd become "lost" after the
19173 * detaching completes but we cannot put them in the default partition
19174 * either until we alter its partition constraint.
19175 *
19176 * I think we could solve this problem if we effected the constraint
19177 * change before committing the first transaction. But the lock would
19178 * have to remain AEL and it would cause concurrent query planning to
19179 * be blocked, so changing it that way would be even worse.
19180 */
19186 }
19188 /*
19189 * In concurrent mode, the partition is locked with share-update-exclusive
19190 * in the first transaction. This allows concurrent transactions to be
19191 * doing DML to the partition.
19192 */
19194 AccessExclusiveLock);
19196 /*
19197 * Check inheritance conditions and either delete the pg_inherits row (in
19198 * non-concurrent mode) or just set the inhdetachpending flag.
19199 */
19202 else
19205 /*
19206 * Ensure that foreign keys still hold after this detach. This keeps
19207 * locks on the referencing tables, which prevents concurrent transactions
19208 * from adding rows that we wouldn't see. For this to work in concurrent
19209 * mode, it is critical that the partition appears as no longer attached
19210 * for the RI queries as soon as the first transaction commits.
19211 */
19214 /*
19215 * Concurrent mode has to work harder; first we add a new constraint to
19216 * the partition that matches the partition constraint. Then we close our
19217 * existing transaction, and in a new one wait for all processes to catch
19218 * up on the catalog updates we've done so far; at that point we can
19219 * complete the operation.
19220 */
19222 {
19223 Oid partrelid,
19224 parentrelid;
19225 LOCKTAG tag;
19229 /*
19230 * Add a new constraint to the partition being detached, which
19231 * supplants the partition constraint (unless there is one already).
19232 */
19235 /*
19236 * We're almost done now; the only traces that remain are the
19237 * pg_inherits tuple and the partition's relpartbounds. Before we can
19238 * remove those, we need to wait until all transactions that know that
19239 * this is a partition are gone.
19240 */
19242 /*
19243 * Remember relation OIDs to re-acquire them later; and relation names
19244 * too, for error messages if something is dropped in between.
19245 */
19253 /* Invalidate relcache entries for the parent -- must be before close */
19260 /* Make updated catalog entry visible */
19266 /*
19267 * Now wait. This ensures that all queries that were planned
19268 * including the partition are finished before we remove the rest of
19269 * catalog entries. We don't need or indeed want to acquire this
19270 * lock, though -- that would block later queries.
19271 *
19272 * We don't need to concern ourselves with waiting for a lock on the
19273 * partition itself, since we will acquire AccessExclusiveLock below.
19274 */
19278 /*
19279 * Now acquire locks in both relations again. Note they may have been
19280 * removed in the meantime, so care is required.
19281 */
19285 /* If the relations aren't there, something bad happened; bail out */
19287 {
19290 partrelname);
19294 parentrelname)));
19295 }
19302 }
19304 /* Do the final part of detaching */
19309 /* keep our lock until commit */
19313 }
19315 /*
19316 * Second part of ALTER TABLE .. DETACH.
19317 *
19318 * This is separate so that it can be run independently when the second
19319 * transaction of the concurrent algorithm fails (crash or abort).
19320 */
19321 static void
19323 Oid defaultPartOid)
19324 {
19325 Relation classRel;
19332 HeapTuple tuple,
19333 newtuple;
19337 {
19338 /*
19339 * We can remove the pg_inherits row now. (In the non-concurrent case,
19340 * this was already done).
19341 */
19343 }
19345 /* Drop any triggers that were cloned on creation/attach. */
19348 /*
19349 * Detach any foreign keys that are inherited. This includes creating
19350 * additional action triggers.
19351 */
19356 {
19358 HeapTuple contup;
19359 Form_pg_constraint conform;
19361 Oid insertTriggerOid,
19362 updateTriggerOid;
19369 /* consider only the inherited foreign keys */
19372 {
19375 }
19377 /* unset conparentid and adjust conislocal, coninhcount, etc. */
19380 /*
19381 * Also, look up the partition's "check" triggers corresponding to the
19382 * constraint being detached and detach them from the parent triggers.
19383 */
19394 /*
19395 * Make the action triggers on the referenced relation. When this was
19396 * a partition the action triggers pointed to the parent rel (they
19397 * still do), but now we need separate ones of our own.
19398 */
19424 }
19429 /*
19430 * Any sub-constraints that are in the referenced-side of a larger
19431 * constraint have to be removed. This partition is no longer part of the
19432 * key space of the constraint.
19433 */
19435 {
19437 ObjectAddress constraint;
19441 constrOid,
19442 ConstraintRelationId,
19443 DEPENDENCY_INTERNAL);
19448 }
19450 /* Now we can detach indexes */
19453 {
19455 Relation idx;
19456 Oid constrOid;
19467 /* If there's a constraint associated with the index, detach it too */
19469 idxid);
19474 }
19476 /* Update pg_class tuple */
19485 /* Clear relpartbound and reset relispartition */
19501 {
19502 /*
19503 * If the relation being detached is the default partition itself,
19504 * remove it from the parent's pg_partitioned_table entry.
19505 *
19506 * If not, we must invalidate default partition's relcache entry, as
19507 * in StorePartitionBound: its partition constraint depends on every
19508 * other partition's partition constraint.
19509 */
19512 else
19514 }
19516 /*
19517 * Invalidate the parent's relcache so that the partition is no longer
19518 * included in its partition descriptor.
19519 */
19522 /*
19523 * If the partition we just detached is partitioned itself, invalidate
19524 * relcache for all descendent partitions too to ensure that their
19525 * rd_partcheck expression trees are rebuilt; must lock partitions before
19526 * doing so, using the same lockmode as what partRel has been locked with
19527 * by the caller.
19528 */
19530 {
19536 {
19538 }
19539 }
19540 }
19542 /*
19543 * ALTER TABLE ... DETACH PARTITION ... FINALIZE
19544 *
19545 * To use when a DETACH PARTITION command previously did not run to
19546 * completion; this completes the detaching process.
19547 */
19548 static ObjectAddress
19550 {
19551 Relation partRel;
19552 ObjectAddress address;
19557 /*
19558 * Wait until existing snapshots are gone. This is important if the
19559 * second transaction of DETACH PARTITION CONCURRENTLY is canceled: the
19560 * user could immediately run DETACH FINALIZE without actually waiting for
19561 * existing transactions. We must not complete the detach action until
19562 * all such queries are complete (otherwise we would present them with an
19563 * inconsistent view of catalogs).
19564 */
19574 }
19576 /*
19577 * DetachAddConstraintIfNeeded
19578 * Subroutine for ATExecDetachPartition. Create a constraint that
19579 * takes the place of the partition constraint, but avoid creating
19580 * a dupe if an constraint already exists which implies the needed
19581 * constraint.
19582 */
19583 static void
19585 {
19591 /*
19592 * Avoid adding a new constraint if the needed constraint is implied by an
19593 * existing constraint
19594 */
19596 {
19602 /* Add constraint on partition, equivalent to the partition constraint */
19612 /* It's a re-add, since it nominally already exists */
19615 }
19616 }
19618 /*
19619 * DropClonedTriggersFromPartition
19620 * subroutine for ATExecDetachPartition to remove any triggers that were
19621 * cloned to the partition when it was created-as-partition or attached.
19622 * This undoes what CloneRowTriggersToPartition did.
19623 */
19624 static void
19626 {
19627 ScanKeyData skey;
19628 SysScanDesc scan;
19629 HeapTuple trigtup;
19630 Relation tgrel;
19635 /*
19636 * Scan pg_trigger to search for all triggers on this rel.
19637 */
19644 {
19646 ObjectAddress trig;
19648 /* Ignore triggers that weren't cloned */
19652 /*
19653 * Ignore internal triggers that are implementation objects of foreign
19654 * keys, because these will be detached when the foreign keys
19655 * themselves are.
19656 */
19660 /*
19661 * This is ugly, but necessary: remove the dependency markings on the
19662 * trigger so that it can be removed.
19663 */
19665 TriggerRelationId,
19666 DEPENDENCY_PARTITION_PRI);
19668 RelationRelationId,
19669 DEPENDENCY_PARTITION_SEC);
19671 /* remember this trigger to remove it below */
19674 }
19676 /* make the dependency removal visible to the deletion below */
19680 /* done */
19684 }
19686 /*
19687 * Before acquiring lock on an index, acquire the same lock on the owning
19688 * table.
19689 */
19690 struct AttachIndexCallbackState
19691 {
19692 Oid partitionOid;
19693 Oid parentTblOid;
19695 };
19697 static void
19700 {
19702 Form_pg_class classform;
19703 HeapTuple tuple;
19708 {
19711 }
19713 /*
19714 * If we previously locked some other heap, and the name we're looking up
19715 * no longer refers to an index on that relation, release the now-useless
19716 * lock. XXX maybe we should do *after* we verify whether the index does
19717 * not actually belong to the same relation ...
19718 */
19720 {
19723 }
19725 /* Didn't find a relation, so no need for locking or permission checks. */
19740 /*
19741 * Since we need only examine the heap's tupledesc, an access share lock
19742 * on it (preventing any DDL) is sufficient.
19743 */
19746 }
19748 /*
19749 * ALTER INDEX i1 ATTACH PARTITION i2
19750 */
19751 static ObjectAddress
19753 {
19754 Relation partIdx;
19755 Relation partTbl;
19756 Relation parentTbl;
19757 ObjectAddress address;
19758 Oid partIdxId;
19759 Oid currParent;
19762 /*
19763 * We need to obtain lock on the index 'name' to modify it, but we also
19764 * need to read its owning table's tuple descriptor -- so we need to lock
19765 * both. To avoid deadlocks, obtain lock on the table before doing so on
19766 * the index. Furthermore, we need to examine the parent table of the
19767 * partition, so lock that one too.
19768 */
19772 partIdxId =
19774 RangeVarCallbackForAttachIndex,
19776 /* Not there? */
19782 /* no deadlock risk: RangeVarGetRelidExtended already acquired the lock */
19785 /* we already hold locks on both tables, so this is safe: */
19791 /* Silently do nothing if already in the right state */
19795 {
19801 PartitionDesc partDesc;
19802 Oid constraintOid,
19805 /*
19806 * If this partition already has an index attached, refuse the
19807 * operation.
19808 */
19820 /* Make sure it indexes a partition of the other index's table */
19824 {
19826 {
19829 }
19830 }
19841 /* Ensure the indexes are compatible */
19852 attmap))
19860 /*
19861 * If there is a constraint in the parent, make sure there is one in
19862 * the child too.
19863 */
19868 {
19870 partIdxId);
19877 errdetail("The index \"%s\" belongs to a constraint in table \"%s\" but no constraint exists for index \"%s\".",
19881 }
19883 /*
19884 * If it's a primary key, make sure the columns in the partition are
19885 * NOT NULL.
19886 */
19890 /* All good -- do it */
19899 }
19902 /* keep these locks till commit */
19907 }
19909 /*
19910 * Verify whether the given partition already contains an index attached
19911 * to the given partitioned index. If so, raise an error.
19912 */
19913 static void
19915 {
19916 Oid existingIdx;
19928 }
19930 /*
19931 * Verify whether the set of attached partition indexes to a parent index on
19932 * a partitioned table is complete. If it is, mark the parent index valid.
19933 *
19934 * This should be called each time a partition index is attached.
19935 */
19936 static void
19938 {
19939 Relation inheritsRel;
19940 SysScanDesc scan;
19941 ScanKeyData key;
19943 HeapTuple inhTup;
19948 /*
19949 * Scan pg_inherits for this parent index. Count each valid index we find
19950 * (verifying the pg_index entry for each), and if we reach the total
19951 * amount we expect, we can mark this parent index as valid.
19952 */
19960 {
19962 HeapTuple indTup;
19963 Form_pg_index indexForm;
19973 }
19975 /* Done with pg_inherits */
19979 /*
19980 * If we found as many inherited indexes as the partitioned table has
19981 * partitions, we're good; update pg_index to set indisvalid.
19982 */
19984 {
19985 Relation idxRel;
19986 HeapTuple indTup;
19987 Form_pg_index indexForm;
20004 }
20006 /*
20007 * If this index is in turn a partition of a larger index, validating it
20008 * might cause the parent to become valid also. Try that.
20009 */
20011 {
20012 Oid parentIdxId,
20013 parentTblId;
20014 Relation parentIdx,
20015 parentTbl;
20017 /* make sure we see the validation we just did */
20030 }
20031 }
20033 /*
20034 * When attaching an index as a partition of a partitioned index which is a
20035 * primary key, verify that all the columns in the partition are marked NOT
20036 * NULL.
20037 */
20038 static void
20040 {
20042 {
20053 }
20054 }
20056 /*
20057 * Return an OID list of constraints that reference the given relation
20058 * that are marked as having a parent constraints.
20059 */
20062 {
20063 Relation pg_constraint;
20064 HeapTuple tuple;
20065 SysScanDesc scan;
20069 /*
20070 * If no indexes, or no columns are referenceable by FKs, we can avoid the
20071 * scan.
20072 */
20075 INDEX_ATTR_BITMAP_KEY)))
20078 /* Search for constraints referencing this table */
20087 /* XXX This is a seqscan, as we don't have a usable index */
20090 {
20093 /*
20094 * We only need to process constraints that are part of larger ones.
20095 */
20100 }
20106 }
20108 /*
20109 * During DETACH PARTITION, verify that any foreign keys pointing to the
20110 * partitioned table would not become invalid. An error is raised if any
20111 * referenced values exist.
20112 */
20113 static void
20115 {
20122 {
20124 HeapTuple tuple;
20125 Form_pg_constraint constrForm;
20126 Relation rel;
20137 /* prevent data changes into the referencing table until commit */
20149 /* we needn't fill in remaining fields */
20156 }
20157 }
20159 /*
20160 * resolve column compression specification to compression method.
20161 */
20162 static char
20164 {
20170 /*
20171 * To specify a nondefault method, the column data type must be toastable.
20172 * Note this says nothing about whether the column's attstorage setting
20173 * permits compression; we intentionally allow attstorage and
20174 * attcompression to be independent. But with a non-toastable type,
20175 * attstorage could not be set to a value that would permit compression.
20176 *
20177 * We don't actually need to enforce this, since nothing bad would happen
20178 * if attcompression were non-default; it would never be consulted. But
20179 * it seems more user-friendly to complain about a certainly-useless
20180 * attempt to set the property.
20181 */
20195 }
20197 /*
20198 * resolve column storage specification
20199 */
20200 static char
20202 {
20215 else
20219 storagemode)));
20221 /*
20222 * safety check: do not allow toasted storage modes unless column datatype
20223 * is TOAST-aware.
20224 */
20232 }