| blob | f2ca686397ebd04f93b542a535900b02a4c4b3b4 |
1 /*-------------------------------------------------------------------------
2 *
3 * heap.c
4 * code to create and destroy POSTGRES heap relations
5 *
6 * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/catalog/heap.c
12 *
13 *
14 * INTERFACE ROUTINES
15 * heap_create() - Create an uncataloged heap relation
16 * heap_create_with_catalog() - Create a cataloged relation
17 * heap_drop_with_catalog() - Removes named relation from catalogs
18 *
19 * NOTES
20 * this code taken from access/heap/create.c, which contains
21 * the old heap_create_with_catalog, amcreate, and amdestroy.
22 * those routines will soon call these routines using the function
23 * manager,
24 * just like the poorly named "NewXXX" routines do. The
25 * "New" routines are all going to die soon, once and for all!
26 * -cim 1/13/91
27 *
28 *-------------------------------------------------------------------------
29 */
91 /* Potentially set by pg_upgrade_support functions */
96 Relation new_rel_desc,
97 Oid new_rel_oid,
98 Oid new_type_oid,
99 Oid reloftype,
100 Oid relowner,
102 TransactionId relfrozenxid,
103 TransactionId relminmxid,
104 Datum relacl,
105 Datum reloptions);
107 Oid typeNamespace,
108 Oid new_rel_oid,
110 Oid ownerid,
111 Oid new_row_type,
112 Oid new_array_type);
129 /* ----------------------------------------------------------------
130 * XXX UGLY HARD CODED BADNESS FOLLOWS XXX
131 *
132 * these should all be moved to someplace in the lib/catalog
133 * module, if not obliterated first.
134 * ----------------------------------------------------------------
135 */
138 /*
139 * Note:
140 * Should the system special case these attributes in the future?
141 * Advantage: consume much less space in the ATTRIBUTE relation.
142 * Disadvantage: special cases will be all over the place.
143 */
145 /*
146 * The initializers below do not include trailing variable length fields,
147 * but that's OK - we're never going to reference anything beyond the
148 * fixed-size portion of the structure anyway.
149 */
163 };
177 };
191 };
205 };
219 };
221 /*
222 * We decided to call this attribute "tableoid" rather than say
223 * "classoid" on the basis that in the future there may be more than one
224 * table of a particular class/type. In any case table is still the word
225 * used in SQL.
226 */
239 };
243 /*
244 * This function returns a Form_pg_attribute pointer for a system attribute.
245 * Note that we elog if the presented attno is invalid, which would only
246 * happen if there's a problem upstream.
247 */
250 {
254 }
256 /*
257 * If the given name is a system attribute name, return a Form_pg_attribute
258 * pointer for a prototype definition. If not, return NULL.
259 */
262 {
266 {
271 }
274 }
277 /* ----------------------------------------------------------------
278 * XXX END OF UGLY HARD CODED BADNESS XXX
279 * ---------------------------------------------------------------- */
282 /* ----------------------------------------------------------------
283 * heap_create - Create an uncataloged heap relation
284 *
285 * Note API change: the caller must now always provide the OID
286 * to use for the relation. The relfilenode may (and, normally,
287 * should) be left unspecified.
288 *
289 * rel->rd_rel is initialized by RelationBuildLocalRelation,
290 * and is mostly zeroes at return.
291 * ----------------------------------------------------------------
292 */
293 Relation
295 Oid relnamespace,
296 Oid reltablespace,
297 Oid relid,
298 Oid relfilenode,
299 Oid accessmtd,
300 TupleDesc tupDesc,
308 {
310 Relation rel;
312 /* The caller must have provided an OID for the relation. */
315 /*
316 * Don't allow creating relations in pg_catalog directly, even though it
317 * is allowed to move user defined relations there. Semantics with search
318 * paths including pg_catalog are too confusing for now.
319 *
320 * But allow creating indexes on relations in pg_catalog even if
321 * allow_system_table_mods = off, upper layers already guarantee it's on a
322 * user defined relation, not a system one.
323 */
337 /* Handle reltablespace for specific relkinds. */
339 {
344 /*
345 * Force reltablespace to zero if the relation has no physical
346 * storage. This is mainly just for cleanliness' sake.
347 *
348 * Partitioned tables and indexes don't have physical storage
349 * either, but we want to keep their tablespace settings so that
350 * their children can inherit it.
351 */
357 /*
358 * Force reltablespace to zero for sequences, since we don't
359 * support moving them around into different tablespaces.
360 */
365 }
367 /*
368 * Decide whether to create storage. If caller passed a valid relfilenode,
369 * storage is already created, so don't do it here. Also don't create it
370 * for relkinds without physical storage.
371 */
374 else
375 {
378 }
380 /*
381 * Never allow a pg_class entry to explicitly specify the database's
382 * default tablespace in reltablespace; force it to zero instead. This
383 * ensures that if the database is cloned with a different default
384 * tablespace, the pg_class entry will still match where CREATE DATABASE
385 * will put the physically copied relation.
386 *
387 * Yes, this is a bit of a hack.
388 */
392 /*
393 * build the relcache entry.
394 */
396 relnamespace,
397 tupDesc,
398 relid,
399 accessmtd,
400 relfilenode,
401 reltablespace,
402 shared_relation,
403 mapped_relation,
404 relpersistence,
405 relkind);
407 /*
408 * Have the storage manager create the relation's disk file, if needed.
409 *
410 * For relations the callback creates both the main and the init fork, for
411 * indexes only the main fork is created. The other forks will be created
412 * on demand.
413 */
415 {
419 {
437 relpersistence,
440 }
441 }
444 }
446 /* ----------------------------------------------------------------
447 * heap_create_with_catalog - Create a cataloged relation
448 *
449 * this is done in multiple steps:
450 *
451 * 1) CheckAttributeNamesTypes() is used to make certain the tuple
452 * descriptor contains a valid set of attribute names and types
453 *
454 * 2) pg_class is opened and get_relname_relid()
455 * performs a scan to ensure that no relation with the
456 * same name already exists.
457 *
458 * 3) heap_create() is called to create the new relation on disk.
459 *
460 * 4) TypeCreate() is called to define a new type corresponding
461 * to the new relation.
462 *
463 * 5) AddNewRelationTuple() is called to register the
464 * relation in pg_class.
465 *
466 * 6) AddNewAttributeTuples() is called to register the
467 * new relation's schema in pg_attribute.
468 *
469 * 7) StoreConstraints is called () - vadim 08/22/97
470 *
471 * 8) the relations are closed and the new relation's oid
472 * is returned.
473 *
474 * ----------------------------------------------------------------
475 */
477 /* --------------------------------
478 * CheckAttributeNamesTypes
479 *
480 * this is used to make certain the tuple descriptor contains a
481 * valid set of attribute names and datatypes. a problem simply
482 * generates ereport(ERROR) which aborts the current transaction.
483 *
484 * relkind is the relkind of the relation to be created.
485 * flags controls which datatypes are allowed, cf CheckAttributeType.
486 * --------------------------------
487 */
488 void
491 {
496 /* Sanity check on column count */
501 MaxHeapAttributeNumber)));
503 /*
504 * first check for collision with system attribute names
505 *
506 * Skip this for a view or type relation, since those don't have system
507 * attributes.
508 */
510 {
512 {
520 }
521 }
523 /*
524 * next check for repeated attribute names
525 */
527 {
529 {
536 }
537 }
539 /*
540 * next check the attribute types
541 */
543 {
548 flags);
549 }
550 }
552 /* --------------------------------
553 * CheckAttributeType
554 *
555 * Verify that the proposed datatype of an attribute is legal.
556 * This is needed mainly because there are types (and pseudo-types)
557 * in the catalogs that we do not support as elements of real tuples.
558 * We also check some other properties required of a table column.
559 *
560 * If the attribute is being proposed for addition to an existing table or
561 * composite type, pass a one-element list of the rowtype OID as
562 * containing_rowtypes. When checking a to-be-created rowtype, it's
563 * sufficient to pass NIL, because there could not be any recursive reference
564 * to a not-yet-existing rowtype.
565 *
566 * flags is a bitmask controlling which datatypes we allow. For the most
567 * part, pseudo-types are disallowed as attribute types, but there are some
568 * exceptions: ANYARRAYOID, RECORDOID, and RECORDARRAYOID can be allowed
569 * in some cases. (This works because values of those type classes are
570 * self-identifying to some extent. However, RECORDOID and RECORDARRAYOID
571 * are reliably identifiable only within a session, since the identity info
572 * may use a typmod that is only locally assigned. The caller is expected
573 * to know whether these cases are safe.)
574 *
575 * flags can also control the phrasing of the error messages. If
576 * CHKATYPE_IS_PARTKEY is specified, "attname" should be a partition key
577 * column number as text, not a real column name.
578 * --------------------------------
579 */
580 void
585 {
587 Oid att_typelem;
590 {
591 /*
592 * We disallow pseudo-type columns, with the exception of ANYARRAY,
593 * RECORD, and RECORD[] when the caller says that those are OK.
594 *
595 * We don't need to worry about recursive containment for RECORD and
596 * RECORD[] because (a) no named composite type should be allowed to
597 * contain those, and (b) two "anonymous" record types couldn't be
598 * considered to be the same type, so infinite recursion isn't
599 * possible.
600 */
604 {
608 /* translator: first %s is an integer not a name */
611 else
616 }
617 }
619 {
620 /*
621 * If it's a domain, recurse to check its base type.
622 */
624 containing_rowtypes,
625 flags);
626 }
628 {
629 /*
630 * For a composite type, recurse into its attributes.
631 */
632 Relation relation;
633 TupleDesc tupdesc;
636 /*
637 * Check for self-containment. Eventually we might be able to allow
638 * this (just return without complaint, if so) but it's not clear how
639 * many other places would require anti-recursion defenses before it
640 * would be safe to allow tables to contain their own rowtype.
641 */
655 {
662 containing_rowtypes,
664 }
669 }
671 {
672 /*
673 * If it's a range, recurse to check its subtype.
674 */
677 containing_rowtypes,
678 flags);
679 }
681 {
682 /*
683 * Must recurse into array types, too, in case they are composite.
684 */
686 containing_rowtypes,
687 flags);
688 }
690 /*
691 * This might not be strictly invalid per SQL standard, but it is pretty
692 * useless, and it cannot be dumped, so we must disallow it.
693 */
695 {
699 /* translator: first %s is an integer not a name */
703 else
709 }
710 }
712 /*
713 * Cap the maximum amount of bytes allocated for InsertPgAttributeTuples()
714 * slots.
715 */
716 #define MAX_PGATTRIBUTE_INSERT_BYTES 65535
718 /*
719 * InsertPgAttributeTuples
720 * Construct and insert a set of tuples in pg_attribute.
721 *
722 * Caller has already opened and locked pg_attribute. tupdesc contains the
723 * attributes to insert. attcacheoff is always initialized to -1, attacl,
724 * attfdwoptions and attmissingval are always initialized to NULL. attoptions
725 * must contain the same number of elements as tupdesc, or be NULL.
726 *
727 * indstate is the index state for CatalogTupleInsertWithInfo. It can be
728 * passed as NULL, in which case we'll fetch the necessary info. (Don't do
729 * this when inserting multiple attributes, because it's a tad more
730 * expensive.)
731 *
732 * new_rel_oid is the relation OID assigned to the attributes inserted.
733 * If set to InvalidOid, the relation OID from tupdesc is used instead.
734 */
735 void
737 TupleDesc tupdesc,
738 Oid new_rel_oid,
740 CatalogIndexState indstate)
741 {
743 TupleDesc td;
751 /* Initialize the number of slots to use */
759 {
766 else
767 slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(attrs->attrelid);
770 slot[slotCount]->tts_values[Anum_pg_attribute_atttypid - 1] = ObjectIdGetDatum(attrs->atttypid);
771 slot[slotCount]->tts_values[Anum_pg_attribute_attstattarget - 1] = Int32GetDatum(attrs->attstattarget);
778 slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);
780 slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);
782 slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);
783 slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);
784 slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);
785 slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);
786 slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);
787 slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int32GetDatum(attrs->attinhcount);
788 slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);
791 else
794 /* start out with empty permissions and empty options */
800 slotCount++;
802 /*
803 * If slots are full or the end of processing has been reached, insert
804 * a batch of tuples.
805 */
807 {
808 /* fetch index info only when we know we need it */
810 {
813 }
815 /* insert the new tuples and update the indexes */
817 indstate);
819 }
821 natts++;
822 }
829 }
831 /* --------------------------------
832 * AddNewAttributeTuples
833 *
834 * this registers the new relation's schema by adding
835 * tuples to pg_attribute.
836 * --------------------------------
837 */
838 static void
840 TupleDesc tupdesc,
842 {
843 Relation rel;
844 CatalogIndexState indstate;
846 ObjectAddress myself,
847 referenced;
849 /*
850 * open pg_attribute and its indexes.
851 */
856 /* set stats detail level to a sane default */
861 /* add dependencies on their datatypes and collations */
863 {
864 /* Add dependency info */
870 /* The default collation is pinned, so don't bother recording it */
873 {
877 }
878 }
880 /*
881 * Next we add the system attributes. Skip OID if rel has no OIDs. Skip
882 * all for a view or type relation. We don't bother with making datatype
883 * dependencies here, since presumably all these types are pinned.
884 */
886 {
887 TupleDesc td;
893 }
895 /*
896 * clean up
897 */
901 }
903 /* --------------------------------
904 * InsertPgClassTuple
905 *
906 * Construct and insert a new tuple in pg_class.
907 *
908 * Caller has already opened and locked pg_class.
909 * Tuple data is taken from new_rel_desc->rd_rel, except for the
910 * variable-width fields which are not present in a cached reldesc.
911 * relacl and reloptions are passed in Datum form (to avoid having
912 * to reference the data types in heap.h). Pass (Datum) 0 to set them
913 * to NULL.
914 * --------------------------------
915 */
916 void
918 Relation new_rel_desc,
919 Oid new_rel_oid,
920 Datum relacl,
921 Datum reloptions)
922 {
926 HeapTuple tup;
928 /* This is a tad tedious, but way cleaner than what we used to do... */
964 else
968 else
971 /* relpartbound is set by updating this tuple, if necessary */
976 /* finally insert the new tuple, update the indexes, and clean up */
980 }
982 /* --------------------------------
983 * AddNewRelationTuple
984 *
985 * this registers the new relation in the catalogs by
986 * adding a tuple to pg_class.
987 * --------------------------------
988 */
989 static void
991 Relation new_rel_desc,
992 Oid new_rel_oid,
993 Oid new_type_oid,
994 Oid reloftype,
995 Oid relowner,
997 TransactionId relfrozenxid,
998 TransactionId relminmxid,
999 Datum relacl,
1000 Datum reloptions)
1001 {
1002 Form_pg_class new_rel_reltup;
1004 /*
1005 * first we update some of the information in our uncataloged relation's
1006 * relation descriptor.
1007 */
1011 {
1016 /* The relation is real, but as yet empty */
1022 /* Sequences always have a known size */
1028 /* Views, etc, have no disk storage */
1033 }
1041 /* relispartition is always set by updating this tuple later */
1044 /* fill rd_att's type ID with something sane even if reltype is zero */
1048 /* Now build and insert the tuple */
1051 }
1054 /* --------------------------------
1055 * AddNewRelationType -
1056 *
1057 * define a composite type corresponding to the new relation
1058 * --------------------------------
1059 */
1060 static ObjectAddress
1062 Oid typeNamespace,
1063 Oid new_rel_oid,
1065 Oid ownerid,
1066 Oid new_row_type,
1067 Oid new_array_type)
1068 {
1069 return
1101 }
1103 /* --------------------------------
1104 * heap_create_with_catalog
1105 *
1106 * creates a new cataloged relation. see comments above.
1107 *
1108 * Arguments:
1109 * relname: name to give to new rel
1110 * relnamespace: OID of namespace it goes in
1111 * reltablespace: OID of tablespace it goes in
1112 * relid: OID to assign to new rel, or InvalidOid to select a new OID
1113 * reltypeid: OID to assign to rel's rowtype, or InvalidOid to select one
1114 * reloftypeid: if a typed table, OID of underlying type; else InvalidOid
1115 * ownerid: OID of new rel's owner
1116 * tupdesc: tuple descriptor (source of column definitions)
1117 * cooked_constraints: list of precooked check constraints and defaults
1118 * relkind: relkind for new rel
1119 * relpersistence: rel's persistence status (permanent, temp, or unlogged)
1120 * shared_relation: true if it's to be a shared relation
1121 * mapped_relation: true if the relation will use the relfilenode map
1122 * oncommit: ON COMMIT marking (only relevant if it's a temp table)
1123 * reloptions: reloptions in Datum form, or (Datum) 0 if none
1124 * use_user_acl: true if should look for user-defined default permissions;
1125 * if false, relacl is always set NULL
1126 * allow_system_table_mods: true to allow creation in system namespaces
1127 * is_internal: is this a system-generated catalog?
1128 *
1129 * Output parameters:
1130 * typaddress: if not null, gets the object address of the new pg_type entry
1131 * (this must be null if the relkind is one that doesn't get a pg_type entry)
1132 *
1133 * Returns the OID of the new relation
1134 * --------------------------------
1135 */
1136 Oid
1138 Oid relnamespace,
1139 Oid reltablespace,
1140 Oid relid,
1141 Oid reltypeid,
1142 Oid reloftypeid,
1143 Oid ownerid,
1144 Oid accessmtd,
1145 TupleDesc tupdesc,
1151 OnCommitAction oncommit,
1152 Datum reloptions,
1156 Oid relrewrite,
1158 {
1159 Relation pg_class_desc;
1160 Relation new_rel_desc;
1162 Oid existing_relid;
1163 Oid old_type_oid;
1164 Oid new_type_oid;
1165 TransactionId relfrozenxid;
1166 MultiXactId relminmxid;
1170 /*
1171 * sanity checks
1172 */
1175 /*
1176 * Validate proposed tupdesc for the desired relkind. If
1177 * allow_system_table_mods is on, allow ANYARRAY to be used; this is a
1178 * hack to allow creating pg_statistic and cloning it during VACUUM FULL.
1179 */
1183 /*
1184 * This would fail later on anyway, if the relation already exists. But
1185 * by catching it here we can emit a nicer error message.
1186 */
1193 /*
1194 * Since we are going to create a rowtype as well, also check for
1195 * collision with an existing type name. If there is one and it's an
1196 * autogenerated array, we can rename it out of the way; otherwise we can
1197 * at least give a good error message.
1198 */
1203 {
1209 "so you must use a name that doesn't conflict "
1211 }
1213 /*
1214 * Shared relations must be in pg_global (last-ditch check)
1215 */
1219 /*
1220 * Allocate an OID for the relation, unless we were told what to use.
1221 *
1222 * The OID will be the relfilenode as well, so make sure it doesn't
1223 * collide with either pg_class OIDs or existing physical files.
1224 */
1226 {
1227 /* Use binary-upgrade override for pg_class.oid/relfilenode? */
1233 {
1241 }
1242 /* There might be no TOAST table, so we have to test for it. */
1246 {
1249 }
1250 else
1252 relpersistence);
1253 }
1255 /*
1256 * Determine the relation's initial permissions.
1257 */
1259 {
1261 {
1268 relnamespace);
1272 relnamespace);
1277 }
1278 }
1279 else
1282 /*
1283 * Create the relcache entry (mostly dummy at this point) and the physical
1284 * disk file. (If we fail further down, it's the smgr's responsibility to
1285 * remove the disk file again.)
1286 */
1288 relnamespace,
1289 reltablespace,
1290 relid,
1291 InvalidOid,
1292 accessmtd,
1293 tupdesc,
1294 relkind,
1295 relpersistence,
1296 shared_relation,
1297 mapped_relation,
1298 allow_system_table_mods,
1306 /*
1307 * Decide whether to create a pg_type entry for the relation's rowtype.
1308 * These types are made except where the use of a relation as such is an
1309 * implementation detail: toast tables, sequences and indexes.
1310 */
1315 {
1316 Oid new_array_oid;
1317 ObjectAddress new_type_addr;
1320 /*
1321 * We'll make an array over the composite type, too. For largely
1322 * historical reasons, the array type's OID is assigned first.
1323 */
1326 /*
1327 * Make the pg_type entry for the composite type. The OID of the
1328 * composite type can be preselected by the caller, but if reltypeid
1329 * is InvalidOid, we'll generate a new OID for it.
1330 *
1331 * NOTE: we could get a unique-index failure here, in case someone
1332 * else is creating the same type name in parallel but hadn't
1333 * committed yet when we checked for a duplicate name above.
1334 */
1336 relnamespace,
1337 relid,
1338 relkind,
1339 ownerid,
1340 reltypeid,
1341 new_array_oid);
1346 /* Now create the array type. */
1382 }
1383 else
1384 {
1385 /* Caller should not be expecting a type to be created. */
1390 }
1392 /*
1393 * now create an entry in pg_class for the relation.
1394 *
1395 * NOTE: we could get a unique-index failure here, in case someone else is
1396 * creating the same relation name in parallel but hadn't committed yet
1397 * when we checked for a duplicate name above.
1398 */
1400 new_rel_desc,
1401 relid,
1402 new_type_oid,
1403 reloftypeid,
1404 ownerid,
1405 relkind,
1406 relfrozenxid,
1407 relminmxid,
1409 reloptions);
1411 /*
1412 * now add tuples to pg_attribute for the attributes in our new relation.
1413 */
1416 /*
1417 * Make a dependency link to force the relation to be deleted if its
1418 * namespace is. Also make a dependency link to its owner, as well as
1419 * dependencies for any roles mentioned in the default ACL.
1420 *
1421 * For composite types, these dependencies are tracked for the pg_type
1422 * entry, so we needn't record them here. Likewise, TOAST tables don't
1423 * need a namespace dependency (they live in a pinned namespace) nor an
1424 * owner dependency (they depend indirectly through the parent table), nor
1425 * should they have any ACL entries. The same applies for extension
1426 * dependencies.
1427 *
1428 * Also, skip this in bootstrap mode, since we don't make dependencies
1429 * while bootstrapping.
1430 */
1434 {
1435 ObjectAddress myself,
1436 referenced;
1454 {
1459 }
1461 /*
1462 * Make a dependency link to force the relation to be deleted if its
1463 * access method is. Do this only for relation and materialized views.
1464 *
1465 * No need to add an explicit dependency for the toast table, as the
1466 * main table depends on it.
1467 */
1470 {
1475 }
1476 }
1478 /* Post creation hook for new relation */
1481 /*
1482 * Store any supplied constraints and defaults.
1483 *
1484 * NB: this may do a CommandCounterIncrement and rebuild the relcache
1485 * entry, so the relation must be valid and self-consistent at this point.
1486 * In particular, there are not yet constraints and defaults anywhere.
1487 */
1490 /*
1491 * If there's a special on-commit action, remember it
1492 */
1496 /*
1497 * ok, the relation has been cataloged, so close our relations and return
1498 * the OID of the newly created relation.
1499 */
1504 }
1506 /*
1507 * RelationRemoveInheritance
1508 *
1509 * Formerly, this routine checked for child relations and aborted the
1510 * deletion if any were found. Now we rely on the dependency mechanism
1511 * to check for or delete child relations. By the time we get here,
1512 * there are no children and we need only remove any pg_inherits rows
1513 * linking this relation to its parent(s).
1514 */
1515 static void
1517 {
1518 Relation catalogRelation;
1519 SysScanDesc scan;
1520 ScanKeyData key;
1521 HeapTuple tuple;
1526 Anum_pg_inherits_inhrelid,
1538 }
1540 /*
1541 * DeleteRelationTuple
1542 *
1543 * Remove pg_class row for the given relid.
1544 *
1545 * Note: this is shared by relation deletion and index deletion. It's
1546 * not intended for use anyplace else.
1547 */
1548 void
1550 {
1551 Relation pg_class_desc;
1552 HeapTuple tup;
1554 /* Grab an appropriate lock on the pg_class relation */
1561 /* delete the relation tuple from pg_class, and finish up */
1567 }
1569 /*
1570 * DeleteAttributeTuples
1571 *
1572 * Remove pg_attribute rows for the given relid.
1573 *
1574 * Note: this is shared by relation deletion and index deletion. It's
1575 * not intended for use anyplace else.
1576 */
1577 void
1579 {
1580 Relation attrel;
1581 SysScanDesc scan;
1583 HeapTuple atttup;
1585 /* Grab an appropriate lock on the pg_attribute relation */
1588 /* Use the index to scan only attributes of the target relation */
1590 Anum_pg_attribute_attrelid,
1597 /* Delete all the matching tuples */
1601 /* Clean up after the scan */
1604 }
1606 /*
1607 * DeleteSystemAttributeTuples
1608 *
1609 * Remove pg_attribute rows for system columns of the given relid.
1610 *
1611 * Note: this is only used when converting a table to a view. Views don't
1612 * have system columns, so we should remove them from pg_attribute.
1613 */
1614 void
1616 {
1617 Relation attrel;
1618 SysScanDesc scan;
1620 HeapTuple atttup;
1622 /* Grab an appropriate lock on the pg_attribute relation */
1625 /* Use the index to scan only system attributes of the target relation */
1627 Anum_pg_attribute_attrelid,
1631 Anum_pg_attribute_attnum,
1638 /* Delete all the matching tuples */
1642 /* Clean up after the scan */
1645 }
1647 /*
1648 * RemoveAttributeById
1649 *
1650 * This is the guts of ALTER TABLE DROP COLUMN: actually mark the attribute
1651 * deleted in pg_attribute. We also remove pg_statistic entries for it.
1652 * (Everything else needed, such as getting rid of any pg_attrdef entry,
1653 * is handled by dependency.c.)
1654 */
1655 void
1657 {
1658 Relation rel;
1659 Relation attr_rel;
1660 HeapTuple tuple;
1661 Form_pg_attribute attStruct;
1664 /*
1665 * Grab an exclusive lock on the target table, which we will NOT release
1666 * until end of transaction. (In the simple case where we are directly
1667 * dropping this column, ATExecDropColumn already did this ... but when
1668 * cascading from a drop of some other object, we may not have any lock.)
1669 */
1683 {
1684 /* System attribute (probably OID) ... just delete the row */
1687 }
1688 else
1689 {
1690 /* Dropping user attributes is lots harder */
1692 /* Mark the attribute as dropped */
1695 /*
1696 * Set the type OID to invalid. A dropped attribute's type link
1697 * cannot be relied on (once the attribute is dropped, the type might
1698 * be too). Fortunately we do not need the type row --- the only
1699 * really essential information is the type's typlen and typalign,
1700 * which are preserved in the attribute's attlen and attalign. We set
1701 * atttypid to zero here as a means of catching code that incorrectly
1702 * expects it to be valid.
1703 */
1706 /* Remove any NOT NULL constraint the column may have */
1709 /* We don't want to keep stats for it anymore */
1712 /* Unset this so no one tries to look up the generation expression */
1715 /*
1716 * Change the column name to something that isn't likely to conflict
1717 */
1722 /* clear the missing value if any */
1724 {
1729 /* update the tuple - set atthasmissing and attmissingval */
1743 }
1746 }
1748 /*
1749 * Because updating the pg_attribute row will trigger a relcache flush for
1750 * the target relation, we need not do anything else to notify other
1751 * backends of the change.
1752 */
1760 }
1762 /*
1763 * RemoveAttrDefault
1764 *
1765 * If the specified relation/attribute has a default, remove it.
1766 * (If no default, raise error if complain is true, else return quietly.)
1767 */
1768 void
1771 {
1772 Relation attrdef_rel;
1774 SysScanDesc scan;
1775 HeapTuple tuple;
1781 Anum_pg_attrdef_adrelid,
1785 Anum_pg_attrdef_adnum,
1792 /* There should be at most one matching tuple, but we loop anyway */
1794 {
1795 ObjectAddress object;
1806 }
1814 }
1816 /*
1817 * RemoveAttrDefaultById
1818 *
1819 * Remove a pg_attrdef entry specified by OID. This is the guts of
1820 * attribute-default removal. Note it should be called via performDeletion,
1821 * not directly.
1822 */
1823 void
1825 {
1826 Relation attrdef_rel;
1827 Relation attr_rel;
1828 Relation myrel;
1830 SysScanDesc scan;
1831 HeapTuple tuple;
1832 Oid myrelid;
1833 AttrNumber myattnum;
1835 /* Grab an appropriate lock on the pg_attrdef relation */
1838 /* Find the pg_attrdef tuple */
1840 Anum_pg_attrdef_oid,
1854 /* Get an exclusive lock on the relation owning the attribute */
1857 /* Now we can delete the pg_attrdef row */
1863 /* Fix the pg_attribute row */
1877 /*
1878 * Our update of the pg_attribute row will force a relcache rebuild, so
1879 * there's nothing else to do here.
1880 */
1883 /* Keep lock on attribute's rel until end of xact */
1885 }
1887 /*
1888 * heap_drop_with_catalog - removes specified relation from catalogs
1889 *
1890 * Note that this routine is not responsible for dropping objects that are
1891 * linked to the pg_class entry via dependencies (for example, indexes and
1892 * constraints). Those are deleted by the dependency-tracing logic in
1893 * dependency.c before control gets here. In general, therefore, this routine
1894 * should never be called directly; go through performDeletion() instead.
1895 */
1896 void
1898 {
1899 Relation rel;
1900 HeapTuple tuple;
1904 /*
1905 * To drop a partition safely, we must grab exclusive lock on its parent,
1906 * because another backend might be about to execute a query on the parent
1907 * table. If it relies on previously cached partition descriptor, then it
1908 * could attempt to access the just-dropped relation as its partition. We
1909 * must therefore take a table lock strong enough to prevent all queries
1910 * on the table from proceeding until we commit and send out a
1911 * shared-cache-inval notice that will make them update their partition
1912 * descriptors.
1913 */
1918 {
1922 /*
1923 * If this is not the default partition, dropping it will change the
1924 * default partition's partition constraint, so we must lock it.
1925 */
1929 }
1933 /*
1934 * Open and lock the relation.
1935 */
1938 /*
1939 * There can no longer be anyone *else* touching the relation, but we
1940 * might still have open queries or cursors, or pending trigger events, in
1941 * our own session.
1942 */
1945 /*
1946 * This effectively deletes all rows in the table, and may be done in a
1947 * serializable transaction. In that case we must record a rw-conflict in
1948 * to this transaction from each transaction holding a predicate lock on
1949 * the table.
1950 */
1953 /*
1954 * Delete pg_foreign_table tuple first.
1955 */
1957 {
1958 Relation rel;
1959 HeapTuple tuple;
1971 }
1973 /*
1974 * If a partitioned table, delete the pg_partitioned_table tuple.
1975 */
1979 /*
1980 * If the relation being dropped is the default partition itself,
1981 * invalidate its entry in pg_partitioned_table.
1982 */
1986 /*
1987 * Schedule unlinking of the relation's physical files at commit.
1988 */
1992 /*
1993 * Close relcache entry, but *keep* AccessExclusiveLock on the relation
1994 * until transaction commit. This ensures no one else will try to do
1995 * something with the doomed relation.
1996 */
1999 /*
2000 * Remove any associated relation synchronization states.
2001 */
2004 /*
2005 * Forget any ON COMMIT action for the rel
2006 */
2009 /*
2010 * Flush the relation from the relcache. We want to do this before
2011 * starting to remove catalog entries, just to be certain that no relcache
2012 * entry rebuild will happen partway through. (That should not really
2013 * matter, since we don't do CommandCounterIncrement here, but let's be
2014 * safe.)
2015 */
2018 /*
2019 * remove inheritance information
2020 */
2023 /*
2024 * delete statistics
2025 */
2028 /*
2029 * delete attribute tuples
2030 */
2033 /*
2034 * delete relation tuple
2035 */
2039 {
2040 /*
2041 * If this is not the default partition, the partition constraint of
2042 * the default partition has changed to include the portion of the key
2043 * space previously covered by the dropped partition.
2044 */
2048 /*
2049 * Invalidate the parent's relcache so that the partition is no longer
2050 * included in its partition descriptor.
2051 */
2053 /* keep the lock */
2054 }
2055 }
2058 /*
2059 * RelationClearMissing
2060 *
2061 * Set atthasmissing and attmissingval to false/null for all attributes
2062 * where they are currently set. This can be safely and usefully done if
2063 * the table is rewritten (e.g. by VACUUM FULL or CLUSTER) where we know there
2064 * are no rows left with less than a full complement of attributes.
2065 *
2066 * The caller must have an AccessExclusive lock on the relation.
2067 */
2068 void
2070 {
2071 Relation attr_rel;
2078 Form_pg_attribute attrtuple;
2079 HeapTuple tuple,
2080 newtuple;
2093 /* Get a lock on pg_attribute */
2096 /* process each non-system attribute, including any dropped columns */
2098 {
2108 /* ignore any where atthasmissing is not true */
2110 {
2117 }
2120 }
2122 /*
2123 * Our update of the pg_attribute rows will force a relcache rebuild, so
2124 * there's nothing else to do here.
2125 */
2127 }
2129 /*
2130 * SetAttrMissing
2131 *
2132 * Set the missing value of a single attribute. This should only be used by
2133 * binary upgrade. Takes an AccessExclusive lock on the relation owning the
2134 * attribute.
2135 */
2136 void
2138 {
2142 Datum missingval;
2143 Form_pg_attribute attStruct;
2144 Relation attrrel,
2145 tablerel;
2146 HeapTuple atttup,
2147 newtup;
2149 /* lock the table the attribute belongs to */
2152 /* Lock the attribute row and get the data */
2160 /* get an array value from the value string */
2166 /* update the tuple - set atthasmissing and attmissingval */
2180 /* clean up */
2184 }
2186 /*
2187 * Store a default expression for column attnum of relation rel.
2188 *
2189 * Returns the OID of the new pg_attrdef tuple.
2190 *
2191 * add_column_mode must be true if we are storing the default for a new
2192 * attribute, and false if it's for an already existing attribute. The reason
2193 * for this is that the missing value must never be updated after it is set,
2194 * which can only be when a column is added to the table. Otherwise we would
2195 * in effect be changing existing tuples.
2196 */
2197 Oid
2200 {
2202 Relation adrel;
2203 HeapTuple tuple;
2206 Relation attrrel;
2207 HeapTuple atttup;
2208 Form_pg_attribute attStruct;
2210 Oid attrdefOid;
2211 ObjectAddress colobject,
2212 defobject;
2216 /*
2217 * Flatten expression to string form for storage.
2218 */
2221 /*
2222 * Make the pg_attrdef entry.
2223 */
2225 Anum_pg_attrdef_oid);
2240 /* now can free some of the stuff allocated above */
2245 /*
2246 * Update the pg_attribute entry for the column to show that a default
2247 * exists.
2248 */
2259 {
2260 Form_pg_attribute defAttStruct;
2279 {
2293 {
2294 /* if the default evaluates to NULL, just store a NULL array */
2296 }
2297 else
2298 {
2299 /* otherwise make a one-element array of the value */
2306 }
2313 }
2322 }
2326 /*
2327 * Make a dependency so that the pg_attrdef entry goes away if the column
2328 * (or whole table) is deleted.
2329 */
2336 /*
2337 * Record dependencies on objects used in the expression, too.
2338 */
2340 {
2341 /*
2342 * Generated column: Dropping anything that the generation expression
2343 * refers to automatically drops the generated column.
2344 */
2346 DEPENDENCY_AUTO,
2348 }
2349 else
2350 {
2351 /*
2352 * Normal default: Dropping anything that the default refers to
2353 * requires CASCADE and drops the default only.
2354 */
2356 DEPENDENCY_NORMAL,
2358 }
2360 /*
2361 * Post creation hook for attribute defaults.
2362 *
2363 * XXX. ALTER TABLE ALTER COLUMN SET/DROP DEFAULT is implemented with a
2364 * couple of deletion/creation of the attribute's default entry, so the
2365 * callee should check existence of an older version of this entry if it
2366 * needs to distinguish.
2367 */
2372 }
2374 /*
2375 * Store a check-constraint expression for the given relation.
2376 *
2377 * Caller is responsible for updating the count of constraints
2378 * in the pg_class entry for the relation.
2379 *
2380 * The OID of the new constraint is returned.
2381 */
2382 static Oid
2386 {
2391 Oid constrOid;
2393 /*
2394 * Flatten expression to string form for storage.
2395 */
2398 /*
2399 * Find columns of rel that are used in expr
2400 *
2401 * NB: pull_var_clause is okay here only because we don't allow subselects
2402 * in check constraints; it would fail to examine the contents of
2403 * subselects.
2404 */
2409 {
2415 {
2424 }
2426 }
2427 else
2430 /*
2431 * Partitioned tables do not contain any rows themselves, so a NO INHERIT
2432 * constraint makes no sense.
2433 */
2441 /*
2442 * Create the Check Constraint
2443 */
2444 constrOid =
2450 is_validated,
2459 NULL,
2460 NULL,
2461 NULL,
2462 NULL,
2478 }
2480 /*
2481 * Store defaults and constraints (passed as a list of CookedConstraint).
2482 *
2483 * Each CookedConstraint struct is modified to store the new catalog tuple OID.
2484 *
2485 * NOTE: only pre-cooked expressions will be passed this way, which is to
2486 * say expressions inherited from an existing relation. Newly parsed
2487 * expressions can be added later, by direct calls to StoreAttrDefault
2488 * and StoreRelCheck (see AddRelationNewConstraints()).
2489 */
2490 static void
2492 {
2499 /*
2500 * Deparsing of constraint expressions will fail unless the just-created
2501 * pg_attribute tuples for this relation are made visible. So, bump the
2502 * command counter. CAUTION: this will cause a relcache entry rebuild.
2503 */
2507 {
2511 {
2521 is_internal);
2522 numchecks++;
2527 }
2528 }
2532 }
2534 /*
2535 * AddRelationNewConstraints
2536 *
2537 * Add new column default expressions and/or constraint check expressions
2538 * to an existing relation. This is defined to do both for efficiency in
2539 * DefineRelation, but of course you can do just one or the other by passing
2540 * empty lists.
2541 *
2542 * rel: relation to be modified
2543 * newColDefaults: list of RawColumnDefault structures
2544 * newConstraints: list of Constraint nodes
2545 * allow_merge: true if check constraints may be merged with existing ones
2546 * is_local: true if definition is local, false if it's inherited
2547 * is_internal: true if result of some internal process, not a user request
2548 *
2549 * All entries in newColDefaults will be processed. Entries in newConstraints
2550 * will be processed only if they are CONSTR_CHECK type.
2551 *
2552 * Returns a list of CookedConstraint nodes that shows the cooked form of
2553 * the default and constraint expressions added to the relation.
2554 *
2555 * NB: caller should have opened rel with AccessExclusiveLock, and should
2556 * hold that lock till end of transaction. Also, we assume the caller has
2557 * done a CommandCounterIncrement if necessary to make the relation's catalog
2558 * tuples visible.
2559 */
2560 List *
2568 {
2570 TupleDesc tupleDesc;
2581 /*
2582 * Get info about existing constraints.
2583 */
2588 else
2591 /*
2592 * Create a dummy ParseState and insert the target relation as its sole
2593 * rangetable entry. We need a ParseState for transformExpr.
2594 */
2598 rel,
2599 AccessShareLock,
2600 NULL,
2605 /*
2606 * Process column default expressions.
2607 */
2609 {
2612 Oid defOid;
2619 /*
2620 * If the expression is just a NULL constant, we do not bother to make
2621 * an explicit pg_attrdef entry, since the default behavior is
2622 * equivalent. This applies to column defaults, but not for
2623 * generation expressions.
2624 *
2625 * Note a nonobvious property of this test: if the column is of a
2626 * domain type, what we'll get is not a bare null Const but a
2627 * CoerceToDomain expr, so we will not discard the default. This is
2628 * critical because the column default needs to be retained to
2629 * override any default that the domain might have.
2630 */
2637 /* If the DEFAULT is volatile we cannot use a missing value */
2655 }
2657 /*
2658 * Process constraint expressions.
2659 */
2663 {
2666 Oid constrOid;
2672 {
2675 /*
2676 * Transform raw parsetree to executable expression, and verify
2677 * it's valid as a CHECK constraint.
2678 */
2681 }
2682 else
2683 {
2686 /*
2687 * Here, we assume the parser will only pass us valid CHECK
2688 * expressions, so we do no particular checking.
2689 */
2691 }
2693 /*
2694 * Check name uniqueness, or generate a name if none was given.
2695 */
2697 {
2701 /* Check against other new constraints */
2702 /* Needed because we don't do CommandCounterIncrement in loop */
2704 {
2709 ccname)));
2710 }
2712 /* save name for future checks */
2715 /*
2716 * Check against pre-existing constraints. If we are allowed to
2717 * merge with an existing constraint, there's no more to do here.
2718 * (We omit the duplicate constraint from the result, which is
2719 * what ATAddCheckConstraint wants.)
2720 */
2726 }
2727 else
2728 {
2729 /*
2730 * When generating a name, we want to create "tab_col_check" for a
2731 * column constraint and "tab_check" for a table constraint. We
2732 * no longer have any info about the syntactic positioning of the
2733 * constraint phrase, so we approximate this by seeing whether the
2734 * expression references more than one column. (If the user
2735 * played by the rules, the result is the same...)
2736 *
2737 * Note: pull_var_clause() doesn't descend into sublinks, but we
2738 * eliminated those above; and anyway this only needs to be an
2739 * approximate answer.
2740 */
2746 /* eliminate duplicates */
2753 else
2757 colname,
2760 checknames);
2762 /* save name for future checks */
2764 }
2766 /*
2767 * OK, store it.
2768 */
2769 constrOid =
2773 numchecks++;
2786 }
2788 /*
2789 * Update the count of constraints in the relation's pg_class tuple. We do
2790 * this even if there was no change, in order to ensure that an SI update
2791 * message is sent out for the pg_class tuple, which will force other
2792 * backends to rebuild their relcache entries for the rel. (This is
2793 * critical if we added defaults but not constraints.)
2794 */
2798 }
2800 /*
2801 * Check for a pre-existing check constraint that conflicts with a proposed
2802 * new one, and either adjust its conislocal/coninhcount settings or throw
2803 * error as needed.
2804 *
2805 * Returns true if merged (constraint is a duplicate), or false if it's
2806 * got a so-far-unique name, or throws error if conflict.
2807 *
2808 * XXX See MergeConstraintsIntoExisting too if you change this code.
2809 */
2810 static bool
2815 {
2817 Relation conDesc;
2818 SysScanDesc conscan;
2820 HeapTuple tup;
2822 /* Search for a pg_constraint entry with same name and relation */
2828 Anum_pg_constraint_conrelid,
2832 Anum_pg_constraint_contypid,
2836 Anum_pg_constraint_conname,
2843 /* There can be at most one matching row */
2845 {
2848 /* Found it. Conflicts if not identical check constraint */
2850 {
2851 Datum val;
2855 Anum_pg_constraint_conbin,
2862 }
2864 /*
2865 * If the existing constraint is purely inherited (no local
2866 * definition) then interpret addition of a local constraint as a
2867 * legal merge. This allows ALTER ADD CONSTRAINT on parent and child
2868 * tables to be given in either order with same end state. However if
2869 * the relation is a partition, all inherited constraints are always
2870 * non-local, including those that were merged.
2871 */
2881 /* If the child constraint is "no inherit" then cannot merge */
2888 /*
2889 * Must not change an existing inherited constraint to "no inherit"
2890 * status. That's because inherited constraints should be able to
2891 * propagate to lower-level children.
2892 */
2899 /*
2900 * If the child constraint is "not valid" then cannot merge with a
2901 * valid parent constraint.
2902 */
2909 /* OK to update the tuple */
2912 ccname)));
2917 /*
2918 * In case of partitions, an inherited constraint must be inherited
2919 * only once since it cannot have multiple parents and it is never
2920 * considered local.
2921 */
2923 {
2926 }
2927 else
2928 {
2931 else
2933 }
2936 {
2939 }
2942 }
2948 }
2950 /*
2951 * Update the count of constraints in the relation's pg_class tuple.
2952 *
2953 * Caller had better hold exclusive lock on the relation.
2954 *
2955 * An important side effect is that a SI update message will be sent out for
2956 * the pg_class tuple, which will force other backends to rebuild their
2957 * relcache entries for the rel. Also, this backend will rebuild its
2958 * own relcache entry at the next CommandCounterIncrement.
2959 */
2960 static void
2962 {
2963 Relation relrel;
2964 HeapTuple reltup;
2965 Form_pg_class relStruct;
2976 {
2980 }
2981 else
2982 {
2983 /* Skip the disk update, but force relcache inval anyway */
2985 }
2989 }
2991 /*
2992 * Check for references to generated columns
2993 */
2994 static bool
2996 {
3002 {
3004 Oid relid;
3005 AttrNumber attnum;
3019 }
3020 else
3023 }
3025 static void
3027 {
3029 }
3031 /*
3032 * Take a raw default and convert it to a cooked format ready for
3033 * storage.
3034 *
3035 * Parse state should be set up to recognize any vars that might appear
3036 * in the expression. (Even though we plan to reject vars, it's more
3037 * user-friendly to give the correct error message than "unknown var".)
3038 *
3039 * If atttypid is not InvalidOid, coerce the expression to the specified
3040 * type (and typmod atttypmod). attname is only needed in this case:
3041 * it is used in the error message, if any.
3042 */
3043 Node *
3046 Oid atttypid,
3047 int32 atttypmod,
3050 {
3055 /*
3056 * Transform raw parsetree to executable expression.
3057 */
3058 expr = transformExpr(pstate, raw_default, attgenerated ? EXPR_KIND_GENERATED_COLUMN : EXPR_KIND_COLUMN_DEFAULT);
3061 {
3068 }
3069 else
3070 {
3071 /*
3072 * For a default expression, transformExpr() should have rejected
3073 * column references.
3074 */
3076 }
3078 /*
3079 * Coerce the expression to the correct type and typmod, if given. This
3080 * should match the parser's processing of non-defaulted expressions ---
3081 * see transformAssignedExpr().
3082 */
3084 {
3089 COERCION_ASSIGNMENT,
3090 COERCE_IMPLICIT_CAST,
3097 attname,
3101 }
3103 /*
3104 * Finally, take care of collations in the finished expression.
3105 */
3109 }
3111 /*
3112 * Take a raw CHECK constraint expression and convert it to a cooked format
3113 * ready for storage.
3114 *
3115 * Parse state must be set up to recognize any vars that might appear
3116 * in the expression.
3117 */
3122 {
3125 /*
3126 * Transform raw parsetree to executable expression.
3127 */
3130 /*
3131 * Make sure it yields a boolean result.
3132 */
3135 /*
3136 * Take care of collations.
3137 */
3140 /*
3141 * Make sure no outside relations are referred to (this is probably dead
3142 * code now that add_missing_from is history).
3143 */
3148 relname)));
3151 }
3154 /*
3155 * RemoveStatistics --- remove entries in pg_statistic for a rel or column
3156 *
3157 * If attnum is zero, remove all entries for rel; else remove only the one(s)
3158 * for that column.
3159 */
3160 void
3162 {
3163 Relation pgstatistic;
3164 SysScanDesc scan;
3167 HeapTuple tuple;
3172 Anum_pg_statistic_starelid,
3178 else
3179 {
3181 Anum_pg_statistic_staattnum,
3185 }
3190 /* we must loop even when attnum != 0, in case of inherited stats */
3197 }
3200 /*
3201 * RelationTruncateIndexes - truncate all indexes associated
3202 * with the heap relation to zero tuples.
3203 *
3204 * The routine will truncate and then reconstruct the indexes on
3205 * the specified relation. Caller must hold exclusive lock on rel.
3206 */
3207 static void
3209 {
3212 /* Ask the relcache to produce a list of the indexes of the rel */
3214 {
3216 Relation currentIndex;
3219 /* Open the index relation; use exclusive lock, just to be sure */
3222 /*
3223 * Fetch info needed for index_build. Since we know there are no
3224 * tuples that actually need indexing, we can use a dummy IndexInfo.
3225 * This is slightly cheaper to build, but the real point is to avoid
3226 * possibly running user-defined code in index expressions or
3227 * predicates. We might be getting invoked during ON COMMIT
3228 * processing, and we don't want to run any such code then.
3229 */
3232 /*
3233 * Now truncate the actual file (and discard buffers).
3234 */
3237 /* Initialize the index and rebuild */
3238 /* Note: we do not need to re-establish pkey setting */
3241 /* We're done with this index */
3243 }
3244 }
3246 /*
3247 * heap_truncate
3248 *
3249 * This routine deletes all data within all the specified relations.
3250 *
3251 * This is not transaction-safe! There is another, transaction-safe
3252 * implementation in commands/tablecmds.c. We now use this only for
3253 * ON COMMIT truncation of temporary tables, where it doesn't matter.
3254 */
3255 void
3257 {
3261 /* Open relations for processing, and grab exclusive access on each */
3263 {
3265 Relation rel;
3269 }
3271 /* Don't allow truncate on tables that are referenced by foreign keys */
3274 /* OK to do it */
3276 {
3279 /* Truncate the relation */
3282 /* Close the relation, but keep exclusive lock on it until commit */
3284 }
3285 }
3287 /*
3288 * heap_truncate_one_rel
3289 *
3290 * This routine deletes all data within the specified relation.
3291 *
3292 * This is not transaction-safe, because the truncation is done immediately
3293 * and cannot be rolled back later. Caller is responsible for having
3294 * checked permissions etc, and must have obtained AccessExclusiveLock.
3295 */
3296 void
3298 {
3299 Oid toastrelid;
3301 /*
3302 * Truncate the relation. Partitioned tables have no storage, so there is
3303 * nothing to do for them here.
3304 */
3308 /* Truncate the underlying relation */
3311 /* If the relation has indexes, truncate the indexes too */
3314 /* If there is a toast table, truncate that too */
3317 {
3322 /* keep the lock... */
3324 }
3325 }
3327 /*
3328 * heap_truncate_check_FKs
3329 * Check for foreign keys referencing a list of relations that
3330 * are to be truncated, and raise error if there are any
3331 *
3332 * We disallow such FKs (except self-referential ones) since the whole point
3333 * of TRUNCATE is to not scan the individual rows to be thrown away.
3334 *
3335 * This is split out so it can be shared by both implementations of truncate.
3336 * Caller should already hold a suitable lock on the relations.
3337 *
3338 * tempTables is only used to select an appropriate error message.
3339 */
3340 void
3342 {
3347 /*
3348 * Build a list of OIDs of the interesting relations.
3349 *
3350 * If a relation has no triggers, then it can neither have FKs nor be
3351 * referenced by a FK from another table, so we can ignore it. For
3352 * partitioned tables, FKs have no triggers, so we must include them
3353 * anyway.
3354 */
3356 {
3362 }
3364 /*
3365 * Fast path: if no relation has triggers, none has FKs either.
3366 */
3370 /*
3371 * Otherwise, must scan pg_constraint. We make one pass with all the
3372 * relations considered; if this finds nothing, then all is well.
3373 */
3378 /*
3379 * Otherwise we repeat the scan once per relation to identify a particular
3380 * pair of relations to complain about. This is pretty slow, but
3381 * performance shouldn't matter much in a failure path. The reason for
3382 * doing things this way is to ensure that the message produced is not
3383 * dependent on chance row locations within pg_constraint.
3384 */
3386 {
3393 {
3397 {
3407 else
3415 relname2)));
3416 }
3417 }
3418 }
3419 }
3421 /*
3422 * heap_truncate_find_FKs
3423 * Find relations having foreign keys referencing any of the given rels
3424 *
3425 * Input and result are both lists of relation OIDs. The result contains
3426 * no duplicates, does *not* include any rels that were already in the input
3427 * list, and is sorted in OID order. (The last property is enforced mainly
3428 * to guarantee consistent behavior in the regression tests; we don't want
3429 * behavior to change depending on chance locations of rows in pg_constraint.)
3430 *
3431 * Note: caller should already have appropriate lock on all rels mentioned
3432 * in relationIds. Since adding or dropping an FK requires exclusive lock
3433 * on both rels, this ensures that the answer will be stable.
3434 */
3435 List *
3437 {
3442 ScanKeyData key;
3443 Relation fkeyRel;
3444 SysScanDesc fkeyScan;
3445 HeapTuple tuple;
3450 /*
3451 * Must scan pg_constraint. Right now, it is a seqscan because there is
3452 * no available index on confrelid.
3453 */
3456 restart:
3464 {
3467 /* Not a foreign key */
3471 /* Not referencing one of our list of tables */
3475 /*
3476 * If this constraint has a parent constraint which we have not seen
3477 * yet, keep track of it for the second loop, below. Tracking parent
3478 * constraints allows us to climb up to the top-level level constraint
3479 * and look for all possible relations referencing the partitioned
3480 * table.
3481 */
3486 /*
3487 * Add referencer to result, unless present in input list. (Don't
3488 * worry about dupes: we'll fix that below).
3489 */
3492 }
3496 /*
3497 * Process each parent constraint we found to add the list of referenced
3498 * relations by them to the oids list. If we do add any new such
3499 * relations, redo the first loop above. Also, if we see that the parent
3500 * constraint in turn has a parent, add that so that we process all
3501 * relations in a single additional pass.
3502 */
3504 {
3508 Anum_pg_constraint_oid,
3517 {
3520 /*
3521 * pg_constraint rows always appear for partitioned hierarchies
3522 * this way: on the each side of the constraint, one row appears
3523 * for each partition that points to the top-most table on the
3524 * other side.
3525 *
3526 * Because of this arrangement, we can correctly catch all
3527 * relevant relations by adding to 'parent_cons' all rows with
3528 * valid conparentid, and to the 'oids' list all rows with a zero
3529 * conparentid. If any oids are added to 'oids', redo the first
3530 * loop above by setting 'restart'.
3531 */
3536 {
3539 }
3540 }
3543 }
3552 /* Now sort and de-duplicate the result list */
3557 }
3559 /*
3560 * StorePartitionKey
3561 * Store information about the partition key rel into the catalog
3562 */
3563 void
3566 int16 partnatts,
3571 {
3576 Datum partexprDatum;
3577 Relation pg_partitioned_table;
3578 HeapTuple tuple;
3581 ObjectAddress myself;
3582 ObjectAddress referenced;
3586 /* Copy the partition attribute numbers, opclass OIDs into arrays */
3591 /* Convert the expressions (if any) to a text datum */
3593 {
3599 }
3600 else
3607 /* Only this can ever be NULL */
3625 /* Mark this relation as dependent on a few things as follows */
3630 /* Operator class and collation per key column */
3632 {
3639 /* The default collation is pinned, so don't bother recording it */
3642 {
3648 }
3649 }
3651 /*
3652 * The partitioning columns are made internally dependent on the table,
3653 * because we cannot drop any of them without dropping the whole table.
3654 * (ATExecDropColumn independently enforces that, but it's not bulletproof
3655 * so we need the dependencies too.)
3656 */
3658 {
3667 }
3669 /*
3670 * Also consider anything mentioned in partition expressions. External
3671 * references (e.g. functions) get NORMAL dependencies. Table columns
3672 * mentioned in the expressions are handled the same as plain partitioning
3673 * columns, i.e. they become internally dependent on the whole table.
3674 */
3679 DEPENDENCY_NORMAL,
3680 DEPENDENCY_INTERNAL,
3683 /*
3684 * We must invalidate the relcache so that the next
3685 * CommandCounterIncrement() will cause the same to be rebuilt using the
3686 * information in just created catalog entry.
3687 */
3689 }
3691 /*
3692 * RemovePartitionKeyByRelId
3693 * Remove pg_partitioned_table entry for a relation
3694 */
3695 void
3697 {
3698 Relation rel;
3699 HeapTuple tuple;
3706 relid);
3712 }
3714 /*
3715 * StorePartitionBound
3716 * Update pg_class tuple of rel to store the partition bound and set
3717 * relispartition to true
3718 *
3719 * If this is the default partition, also update the default partition OID in
3720 * pg_partitioned_table.
3721 *
3722 * Also, invalidate the parent's relcache, so that the next rebuild will load
3723 * the new partition's info into its partition descriptor. If there is a
3724 * default partition, we must invalidate its relcache entry as well.
3725 */
3726 void
3728 {
3729 Relation classRel;
3730 HeapTuple tuple,
3731 newtuple;
3735 Oid defaultPartOid;
3737 /* Update pg_class tuple */
3745 #ifdef USE_ASSERT_CHECKING
3746 {
3747 Form_pg_class classForm;
3755 }
3756 #endif
3758 /* Fill in relpartbound value */
3767 /* Also set the flag */
3773 /*
3774 * If we're storing bounds for the default partition, update
3775 * pg_partitioned_table too.
3776 */
3781 /* Make these updates visible */
3784 /*
3785 * The partition constraint for the default partition depends on the
3786 * partition bounds of every other partition, so we must invalidate the
3787 * relcache entry for that partition every time a partition is added or
3788 * removed.
3789 */
3795 }