| blob | f0278b9c0175d35b3fa4d762ef939d9b35e7958e |
1 /*-------------------------------------------------------------------------
2 *
3 * heap.c
4 * code to create and destroy POSTGRES heap relations
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/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 */
79 /* Potentially set by pg_upgrade_support functions */
86 Relation new_rel_desc,
87 Oid new_rel_oid,
88 Oid new_type_oid,
89 Oid reloftype,
90 Oid relowner,
92 TransactionId relfrozenxid,
93 TransactionId relminmxid,
94 Datum relacl,
95 Datum reloptions);
97 Oid typeNamespace,
98 Oid new_rel_oid,
100 Oid ownerid,
101 Oid new_row_type,
102 Oid new_array_type);
119 /* ----------------------------------------------------------------
120 * XXX UGLY HARD CODED BADNESS FOLLOWS XXX
121 *
122 * these should all be moved to someplace in the lib/catalog
123 * module, if not obliterated first.
124 * ----------------------------------------------------------------
125 */
128 /*
129 * Note:
130 * Should the system special case these attributes in the future?
131 * Advantage: consume much less space in the ATTRIBUTE relation.
132 * Disadvantage: special cases will be all over the place.
133 */
135 /*
136 * The initializers below do not include trailing variable length fields,
137 * but that's OK - we're never going to reference anything beyond the
138 * fixed-size portion of the structure anyway. Fields that can default
139 * to zeroes are also not mentioned.
140 */
154 };
168 };
182 };
196 };
210 };
212 /*
213 * We decided to call this attribute "tableoid" rather than say
214 * "classoid" on the basis that in the future there may be more than one
215 * table of a particular class/type. In any case table is still the word
216 * used in SQL.
217 */
230 };
234 /*
235 * This function returns a Form_pg_attribute pointer for a system attribute.
236 * Note that we elog if the presented attno is invalid, which would only
237 * happen if there's a problem upstream.
238 */
241 {
245 }
247 /*
248 * If the given name is a system attribute name, return a Form_pg_attribute
249 * pointer for a prototype definition. If not, return NULL.
250 */
253 {
257 {
262 }
265 }
268 /* ----------------------------------------------------------------
269 * XXX END OF UGLY HARD CODED BADNESS XXX
270 * ---------------------------------------------------------------- */
273 /* ----------------------------------------------------------------
274 * heap_create - Create an uncataloged heap relation
275 *
276 * Note API change: the caller must now always provide the OID
277 * to use for the relation. The relfilenumber may be (and in
278 * the simplest cases is) left unspecified.
279 *
280 * create_storage indicates whether or not to create the storage.
281 * However, even if create_storage is true, no storage will be
282 * created if the relkind is one that doesn't have storage.
283 *
284 * rel->rd_rel is initialized by RelationBuildLocalRelation,
285 * and is mostly zeroes at return.
286 * ----------------------------------------------------------------
287 */
288 Relation
290 Oid relnamespace,
291 Oid reltablespace,
292 Oid relid,
293 RelFileNumber relfilenumber,
294 Oid accessmtd,
295 TupleDesc tupDesc,
304 {
305 Relation rel;
307 /* The caller must have provided an OID for the relation. */
310 /*
311 * Don't allow creating relations in pg_catalog directly, even though it
312 * is allowed to move user defined relations there. Semantics with search
313 * paths including pg_catalog are too confusing for now.
314 *
315 * But allow creating indexes on relations in pg_catalog even if
316 * allow_system_table_mods = off, upper layers already guarantee it's on a
317 * user defined relation, not a system one.
318 */
332 /*
333 * Force reltablespace to zero if the relation kind does not support
334 * tablespaces. This is mainly just for cleanliness' sake.
335 */
339 /* Don't create storage for relkinds without physical storage. */
342 else
343 {
344 /*
345 * If relfilenumber is unspecified by the caller then create storage
346 * with oid same as relid.
347 */
350 }
352 /*
353 * Never allow a pg_class entry to explicitly specify the database's
354 * default tablespace in reltablespace; force it to zero instead. This
355 * ensures that if the database is cloned with a different default
356 * tablespace, the pg_class entry will still match where CREATE DATABASE
357 * will put the physically copied relation.
358 *
359 * Yes, this is a bit of a hack.
360 */
364 /*
365 * build the relcache entry.
366 */
368 relnamespace,
369 tupDesc,
370 relid,
371 accessmtd,
372 relfilenumber,
373 reltablespace,
374 shared_relation,
375 mapped_relation,
376 relpersistence,
377 relkind);
379 /*
380 * Have the storage manager create the relation's disk file, if needed.
381 *
382 * For tables, the AM callback creates both the main and the init fork.
383 * For others, only the main fork is created; the other forks will be
384 * created on demand.
385 */
387 {
390 relpersistence,
394 else
396 }
398 /*
399 * If a tablespace is specified, removal of that tablespace is normally
400 * protected by the existence of a physical file; but for relations with
401 * no files, add a pg_shdepend entry to account for that.
402 */
405 reltablespace);
407 /* ensure that stats are dropped if transaction aborts */
411 }
413 /* ----------------------------------------------------------------
414 * heap_create_with_catalog - Create a cataloged relation
415 *
416 * this is done in multiple steps:
417 *
418 * 1) CheckAttributeNamesTypes() is used to make certain the tuple
419 * descriptor contains a valid set of attribute names and types
420 *
421 * 2) pg_class is opened and get_relname_relid()
422 * performs a scan to ensure that no relation with the
423 * same name already exists.
424 *
425 * 3) heap_create() is called to create the new relation on disk.
426 *
427 * 4) TypeCreate() is called to define a new type corresponding
428 * to the new relation.
429 *
430 * 5) AddNewRelationTuple() is called to register the
431 * relation in pg_class.
432 *
433 * 6) AddNewAttributeTuples() is called to register the
434 * new relation's schema in pg_attribute.
435 *
436 * 7) StoreConstraints is called () - vadim 08/22/97
437 *
438 * 8) the relations are closed and the new relation's oid
439 * is returned.
440 *
441 * ----------------------------------------------------------------
442 */
444 /* --------------------------------
445 * CheckAttributeNamesTypes
446 *
447 * this is used to make certain the tuple descriptor contains a
448 * valid set of attribute names and datatypes. a problem simply
449 * generates ereport(ERROR) which aborts the current transaction.
450 *
451 * relkind is the relkind of the relation to be created.
452 * flags controls which datatypes are allowed, cf CheckAttributeType.
453 * --------------------------------
454 */
455 void
458 {
463 /* Sanity check on column count */
468 MaxHeapAttributeNumber)));
470 /*
471 * first check for collision with system attribute names
472 *
473 * Skip this for a view or type relation, since those don't have system
474 * attributes.
475 */
477 {
479 {
487 }
488 }
490 /*
491 * next check for repeated attribute names
492 */
494 {
496 {
503 }
504 }
506 /*
507 * next check the attribute types
508 */
510 {
515 flags);
516 }
517 }
519 /* --------------------------------
520 * CheckAttributeType
521 *
522 * Verify that the proposed datatype of an attribute is legal.
523 * This is needed mainly because there are types (and pseudo-types)
524 * in the catalogs that we do not support as elements of real tuples.
525 * We also check some other properties required of a table column.
526 *
527 * If the attribute is being proposed for addition to an existing table or
528 * composite type, pass a one-element list of the rowtype OID as
529 * containing_rowtypes. When checking a to-be-created rowtype, it's
530 * sufficient to pass NIL, because there could not be any recursive reference
531 * to a not-yet-existing rowtype.
532 *
533 * flags is a bitmask controlling which datatypes we allow. For the most
534 * part, pseudo-types are disallowed as attribute types, but there are some
535 * exceptions: ANYARRAYOID, RECORDOID, and RECORDARRAYOID can be allowed
536 * in some cases. (This works because values of those type classes are
537 * self-identifying to some extent. However, RECORDOID and RECORDARRAYOID
538 * are reliably identifiable only within a session, since the identity info
539 * may use a typmod that is only locally assigned. The caller is expected
540 * to know whether these cases are safe.)
541 *
542 * flags can also control the phrasing of the error messages. If
543 * CHKATYPE_IS_PARTKEY is specified, "attname" should be a partition key
544 * column number as text, not a real column name.
545 * --------------------------------
546 */
547 void
552 {
554 Oid att_typelem;
556 /* since this function recurses, it could be driven to stack overflow */
560 {
561 /*
562 * We disallow pseudo-type columns, with the exception of ANYARRAY,
563 * RECORD, and RECORD[] when the caller says that those are OK.
564 *
565 * We don't need to worry about recursive containment for RECORD and
566 * RECORD[] because (a) no named composite type should be allowed to
567 * contain those, and (b) two "anonymous" record types couldn't be
568 * considered to be the same type, so infinite recursion isn't
569 * possible.
570 */
574 {
578 /* translator: first %s is an integer not a name */
581 else
586 }
587 }
589 {
590 /*
591 * If it's a domain, recurse to check its base type.
592 */
594 containing_rowtypes,
595 flags);
596 }
598 {
599 /*
600 * For a composite type, recurse into its attributes.
601 */
602 Relation relation;
603 TupleDesc tupdesc;
606 /*
607 * Check for self-containment. Eventually we might be able to allow
608 * this (just return without complaint, if so) but it's not clear how
609 * many other places would require anti-recursion defenses before it
610 * would be safe to allow tables to contain their own rowtype.
611 */
625 {
632 containing_rowtypes,
634 }
639 }
641 {
642 /*
643 * If it's a range, recurse to check its subtype.
644 */
647 containing_rowtypes,
648 flags);
649 }
651 {
652 /*
653 * Must recurse into array types, too, in case they are composite.
654 */
656 containing_rowtypes,
657 flags);
658 }
660 /*
661 * This might not be strictly invalid per SQL standard, but it is pretty
662 * useless, and it cannot be dumped, so we must disallow it.
663 */
665 {
669 /* translator: first %s is an integer not a name */
673 else
679 }
680 }
682 /*
683 * InsertPgAttributeTuples
684 * Construct and insert a set of tuples in pg_attribute.
685 *
686 * Caller has already opened and locked pg_attribute. tupdesc contains the
687 * attributes to insert. attcacheoff is always initialized to -1.
688 * tupdesc_extra supplies the values for certain variable-length/nullable
689 * pg_attribute fields and must contain the same number of elements as tupdesc
690 * or be NULL. The other variable-length fields of pg_attribute are always
691 * initialized to null values.
692 *
693 * indstate is the index state for CatalogTupleInsertWithInfo. It can be
694 * passed as NULL, in which case we'll fetch the necessary info. (Don't do
695 * this when inserting multiple attributes, because it's a tad more
696 * expensive.)
697 *
698 * new_rel_oid is the relation OID assigned to the attributes inserted.
699 * If set to InvalidOid, the relation OID from tupdesc is used instead.
700 */
701 void
703 TupleDesc tupdesc,
704 Oid new_rel_oid,
706 CatalogIndexState indstate)
707 {
709 TupleDesc td;
717 /* Initialize the number of slots to use */
725 {
736 else
737 slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(attrs->attrelid);
740 slot[slotCount]->tts_values[Anum_pg_attribute_atttypid - 1] = ObjectIdGetDatum(attrs->atttypid);
748 slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);
749 slot[slotCount]->tts_values[Anum_pg_attribute_attcompression - 1] = CharGetDatum(attrs->attcompression);
750 slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);
752 slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);
753 slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);
754 slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);
755 slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);
756 slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);
757 slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int16GetDatum(attrs->attinhcount);
758 slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);
760 {
761 slot[slotCount]->tts_values[Anum_pg_attribute_attstattarget - 1] = attrs_extra->attstattarget.value;
762 slot[slotCount]->tts_isnull[Anum_pg_attribute_attstattarget - 1] = attrs_extra->attstattarget.isnull;
766 }
767 else
768 {
771 }
773 /*
774 * The remaining fields are not set for new columns.
775 */
781 slotCount++;
783 /*
784 * If slots are full or the end of processing has been reached, insert
785 * a batch of tuples.
786 */
788 {
789 /* fetch index info only when we know we need it */
791 {
794 }
796 /* insert the new tuples and update the indexes */
798 indstate);
800 }
802 natts++;
803 }
810 }
812 /* --------------------------------
813 * AddNewAttributeTuples
814 *
815 * this registers the new relation's schema by adding
816 * tuples to pg_attribute.
817 * --------------------------------
818 */
819 static void
821 TupleDesc tupdesc,
823 {
824 Relation rel;
825 CatalogIndexState indstate;
827 ObjectAddress myself,
828 referenced;
830 /*
831 * open pg_attribute and its indexes.
832 */
839 /* add dependencies on their datatypes and collations */
841 {
842 /* Add dependency info */
848 /* The default collation is pinned, so don't bother recording it */
851 {
855 }
856 }
858 /*
859 * Next we add the system attributes. Skip all for a view or type
860 * relation. We don't bother with making datatype dependencies here,
861 * since presumably all these types are pinned.
862 */
864 {
865 TupleDesc td;
871 }
873 /*
874 * clean up
875 */
879 }
881 /* --------------------------------
882 * InsertPgClassTuple
883 *
884 * Construct and insert a new tuple in pg_class.
885 *
886 * Caller has already opened and locked pg_class.
887 * Tuple data is taken from new_rel_desc->rd_rel, except for the
888 * variable-width fields which are not present in a cached reldesc.
889 * relacl and reloptions are passed in Datum form (to avoid having
890 * to reference the data types in heap.h). Pass (Datum) 0 to set them
891 * to NULL.
892 * --------------------------------
893 */
894 void
896 Relation new_rel_desc,
897 Oid new_rel_oid,
898 Datum relacl,
899 Datum reloptions)
900 {
904 HeapTuple tup;
906 /* This is a tad tedious, but way cleaner than what we used to do... */
942 else
946 else
949 /* relpartbound is set by updating this tuple, if necessary */
954 /* finally insert the new tuple, update the indexes, and clean up */
958 }
960 /* --------------------------------
961 * AddNewRelationTuple
962 *
963 * this registers the new relation in the catalogs by
964 * adding a tuple to pg_class.
965 * --------------------------------
966 */
967 static void
969 Relation new_rel_desc,
970 Oid new_rel_oid,
971 Oid new_type_oid,
972 Oid reloftype,
973 Oid relowner,
975 TransactionId relfrozenxid,
976 TransactionId relminmxid,
977 Datum relacl,
978 Datum reloptions)
979 {
980 Form_pg_class new_rel_reltup;
982 /*
983 * first we update some of the information in our uncataloged relation's
984 * relation descriptor.
985 */
988 /* The relation is empty */
993 /* Sequences always have a known size */
995 {
998 }
1006 /* relispartition is always set by updating this tuple later */
1009 /* fill rd_att's type ID with something sane even if reltype is zero */
1013 /* Now build and insert the tuple */
1016 }
1019 /* --------------------------------
1020 * AddNewRelationType -
1021 *
1022 * define a composite type corresponding to the new relation
1023 * --------------------------------
1024 */
1025 static ObjectAddress
1027 Oid typeNamespace,
1028 Oid new_rel_oid,
1030 Oid ownerid,
1031 Oid new_row_type,
1032 Oid new_array_type)
1033 {
1034 return
1067 }
1069 /* --------------------------------
1070 * heap_create_with_catalog
1071 *
1072 * creates a new cataloged relation. see comments above.
1073 *
1074 * Arguments:
1075 * relname: name to give to new rel
1076 * relnamespace: OID of namespace it goes in
1077 * reltablespace: OID of tablespace it goes in
1078 * relid: OID to assign to new rel, or InvalidOid to select a new OID
1079 * reltypeid: OID to assign to rel's rowtype, or InvalidOid to select one
1080 * reloftypeid: if a typed table, OID of underlying type; else InvalidOid
1081 * ownerid: OID of new rel's owner
1082 * accessmtd: OID of new rel's access method
1083 * tupdesc: tuple descriptor (source of column definitions)
1084 * cooked_constraints: list of precooked check constraints and defaults
1085 * relkind: relkind for new rel
1086 * relpersistence: rel's persistence status (permanent, temp, or unlogged)
1087 * shared_relation: true if it's to be a shared relation
1088 * mapped_relation: true if the relation will use the relfilenumber map
1089 * oncommit: ON COMMIT marking (only relevant if it's a temp table)
1090 * reloptions: reloptions in Datum form, or (Datum) 0 if none
1091 * use_user_acl: true if should look for user-defined default permissions;
1092 * if false, relacl is always set NULL
1093 * allow_system_table_mods: true to allow creation in system namespaces
1094 * is_internal: is this a system-generated catalog?
1095 *
1096 * Output parameters:
1097 * typaddress: if not null, gets the object address of the new pg_type entry
1098 * (this must be null if the relkind is one that doesn't get a pg_type entry)
1099 *
1100 * Returns the OID of the new relation
1101 * --------------------------------
1102 */
1103 Oid
1105 Oid relnamespace,
1106 Oid reltablespace,
1107 Oid relid,
1108 Oid reltypeid,
1109 Oid reloftypeid,
1110 Oid ownerid,
1111 Oid accessmtd,
1112 TupleDesc tupdesc,
1118 OnCommitAction oncommit,
1119 Datum reloptions,
1123 Oid relrewrite,
1125 {
1126 Relation pg_class_desc;
1127 Relation new_rel_desc;
1129 Oid existing_relid;
1130 Oid old_type_oid;
1131 Oid new_type_oid;
1133 /* By default set to InvalidOid unless overridden by binary-upgrade */
1135 TransactionId relfrozenxid;
1136 MultiXactId relminmxid;
1140 /*
1141 * sanity checks
1142 */
1145 /*
1146 * Validate proposed tupdesc for the desired relkind. If
1147 * allow_system_table_mods is on, allow ANYARRAY to be used; this is a
1148 * hack to allow creating pg_statistic and cloning it during VACUUM FULL.
1149 */
1153 /*
1154 * This would fail later on anyway, if the relation already exists. But
1155 * by catching it here we can emit a nicer error message.
1156 */
1163 /*
1164 * Since we are going to create a rowtype as well, also check for
1165 * collision with an existing type name. If there is one and it's an
1166 * autogenerated array, we can rename it out of the way; otherwise we can
1167 * at least give a good error message.
1168 */
1173 {
1179 "so you must use a name that doesn't conflict "
1181 }
1183 /*
1184 * Shared relations must be in pg_global (last-ditch check)
1185 */
1189 /*
1190 * Allocate an OID for the relation, unless we were told what to use.
1191 *
1192 * The OID will be the relfilenumber as well, so make sure it doesn't
1193 * collide with either pg_class OIDs or existing physical files.
1194 */
1196 {
1197 /* Use binary-upgrade override for pg_class.oid and relfilenumber */
1199 {
1200 /*
1201 * Indexes are not supported here; they use
1202 * binary_upgrade_next_index_pg_class_oid.
1203 */
1208 {
1209 /* There might be no TOAST table, so we have to test for it. */
1211 {
1222 }
1223 }
1224 else
1225 {
1235 {
1243 }
1244 }
1245 }
1249 relpersistence);
1250 }
1252 /*
1253 * Determine the relation's initial permissions.
1254 */
1256 {
1258 {
1265 relnamespace);
1269 relnamespace);
1274 }
1275 }
1276 else
1279 /*
1280 * Create the relcache entry (mostly dummy at this point) and the physical
1281 * disk file. (If we fail further down, it's the smgr's responsibility to
1282 * remove the disk file again.)
1283 *
1284 * NB: Note that passing create_storage = true is correct even for binary
1285 * upgrade. The storage we create here will be replaced later, but we
1286 * need to have something on disk in the meanwhile.
1287 */
1289 relnamespace,
1290 reltablespace,
1291 relid,
1292 relfilenumber,
1293 accessmtd,
1294 tupdesc,
1295 relkind,
1296 relpersistence,
1297 shared_relation,
1298 mapped_relation,
1299 allow_system_table_mods,
1308 /*
1309 * Decide whether to create a pg_type entry for the relation's rowtype.
1310 * These types are made except where the use of a relation as such is an
1311 * implementation detail: toast tables, sequences and indexes.
1312 */
1317 {
1318 Oid new_array_oid;
1319 ObjectAddress new_type_addr;
1322 /*
1323 * We'll make an array over the composite type, too. For largely
1324 * historical reasons, the array type's OID is assigned first.
1325 */
1328 /*
1329 * Make the pg_type entry for the composite type. The OID of the
1330 * composite type can be preselected by the caller, but if reltypeid
1331 * is InvalidOid, we'll generate a new OID for it.
1332 *
1333 * NOTE: we could get a unique-index failure here, in case someone
1334 * else is creating the same type name in parallel but hadn't
1335 * committed yet when we checked for a duplicate name above.
1336 */
1338 relnamespace,
1339 relid,
1340 relkind,
1341 ownerid,
1342 reltypeid,
1343 new_array_oid);
1348 /* Now create the array type. */
1385 }
1386 else
1387 {
1388 /* Caller should not be expecting a type to be created. */
1393 }
1395 /*
1396 * now create an entry in pg_class for the relation.
1397 *
1398 * NOTE: we could get a unique-index failure here, in case someone else is
1399 * creating the same relation name in parallel but hadn't committed yet
1400 * when we checked for a duplicate name above.
1401 */
1403 new_rel_desc,
1404 relid,
1405 new_type_oid,
1406 reloftypeid,
1407 ownerid,
1408 relkind,
1409 relfrozenxid,
1410 relminmxid,
1412 reloptions);
1414 /*
1415 * now add tuples to pg_attribute for the attributes in our new relation.
1416 */
1419 /*
1420 * Make a dependency link to force the relation to be deleted if its
1421 * namespace is. Also make a dependency link to its owner, as well as
1422 * dependencies for any roles mentioned in the default ACL.
1423 *
1424 * For composite types, these dependencies are tracked for the pg_type
1425 * entry, so we needn't record them here. Likewise, TOAST tables don't
1426 * need a namespace dependency (they live in a pinned namespace) nor an
1427 * owner dependency (they depend indirectly through the parent table), nor
1428 * should they have any ACL entries. The same applies for extension
1429 * dependencies.
1430 *
1431 * Also, skip this in bootstrap mode, since we don't make dependencies
1432 * while bootstrapping.
1433 */
1437 {
1438 ObjectAddress myself,
1439 referenced;
1456 {
1459 }
1461 /*
1462 * Make a dependency link to force the relation to be deleted if its
1463 * access method is.
1464 *
1465 * No need to add an explicit dependency for the toast table, as the
1466 * main table depends on it.
1467 */
1469 {
1472 }
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;
1667 /*
1668 * Grab an exclusive lock on the target table, which we will NOT release
1669 * until end of transaction. (In the simple case where we are directly
1670 * dropping this column, ATExecDropColumn already did this ... but when
1671 * cascading from a drop of some other object, we may not have any lock.)
1672 */
1685 /* Mark the attribute as dropped */
1688 /*
1689 * Set the type OID to invalid. A dropped attribute's type link cannot be
1690 * relied on (once the attribute is dropped, the type might be too).
1691 * Fortunately we do not need the type row --- the only really essential
1692 * information is the type's typlen and typalign, which are preserved in
1693 * the attribute's attlen and attalign. We set atttypid to zero here as a
1694 * means of catching code that incorrectly expects it to be valid.
1695 */
1698 /* Remove any not-null constraint the column may have */
1701 /* Unset this so no one tries to look up the generation expression */
1704 /*
1705 * Change the column name to something that isn't likely to conflict
1706 */
1711 /* Clear the missing value */
1716 /*
1717 * Clear the other nullable fields. This saves some space in pg_attribute
1718 * and removes no longer useful information.
1719 */
1734 /*
1735 * Because updating the pg_attribute row will trigger a relcache flush for
1736 * the target relation, we need not do anything else to notify other
1737 * backends of the change.
1738 */
1745 }
1747 /*
1748 * heap_drop_with_catalog - removes specified relation from catalogs
1749 *
1750 * Note that this routine is not responsible for dropping objects that are
1751 * linked to the pg_class entry via dependencies (for example, indexes and
1752 * constraints). Those are deleted by the dependency-tracing logic in
1753 * dependency.c before control gets here. In general, therefore, this routine
1754 * should never be called directly; go through performDeletion() instead.
1755 */
1756 void
1758 {
1759 Relation rel;
1760 HeapTuple tuple;
1764 /*
1765 * To drop a partition safely, we must grab exclusive lock on its parent,
1766 * because another backend might be about to execute a query on the parent
1767 * table. If it relies on previously cached partition descriptor, then it
1768 * could attempt to access the just-dropped relation as its partition. We
1769 * must therefore take a table lock strong enough to prevent all queries
1770 * on the table from proceeding until we commit and send out a
1771 * shared-cache-inval notice that will make them update their partition
1772 * descriptors.
1773 */
1778 {
1779 /*
1780 * We have to lock the parent if the partition is being detached,
1781 * because it's possible that some query still has a partition
1782 * descriptor that includes this partition.
1783 */
1787 /*
1788 * If this is not the default partition, dropping it will change the
1789 * default partition's partition constraint, so we must lock it.
1790 */
1794 }
1798 /*
1799 * Open and lock the relation.
1800 */
1803 /*
1804 * There can no longer be anyone *else* touching the relation, but we
1805 * might still have open queries or cursors, or pending trigger events, in
1806 * our own session.
1807 */
1810 /*
1811 * This effectively deletes all rows in the table, and may be done in a
1812 * serializable transaction. In that case we must record a rw-conflict in
1813 * to this transaction from each transaction holding a predicate lock on
1814 * the table.
1815 */
1818 /*
1819 * Delete pg_foreign_table tuple first.
1820 */
1822 {
1823 Relation ftrel;
1824 HeapTuple fttuple;
1836 }
1838 /*
1839 * If a partitioned table, delete the pg_partitioned_table tuple.
1840 */
1844 /*
1845 * If the relation being dropped is the default partition itself,
1846 * invalidate its entry in pg_partitioned_table.
1847 */
1851 /*
1852 * Schedule unlinking of the relation's physical files at commit.
1853 */
1857 /* ensure that stats are dropped if transaction commits */
1860 /*
1861 * Close relcache entry, but *keep* AccessExclusiveLock on the relation
1862 * until transaction commit. This ensures no one else will try to do
1863 * something with the doomed relation.
1864 */
1867 /*
1868 * Remove any associated relation synchronization states.
1869 */
1872 /*
1873 * Forget any ON COMMIT action for the rel
1874 */
1877 /*
1878 * Flush the relation from the relcache. We want to do this before
1879 * starting to remove catalog entries, just to be certain that no relcache
1880 * entry rebuild will happen partway through. (That should not really
1881 * matter, since we don't do CommandCounterIncrement here, but let's be
1882 * safe.)
1883 */
1886 /*
1887 * remove inheritance information
1888 */
1891 /*
1892 * delete statistics
1893 */
1896 /*
1897 * delete attribute tuples
1898 */
1901 /*
1902 * delete relation tuple
1903 */
1907 {
1908 /*
1909 * If this is not the default partition, the partition constraint of
1910 * the default partition has changed to include the portion of the key
1911 * space previously covered by the dropped partition.
1912 */
1916 /*
1917 * Invalidate the parent's relcache so that the partition is no longer
1918 * included in its partition descriptor.
1919 */
1921 /* keep the lock */
1922 }
1923 }
1926 /*
1927 * RelationClearMissing
1928 *
1929 * Set atthasmissing and attmissingval to false/null for all attributes
1930 * where they are currently set. This can be safely and usefully done if
1931 * the table is rewritten (e.g. by VACUUM FULL or CLUSTER) where we know there
1932 * are no rows left with less than a full complement of attributes.
1933 *
1934 * The caller must have an AccessExclusive lock on the relation.
1935 */
1936 void
1938 {
1939 Relation attr_rel;
1946 Form_pg_attribute attrtuple;
1947 HeapTuple tuple,
1948 newtuple;
1961 /* Get a lock on pg_attribute */
1964 /* process each non-system attribute, including any dropped columns */
1966 {
1976 /* ignore any where atthasmissing is not true */
1978 {
1985 }
1988 }
1990 /*
1991 * Our update of the pg_attribute rows will force a relcache rebuild, so
1992 * there's nothing else to do here.
1993 */
1995 }
1997 /*
1998 * SetAttrMissing
1999 *
2000 * Set the missing value of a single attribute. This should only be used by
2001 * binary upgrade. Takes an AccessExclusive lock on the relation owning the
2002 * attribute.
2003 */
2004 void
2006 {
2010 Datum missingval;
2011 Form_pg_attribute attStruct;
2012 Relation attrrel,
2013 tablerel;
2014 HeapTuple atttup,
2015 newtup;
2017 /* lock the table the attribute belongs to */
2020 /* Don't do anything unless it's a plain table */
2022 {
2025 }
2027 /* Lock the attribute row and get the data */
2035 /* get an array value from the value string */
2041 /* update the tuple - set atthasmissing and attmissingval */
2051 /* clean up */
2055 }
2057 /*
2058 * Store a check-constraint expression for the given relation.
2059 *
2060 * Caller is responsible for updating the count of constraints
2061 * in the pg_class entry for the relation.
2062 *
2063 * The OID of the new constraint is returned.
2064 */
2065 static Oid
2069 {
2074 Oid constrOid;
2076 /*
2077 * Flatten expression to string form for storage.
2078 */
2081 /*
2082 * Find columns of rel that are used in expr
2083 *
2084 * NB: pull_var_clause is okay here only because we don't allow subselects
2085 * in check constraints; it would fail to examine the contents of
2086 * subselects.
2087 */
2092 {
2098 {
2107 }
2109 }
2110 else
2113 /*
2114 * Partitioned tables do not contain any rows themselves, so a NO INHERIT
2115 * constraint makes no sense.
2116 */
2124 /*
2125 * Create the Check Constraint
2126 */
2127 constrOid =
2133 is_validated,
2142 NULL,
2143 NULL,
2144 NULL,
2145 NULL,
2149 NULL,
2164 }
2166 /*
2167 * Store a not-null constraint for the given relation
2168 *
2169 * The OID of the new constraint is returned.
2170 */
2171 static Oid
2175 {
2176 Oid constrOid;
2178 constrOid =
2181 CONSTRAINT_NOTNULL,
2184 is_validated,
2185 InvalidOid,
2193 NULL,
2194 NULL,
2195 NULL,
2196 NULL,
2200 NULL,
2204 NULL,
2205 NULL,
2206 is_local,
2207 inhcount,
2208 is_no_inherit,
2212 }
2214 /*
2215 * Store defaults and constraints (passed as a list of CookedConstraint).
2216 *
2217 * Each CookedConstraint struct is modified to store the new catalog tuple OID.
2218 *
2219 * NOTE: only pre-cooked expressions will be passed this way, which is to
2220 * say expressions inherited from an existing relation. Newly parsed
2221 * expressions can be added later, by direct calls to StoreAttrDefault
2222 * and StoreRelCheck (see AddRelationNewConstraints()).
2223 */
2224 static void
2226 {
2233 /*
2234 * Deparsing of constraint expressions will fail unless the just-created
2235 * pg_attribute tuples for this relation are made visible. So, bump the
2236 * command counter. CAUTION: this will cause a relcache entry rebuild.
2237 */
2241 {
2245 {
2255 is_internal);
2256 numchecks++;
2269 }
2270 }
2274 }
2276 /*
2277 * AddRelationNewConstraints
2278 *
2279 * Add new column default expressions and/or constraint check expressions
2280 * to an existing relation. This is defined to do both for efficiency in
2281 * DefineRelation, but of course you can do just one or the other by passing
2282 * empty lists.
2283 *
2284 * rel: relation to be modified
2285 * newColDefaults: list of RawColumnDefault structures
2286 * newConstraints: list of Constraint nodes
2287 * allow_merge: true if check constraints may be merged with existing ones
2288 * is_local: true if definition is local, false if it's inherited
2289 * is_internal: true if result of some internal process, not a user request
2290 * queryString: used during expression transformation of default values and
2291 * cooked CHECK constraints
2292 *
2293 * All entries in newColDefaults will be processed. Entries in newConstraints
2294 * will be processed only if they are CONSTR_CHECK type.
2295 *
2296 * Returns a list of CookedConstraint nodes that shows the cooked form of
2297 * the default and constraint expressions added to the relation.
2298 *
2299 * NB: caller should have opened rel with some self-conflicting lock mode,
2300 * and should hold that lock till end of transaction; for normal cases that'll
2301 * be AccessExclusiveLock, but if caller knows that the constraint is already
2302 * enforced by some other means, it can be ShareUpdateExclusiveLock. Also, we
2303 * assume the caller has done a CommandCounterIncrement if necessary to make
2304 * the relation's catalog tuples visible.
2305 */
2306 List *
2314 {
2316 TupleDesc tupleDesc;
2328 /*
2329 * Get info about existing constraints.
2330 */
2335 else
2338 /*
2339 * Create a dummy ParseState and insert the target relation as its sole
2340 * rangetable entry. We need a ParseState for transformExpr.
2341 */
2345 rel,
2346 AccessShareLock,
2347 NULL,
2352 /*
2353 * Process column default expressions.
2354 */
2356 {
2359 Oid defOid;
2366 /*
2367 * If the expression is just a NULL constant, we do not bother to make
2368 * an explicit pg_attrdef entry, since the default behavior is
2369 * equivalent. This applies to column defaults, but not for
2370 * generation expressions.
2371 *
2372 * Note a nonobvious property of this test: if the column is of a
2373 * domain type, what we'll get is not a bare null Const but a
2374 * CoerceToDomain expr, so we will not discard the default. This is
2375 * critical because the column default needs to be retained to
2376 * override any default that the domain might have.
2377 */
2384 /* If the DEFAULT is volatile we cannot use a missing value */
2403 }
2405 /*
2406 * Process constraint expressions.
2407 */
2412 {
2414 Oid constrOid;
2417 {
2421 {
2424 /*
2425 * Transform raw parsetree to executable expression, and
2426 * verify it's valid as a CHECK constraint.
2427 */
2430 }
2431 else
2432 {
2435 /*
2436 * Here, we assume the parser will only pass us valid CHECK
2437 * expressions, so we do no particular checking.
2438 */
2440 }
2442 /*
2443 * Check name uniqueness, or generate a name if none was given.
2444 */
2446 {
2450 /* Check against other new constraints */
2451 /* Needed because we don't do CommandCounterIncrement in loop */
2453 {
2458 ccname)));
2459 }
2461 /* save name for future checks */
2464 /*
2465 * Check against pre-existing constraints. If we are allowed
2466 * to merge with an existing constraint, there's no more to do
2467 * here. (We omit the duplicate constraint from the result,
2468 * which is what ATAddCheckConstraint wants.)
2469 */
2475 }
2476 else
2477 {
2478 /*
2479 * When generating a name, we want to create "tab_col_check"
2480 * for a column constraint and "tab_check" for a table
2481 * constraint. We no longer have any info about the syntactic
2482 * positioning of the constraint phrase, so we approximate
2483 * this by seeing whether the expression references more than
2484 * one column. (If the user played by the rules, the result
2485 * is the same...)
2486 *
2487 * Note: pull_var_clause() doesn't descend into sublinks, but
2488 * we eliminated those above; and anyway this only needs to be
2489 * an approximate answer.
2490 */
2496 /* eliminate duplicates */
2503 else
2507 colname,
2510 checknames);
2512 /* save name for future checks */
2514 }
2516 /*
2517 * OK, store it.
2518 */
2519 constrOid =
2523 numchecks++;
2536 }
2538 {
2540 AttrNumber colnum;
2544 /* Determine which column to modify */
2550 /*
2551 * If the column already has an inheritable not-null constraint,
2552 * we need only adjust its inheritance status and we're done. If
2553 * the constraint is there but marked NO INHERIT, then it is
2554 * updated in the same way, but we also recurse to the children
2555 * (if any) to add the constraint there as well.
2556 */
2562 {
2567 {
2571 NIL,
2573 allow_merge,
2574 is_local,
2575 is_internal,
2576 queryString);
2577 /* these constraints are not in the return list -- good? */
2580 }
2583 }
2585 /*
2586 * If a constraint name is specified, check that it isn't already
2587 * used. Otherwise, choose a non-conflicting one ourselves.
2588 */
2590 {
2599 }
2600 else
2605 nnnames);
2608 constrOid =
2627 }
2628 }
2630 /*
2631 * Update the count of constraints in the relation's pg_class tuple. We do
2632 * this even if there was no change, in order to ensure that an SI update
2633 * message is sent out for the pg_class tuple, which will force other
2634 * backends to rebuild their relcache entries for the rel. (This is
2635 * critical if we added defaults but not constraints.)
2636 */
2640 }
2642 /*
2643 * Check for a pre-existing check constraint that conflicts with a proposed
2644 * new one, and either adjust its conislocal/coninhcount settings or throw
2645 * error as needed.
2646 *
2647 * Returns true if merged (constraint is a duplicate), or false if it's
2648 * got a so-far-unique name, or throws error if conflict.
2649 *
2650 * XXX See MergeConstraintsIntoExisting too if you change this code.
2651 */
2652 static bool
2657 {
2659 Relation conDesc;
2660 SysScanDesc conscan;
2662 HeapTuple tup;
2664 /* Search for a pg_constraint entry with same name and relation */
2670 Anum_pg_constraint_conrelid,
2674 Anum_pg_constraint_contypid,
2678 Anum_pg_constraint_conname,
2685 /* There can be at most one matching row */
2687 {
2690 /* Found it. Conflicts if not identical check constraint */
2692 {
2693 Datum val;
2697 Anum_pg_constraint_conbin,
2704 }
2706 /*
2707 * If the existing constraint is purely inherited (no local
2708 * definition) then interpret addition of a local constraint as a
2709 * legal merge. This allows ALTER ADD CONSTRAINT on parent and child
2710 * tables to be given in either order with same end state. However if
2711 * the relation is a partition, all inherited constraints are always
2712 * non-local, including those that were merged.
2713 */
2723 /* If the child constraint is "no inherit" then cannot merge */
2730 /*
2731 * Must not change an existing inherited constraint to "no inherit"
2732 * status. That's because inherited constraints should be able to
2733 * propagate to lower-level children.
2734 */
2741 /*
2742 * If the child constraint is "not valid" then cannot merge with a
2743 * valid parent constraint.
2744 */
2751 /* OK to update the tuple */
2754 ccname)));
2759 /*
2760 * In case of partitions, an inherited constraint must be inherited
2761 * only once since it cannot have multiple parents and it is never
2762 * considered local.
2763 */
2765 {
2768 }
2769 else
2770 {
2773 else
2780 }
2783 {
2786 }
2789 }
2795 }
2797 /* list_sort comparator to sort CookedConstraint by attnum */
2798 static int
2800 {
2805 }
2807 /*
2808 * Create the not-null constraints when creating a new relation
2809 *
2810 * These come from two sources: the 'constraints' list (of Constraint) is
2811 * specified directly by the user; the 'old_notnulls' list (of
2812 * CookedConstraint) comes from inheritance. We create one constraint
2813 * for each column, giving priority to user-specified ones, and setting
2814 * inhcount according to how many parents cause each column to get a
2815 * not-null constraint. If a user-specified name clashes with another
2816 * user-specified name, an error is raised.
2817 *
2818 * Note that inherited constraints have two shapes: those coming from another
2819 * not-null constraint in the parent, which have a name already, and those
2820 * coming from a primary key in the parent, which don't. Any name specified
2821 * in a parent is disregarded in case of a conflict.
2822 *
2823 * Returns a list of AttrNumber for columns that need to have the attnotnull
2824 * flag set.
2825 */
2826 List *
2829 {
2835 /*
2836 * We track two lists of names: nnnames keeps all the constraint names,
2837 * givennames tracks user-generated names. The distinction is important,
2838 * because we must raise error for user-generated name conflicts, but for
2839 * system-generated name conflicts we just generate another.
2840 */
2844 /*
2845 * First, create all not-null constraints that are directly specified by
2846 * the user. Note that inheritance might have given us another source for
2847 * each, so we must scan the old_notnulls list and increment inhcount for
2848 * each element with identical attnum. We delete from there any element
2849 * that we process.
2850 */
2852 {
2854 AttrNumber attnum;
2865 /*
2866 * Search in the list of inherited constraints for any entries on the
2867 * same column.
2868 */
2870 {
2874 {
2875 /*
2876 * If we get a constraint from the parent, having a local NO
2877 * INHERIT one doesn't work.
2878 */
2886 inhcount++;
2888 }
2889 }
2891 /*
2892 * Determine a constraint name, which may have been specified by the
2893 * user, or raise an error if a conflict exists with another
2894 * user-specified name.
2895 */
2897 {
2899 {
2906 }
2910 }
2911 else
2917 nnnames);
2925 }
2927 /*
2928 * If any column remains in the old_notnulls list, we must create a not-
2929 * null constraint marked not-local. Because multiple parents could
2930 * specify a not-null constraint for the same column, we must count how
2931 * many there are and add to the original inhcount accordingly, deleting
2932 * elements we've already processed. We sort the list to make it easy.
2933 *
2934 * We don't use foreach() here because we have two nested loops over the
2935 * constraint list, with possible element deletions in the inner one. If
2936 * we used foreach_delete_current() it could only fix up the state of one
2937 * of the loops, so it seems cleaner to use looping over list indexes for
2938 * both loops. Note that any deletion will happen beyond where the outer
2939 * loop is, so its index never needs adjustment.
2940 */
2943 {
2952 /*
2953 * Preserve the first non-conflicting constraint name we come across,
2954 * if any
2955 */
2960 {
2965 {
2969 add_inhcount++;
2971 }
2972 else
2973 restpos++;
2974 }
2976 /* If we got a name, make sure it isn't one we've already used */
2978 {
2980 {
2982 {
2985 }
2986 }
2987 }
2989 /* and choose a name, if needed */
2996 nnnames);
3004 }
3007 }
3009 /*
3010 * Update the count of constraints in the relation's pg_class tuple.
3011 *
3012 * Caller had better hold exclusive lock on the relation.
3013 *
3014 * An important side effect is that a SI update message will be sent out for
3015 * the pg_class tuple, which will force other backends to rebuild their
3016 * relcache entries for the rel. Also, this backend will rebuild its
3017 * own relcache entry at the next CommandCounterIncrement.
3018 */
3019 static void
3021 {
3022 Relation relrel;
3023 HeapTuple reltup;
3024 Form_pg_class relStruct;
3035 {
3039 }
3040 else
3041 {
3042 /* Skip the disk update, but force relcache inval anyway */
3044 }
3048 }
3050 /*
3051 * Check for references to generated columns
3052 */
3053 static bool
3055 {
3061 {
3063 Oid relid;
3064 AttrNumber attnum;
3079 /* A whole-row Var is necessarily self-referential, so forbid it */
3086 /* System columns were already checked in the parser */
3089 }
3090 else
3093 }
3095 static void
3097 {
3099 }
3101 /*
3102 * Take a raw default and convert it to a cooked format ready for
3103 * storage.
3104 *
3105 * Parse state should be set up to recognize any vars that might appear
3106 * in the expression. (Even though we plan to reject vars, it's more
3107 * user-friendly to give the correct error message than "unknown var".)
3108 *
3109 * If atttypid is not InvalidOid, coerce the expression to the specified
3110 * type (and typmod atttypmod). attname is only needed in this case:
3111 * it is used in the error message, if any.
3112 */
3113 Node *
3116 Oid atttypid,
3117 int32 atttypmod,
3120 {
3125 /*
3126 * Transform raw parsetree to executable expression.
3127 */
3128 expr = transformExpr(pstate, raw_default, attgenerated ? EXPR_KIND_GENERATED_COLUMN : EXPR_KIND_COLUMN_DEFAULT);
3131 {
3132 /* Disallow refs to other generated columns */
3135 /* Disallow mutable functions */
3140 }
3141 else
3142 {
3143 /*
3144 * For a default expression, transformExpr() should have rejected
3145 * column references.
3146 */
3148 }
3150 /*
3151 * Coerce the expression to the correct type and typmod, if given. This
3152 * should match the parser's processing of non-defaulted expressions ---
3153 * see transformAssignedExpr().
3154 */
3156 {
3161 COERCION_ASSIGNMENT,
3162 COERCE_IMPLICIT_CAST,
3169 attname,
3173 }
3175 /*
3176 * Finally, take care of collations in the finished expression.
3177 */
3181 }
3183 /*
3184 * Take a raw CHECK constraint expression and convert it to a cooked format
3185 * ready for storage.
3186 *
3187 * Parse state must be set up to recognize any vars that might appear
3188 * in the expression.
3189 */
3194 {
3197 /*
3198 * Transform raw parsetree to executable expression.
3199 */
3202 /*
3203 * Make sure it yields a boolean result.
3204 */
3207 /*
3208 * Take care of collations.
3209 */
3212 /*
3213 * Make sure no outside relations are referred to (this is probably dead
3214 * code now that add_missing_from is history).
3215 */
3220 relname)));
3223 }
3225 /*
3226 * CopyStatistics --- copy entries in pg_statistic from one rel to another
3227 */
3228 void
3230 {
3231 HeapTuple tup;
3232 SysScanDesc scan;
3234 Relation statrel;
3239 /* Now search for stat records */
3241 Anum_pg_statistic_starelid,
3249 {
3250 Form_pg_statistic statform;
3252 /* make a modifiable copy */
3256 /* update the copy of the tuple and insert it */
3259 /* fetch index information when we know we need it */
3266 }
3273 }
3275 /*
3276 * RemoveStatistics --- remove entries in pg_statistic for a rel or column
3277 *
3278 * If attnum is zero, remove all entries for rel; else remove only the one(s)
3279 * for that column.
3280 */
3281 void
3283 {
3284 Relation pgstatistic;
3285 SysScanDesc scan;
3288 HeapTuple tuple;
3293 Anum_pg_statistic_starelid,
3299 else
3300 {
3302 Anum_pg_statistic_staattnum,
3306 }
3311 /* we must loop even when attnum != 0, in case of inherited stats */
3318 }
3321 /*
3322 * RelationTruncateIndexes - truncate all indexes associated
3323 * with the heap relation to zero tuples.
3324 *
3325 * The routine will truncate and then reconstruct the indexes on
3326 * the specified relation. Caller must hold exclusive lock on rel.
3327 */
3328 static void
3330 {
3333 /* Ask the relcache to produce a list of the indexes of the rel */
3335 {
3337 Relation currentIndex;
3340 /* Open the index relation; use exclusive lock, just to be sure */
3343 /*
3344 * Fetch info needed for index_build. Since we know there are no
3345 * tuples that actually need indexing, we can use a dummy IndexInfo.
3346 * This is slightly cheaper to build, but the real point is to avoid
3347 * possibly running user-defined code in index expressions or
3348 * predicates. We might be getting invoked during ON COMMIT
3349 * processing, and we don't want to run any such code then.
3350 */
3353 /*
3354 * Now truncate the actual file (and discard buffers).
3355 */
3358 /* Initialize the index and rebuild */
3359 /* Note: we do not need to re-establish pkey setting */
3362 /* We're done with this index */
3364 }
3365 }
3367 /*
3368 * heap_truncate
3369 *
3370 * This routine deletes all data within all the specified relations.
3371 *
3372 * This is not transaction-safe! There is another, transaction-safe
3373 * implementation in commands/tablecmds.c. We now use this only for
3374 * ON COMMIT truncation of temporary tables, where it doesn't matter.
3375 */
3376 void
3378 {
3382 /* Open relations for processing, and grab exclusive access on each */
3384 {
3386 Relation rel;
3390 }
3392 /* Don't allow truncate on tables that are referenced by foreign keys */
3395 /* OK to do it */
3397 {
3400 /* Truncate the relation */
3403 /* Close the relation, but keep exclusive lock on it until commit */
3405 }
3406 }
3408 /*
3409 * heap_truncate_one_rel
3410 *
3411 * This routine deletes all data within the specified relation.
3412 *
3413 * This is not transaction-safe, because the truncation is done immediately
3414 * and cannot be rolled back later. Caller is responsible for having
3415 * checked permissions etc, and must have obtained AccessExclusiveLock.
3416 */
3417 void
3419 {
3420 Oid toastrelid;
3422 /*
3423 * Truncate the relation. Partitioned tables have no storage, so there is
3424 * nothing to do for them here.
3425 */
3429 /* Truncate the underlying relation */
3432 /* If the relation has indexes, truncate the indexes too */
3435 /* If there is a toast table, truncate that too */
3438 {
3443 /* keep the lock... */
3445 }
3446 }
3448 /*
3449 * heap_truncate_check_FKs
3450 * Check for foreign keys referencing a list of relations that
3451 * are to be truncated, and raise error if there are any
3452 *
3453 * We disallow such FKs (except self-referential ones) since the whole point
3454 * of TRUNCATE is to not scan the individual rows to be thrown away.
3455 *
3456 * This is split out so it can be shared by both implementations of truncate.
3457 * Caller should already hold a suitable lock on the relations.
3458 *
3459 * tempTables is only used to select an appropriate error message.
3460 */
3461 void
3463 {
3468 /*
3469 * Build a list of OIDs of the interesting relations.
3470 *
3471 * If a relation has no triggers, then it can neither have FKs nor be
3472 * referenced by a FK from another table, so we can ignore it. For
3473 * partitioned tables, FKs have no triggers, so we must include them
3474 * anyway.
3475 */
3477 {
3483 }
3485 /*
3486 * Fast path: if no relation has triggers, none has FKs either.
3487 */
3491 /*
3492 * Otherwise, must scan pg_constraint. We make one pass with all the
3493 * relations considered; if this finds nothing, then all is well.
3494 */
3499 /*
3500 * Otherwise we repeat the scan once per relation to identify a particular
3501 * pair of relations to complain about. This is pretty slow, but
3502 * performance shouldn't matter much in a failure path. The reason for
3503 * doing things this way is to ensure that the message produced is not
3504 * dependent on chance row locations within pg_constraint.
3505 */
3507 {
3514 {
3518 {
3528 else
3536 relname2)));
3537 }
3538 }
3539 }
3540 }
3542 /*
3543 * heap_truncate_find_FKs
3544 * Find relations having foreign keys referencing any of the given rels
3545 *
3546 * Input and result are both lists of relation OIDs. The result contains
3547 * no duplicates, does *not* include any rels that were already in the input
3548 * list, and is sorted in OID order. (The last property is enforced mainly
3549 * to guarantee consistent behavior in the regression tests; we don't want
3550 * behavior to change depending on chance locations of rows in pg_constraint.)
3551 *
3552 * Note: caller should already have appropriate lock on all rels mentioned
3553 * in relationIds. Since adding or dropping an FK requires exclusive lock
3554 * on both rels, this ensures that the answer will be stable.
3555 */
3556 List *
3558 {
3563 ScanKeyData key;
3564 Relation fkeyRel;
3565 SysScanDesc fkeyScan;
3566 HeapTuple tuple;
3571 /*
3572 * Must scan pg_constraint. Right now, it is a seqscan because there is
3573 * no available index on confrelid.
3574 */
3577 restart:
3585 {
3588 /* Not a foreign key */
3592 /* Not referencing one of our list of tables */
3596 /*
3597 * If this constraint has a parent constraint which we have not seen
3598 * yet, keep track of it for the second loop, below. Tracking parent
3599 * constraints allows us to climb up to the top-level constraint and
3600 * look for all possible relations referencing the partitioned table.
3601 */
3606 /*
3607 * Add referencer to result, unless present in input list. (Don't
3608 * worry about dupes: we'll fix that below).
3609 */
3612 }
3616 /*
3617 * Process each parent constraint we found to add the list of referenced
3618 * relations by them to the oids list. If we do add any new such
3619 * relations, redo the first loop above. Also, if we see that the parent
3620 * constraint in turn has a parent, add that so that we process all
3621 * relations in a single additional pass.
3622 */
3624 {
3628 Anum_pg_constraint_oid,
3637 {
3640 /*
3641 * pg_constraint rows always appear for partitioned hierarchies
3642 * this way: on the each side of the constraint, one row appears
3643 * for each partition that points to the top-most table on the
3644 * other side.
3645 *
3646 * Because of this arrangement, we can correctly catch all
3647 * relevant relations by adding to 'parent_cons' all rows with
3648 * valid conparentid, and to the 'oids' list all rows with a zero
3649 * conparentid. If any oids are added to 'oids', redo the first
3650 * loop above by setting 'restart'.
3651 */
3656 {
3659 }
3660 }
3663 }
3672 /* Now sort and de-duplicate the result list */
3677 }
3679 /*
3680 * StorePartitionKey
3681 * Store information about the partition key rel into the catalog
3682 */
3683 void
3686 int16 partnatts,
3691 {
3696 Datum partexprDatum;
3697 Relation pg_partitioned_table;
3698 HeapTuple tuple;
3701 ObjectAddress myself;
3702 ObjectAddress referenced;
3707 /* Copy the partition attribute numbers, opclass OIDs into arrays */
3712 /* Convert the expressions (if any) to a text datum */
3714 {
3720 }
3721 else
3726 /* Only this can ever be NULL */
3744 /* Mark this relation as dependent on a few things as follows */
3748 /* Operator class and collation per key column */
3750 {
3754 /* The default collation is pinned, so don't bother recording it */
3757 {
3760 }
3761 }
3766 /*
3767 * The partitioning columns are made internally dependent on the table,
3768 * because we cannot drop any of them without dropping the whole table.
3769 * (ATExecDropColumn independently enforces that, but it's not bulletproof
3770 * so we need the dependencies too.)
3771 */
3773 {
3780 }
3782 /*
3783 * Also consider anything mentioned in partition expressions. External
3784 * references (e.g. functions) get NORMAL dependencies. Table columns
3785 * mentioned in the expressions are handled the same as plain partitioning
3786 * columns, i.e. they become internally dependent on the whole table.
3787 */
3792 DEPENDENCY_NORMAL,
3793 DEPENDENCY_INTERNAL,
3796 /*
3797 * We must invalidate the relcache so that the next
3798 * CommandCounterIncrement() will cause the same to be rebuilt using the
3799 * information in just created catalog entry.
3800 */
3802 }
3804 /*
3805 * RemovePartitionKeyByRelId
3806 * Remove pg_partitioned_table entry for a relation
3807 */
3808 void
3810 {
3811 Relation rel;
3812 HeapTuple tuple;
3819 relid);
3825 }
3827 /*
3828 * StorePartitionBound
3829 * Update pg_class tuple of rel to store the partition bound and set
3830 * relispartition to true
3831 *
3832 * If this is the default partition, also update the default partition OID in
3833 * pg_partitioned_table.
3834 *
3835 * Also, invalidate the parent's relcache, so that the next rebuild will load
3836 * the new partition's info into its partition descriptor. If there is a
3837 * default partition, we must invalidate its relcache entry as well.
3838 */
3839 void
3841 {
3842 Relation classRel;
3843 HeapTuple tuple,
3844 newtuple;
3848 Oid defaultPartOid;
3850 /* Update pg_class tuple */
3858 #ifdef USE_ASSERT_CHECKING
3859 {
3860 Form_pg_class classForm;
3868 }
3869 #endif
3871 /* Fill in relpartbound value */
3880 /* Also set the flag */
3886 /*
3887 * If we're storing bounds for the default partition, update
3888 * pg_partitioned_table too.
3889 */
3894 /* Make these updates visible */
3897 /*
3898 * The partition constraint for the default partition depends on the
3899 * partition bounds of every other partition, so we must invalidate the
3900 * relcache entry for that partition every time a partition is added or
3901 * removed.
3902 */
3903 defaultPartOid =
3909 }