| blob | 0ea8226286595aa00de2ee326598781a93ac40fc |
1 /*-------------------------------------------------------------------------
2 *
3 * typecmds.c
4 * Routines for SQL commands that manipulate types (and domains).
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/commands/typecmds.c
12 *
13 * DESCRIPTION
14 * The "DefineFoo" routines take the parse tree and pick out the
15 * appropriate arguments/flags, passing the results to the
16 * corresponding "FooCreate" routines (in src/backend/catalog) that do
17 * the actual catalog-munging. These routines also verify permission
18 * of the user to execute the command.
19 *
20 * NOTES
21 * These things must be defined and committed in the following order:
22 * "create function":
23 * input/output, recv/send functions
24 * "create type":
25 * type
26 * "create operator":
27 * operators
28 *
29 *
30 *-------------------------------------------------------------------------
31 */
78 /* result structure for get_rels_with_domain() */
80 {
84 /* atts[] is of allocated length RelationGetNumberOfAttributes(rel) */
87 /* parameter structure for AlterTypeRecurse() */
89 {
90 /* Flags indicating which type attributes to update */
98 /* New values for relevant attributes */
100 Oid receiveOid;
101 Oid sendOid;
102 Oid typmodinOid;
103 Oid typmodoutOid;
104 Oid analyzeOid;
105 Oid subscriptOid;
108 /* Potentially set by pg_upgrade_support functions */
134 Oid baseTypeOid,
147 /*
148 * DefineType
149 * Registers a new base type.
150 */
151 ObjectAddress
153 {
155 Oid typeNamespace;
193 Oid inputOid;
194 Oid outputOid;
202 Oid array_oid;
203 Oid typoid;
205 ObjectAddress address;
207 /*
208 * As of Postgres 8.4, we require superuser privilege to create a base
209 * type. This is simple paranoia: there are too many ways to mess up the
210 * system with an incorrect type definition (for instance, representation
211 * parameters that don't match what the C code expects). In practice it
212 * takes superuser privilege to create the I/O functions, and so the
213 * former requirement that you own the I/O functions pretty much forced
214 * superuserness anyway. We're just making doubly sure here.
215 *
216 * XXX re-enable NOT_USED code sections below if you remove this test.
217 */
223 /* Convert list of names to a name and namespace */
226 #ifdef NOT_USED
227 /* XXX this is unnecessary given the superuser check above */
228 /* Check we have creation rights in target namespace */
233 #endif
235 /*
236 * Look to see if type already exists.
237 */
242 /*
243 * If it's not a shell, see if it's an autogenerated array type, and if so
244 * rename it out of the way.
245 */
247 {
250 else
254 }
256 /*
257 * If this command is a parameterless CREATE TYPE, then we're just here to
258 * make a shell type, so do that (or fail if there already is a shell).
259 */
261 {
269 }
271 /*
272 * Otherwise, we must already have a shell type, since there is no other
273 * way that the I/O functions could have been created.
274 */
279 errhint("Create the type as a shell type, then create its I/O functions, then do a full CREATE TYPE.")));
281 /* Extract the parameters from the parameter list */
283 {
326 else
327 {
328 /* WARNING, not ERROR, for historical backwards-compatibility */
335 }
339 }
341 /*
342 * Now interpret the options; we do this separately so that LIKE can be
343 * overridden by other options regardless of the ordering in the parameter
344 * list.
345 */
347 {
348 Type likeType;
349 Form_pg_type likeForm;
358 }
378 {
382 /* restrict to non-control ASCII */
387 p)));
388 }
392 {
396 /* XXX shouldn't we restrict the delimiter? */
397 }
399 {
401 /* disallow arrays of pseudotypes */
407 }
413 {
416 /*
417 * Note: if argument was an unquoted identifier, parser will have
418 * applied translations to it, so be prepared to recognize translated
419 * type names as well as the nominal form.
420 */
434 else
438 }
440 {
451 else
455 }
459 /*
460 * make sure we have our required definitions
461 */
476 /*
477 * Convert I/O proc names to OIDs
478 */
486 /*
487 * Convert typmodin/out function proc names to OIDs.
488 */
494 /*
495 * Convert analysis function proc name to an OID. If no analysis function
496 * is specified, we'll use zero to select the built-in default algorithm.
497 */
501 /*
502 * Likewise look up the subscripting function if any. If it is not
503 * specified, but a typelem is specified, allow that if
504 * raw_array_subscript_handler can be used. (This is for backwards
505 * compatibility; maybe someday we should throw an error instead.)
506 */
510 {
513 else
517 }
519 /*
520 * Check permissions on functions. We choose to require the creator/owner
521 * of a type to also own the underlying functions. Since creating a type
522 * is tantamount to granting public execute access on the functions, the
523 * minimum sane check would be for execute-with-grant-option. But we
524 * don't have a way to make the type go away if the grant option is
525 * revoked, so ownership seems better.
526 *
527 * XXX For now, this is all unnecessary given the superuser check above.
528 * If we ever relax that, these calls likely should be moved into
529 * findTypeInputFunction et al, where they could be shared by AlterType.
530 */
531 #ifdef NOT_USED
556 #endif
558 /*
559 * OK, we're done checking, time to make the type. We must assign the
560 * array type OID ahead of calling TypeCreate, since the base type and
561 * array type each refer to the other.
562 */
565 /*
566 * now have TypeCreate do all the real work.
567 *
568 * Note: the pg_type.oid is stored in user tables as array elements (base
569 * types) in ArrayType and in composite types in DatumTupleFields. This
570 * oid must be preserved by binary upgrades.
571 */
572 address =
607 /*
608 * Create the array type that goes with it.
609 */
612 /* alignment must be TYPALIGN_INT or TYPALIGN_DOUBLE for arrays */
651 }
653 /*
654 * Guts of type deletion.
655 */
656 void
658 {
659 Relation relation;
660 HeapTuple tup;
670 /*
671 * If it is an enum, delete the pg_enum entries too; we don't bother with
672 * making dependency entries for those, so it has to be done "by hand"
673 * here.
674 */
678 /*
679 * If it is a range type, delete the pg_range entry too; we don't bother
680 * with making a dependency entry for that, so it has to be done "by hand"
681 * here.
682 */
689 }
692 /*
693 * DefineDomain
694 * Registers a new domain.
695 */
696 ObjectAddress
698 {
701 Oid domainNamespace;
702 AclResult aclresult;
703 int16 internalLength;
704 Oid inputProcedure;
705 Oid outputProcedure;
706 Oid receiveProcedure;
707 Oid sendProcedure;
708 Oid analyzeProcedure;
715 Datum datum;
723 HeapTuple typeTup;
726 Oid basetypeoid;
727 Oid old_type_oid;
728 Oid domaincoll;
729 Oid domainArrayOid;
730 Form_pg_type baseType;
731 int32 basetypeMod;
732 Oid baseColl;
733 ObjectAddress address;
735 /* Convert list of names to a name and namespace */
739 /* Check we have creation rights in target namespace */
741 ACL_CREATE);
746 /*
747 * Check for collision with an existing type name. If there is one and
748 * it's an autogenerated array, we can rename it out of the way.
749 */
754 {
759 }
761 /*
762 * Look up the base type.
763 */
768 /*
769 * Base type must be a plain base type, a composite type, another domain,
770 * an enum or a range type. Domains over pseudotypes would create a
771 * security hole. (It would be shorter to code this to just check for
772 * pseudotypes; but it seems safer to call out the specific typtypes that
773 * are supported, rather than assume that all future typtypes would be
774 * automatically supported.)
775 */
793 /*
794 * Collect the properties of the new domain. Some are inherited from the
795 * base type, some are not. If you change any of this inheritance
796 * behavior, be sure to update AlterTypeRecurse() to match!
797 */
799 /*
800 * Identify the collation if any
801 */
805 else
808 /* Complain if COLLATE is applied to an uncollatable type */
816 /* passed by value */
819 /* Required Alignment */
822 /* TOAST Strategy */
825 /* Storage Length */
828 /* Type Category */
831 /* Array element Delimiter */
834 /* I/O Functions */
840 /* Domains never accept typmods, so no typmodin/typmodout needed */
842 /* Analysis function */
845 /*
846 * Domains don't need a subscript function, since they are not
847 * subscriptable on their own. If the base type is subscriptable, the
848 * parser will reduce the type to the base type before subscripting.
849 */
851 /* Inherited default value */
857 /* Inherited default binary value */
863 /*
864 * Run through constraints manually to avoid the additional processing
865 * conducted by DefineRelation() and friends.
866 */
868 {
875 {
878 /*
879 * The inherited default value may be overridden by the user
880 * with the DEFAULT <expr> clause ... but only once.
881 */
890 {
893 /*
894 * Cook the constr->raw_expr into an expression. Note:
895 * name is strictly for error message
896 */
898 basetypeoid,
899 basetypeMod,
900 domainName,
903 /*
904 * If the expression is just a NULL constant, we treat it
905 * like not having a default.
906 *
907 * Note that if the basetype is another domain, we'll see
908 * a CoerceToDomain expr here and not discard the default.
909 * This is critical because the domain default needs to be
910 * retained to override any default that the base domain
911 * might have.
912 */
916 {
919 }
920 else
921 {
922 /*
923 * Expression must be stored as a nodeToString result,
924 * but we also require a valid textual representation
925 * (mainly to make life easier for pg_dump).
926 */
927 defaultValue =
931 }
932 }
933 else
934 {
935 /* No default (can this still happen?) */
938 }
968 /*
969 * Check constraints are handled after domain creation, as
970 * they require the Oid of the domain; at this point we can
971 * only check that they're not marked NO INHERIT, because that
972 * would be bogus.
973 */
982 /*
983 * All else are error cases
984 */
1039 /* no default, to let compiler warn about missing case */
1040 }
1041 }
1043 /* Allocate OID for array type */
1046 /*
1047 * Have TypeCreate do all the real work.
1048 */
1049 address =
1083 /*
1084 * Create the array type that goes with it.
1085 */
1088 /* alignment must be TYPALIGN_INT or TYPALIGN_DOUBLE for arrays */
1126 /*
1127 * Process constraints which refer to the domain ID returned by TypeCreate
1128 */
1130 {
1133 /* it must be a Constraint, per check above */
1136 {
1149 /* Other constraint types were fully processed above */
1153 }
1155 /* CCI so we can detect duplicate constraint names */
1157 }
1159 /*
1160 * Now we can clean up.
1161 */
1165 }
1168 /*
1169 * DefineEnum
1170 * Registers a new enum.
1171 */
1172 ObjectAddress
1174 {
1177 Oid enumNamespace;
1178 AclResult aclresult;
1179 Oid old_type_oid;
1180 Oid enumArrayOid;
1181 ObjectAddress enumTypeAddr;
1183 /* Convert list of names to a name and namespace */
1187 /* Check we have creation rights in target namespace */
1193 /*
1194 * Check for collision with an existing type name. If there is one and
1195 * it's an autogenerated array, we can rename it out of the way.
1196 */
1201 {
1206 }
1208 /* Allocate OID for array type */
1211 /* Create the pg_type entry */
1212 enumTypeAddr =
1246 /* Enter the enum's values into pg_enum */
1249 /*
1250 * Create the array type that goes with it.
1251 */
1290 }
1292 /*
1293 * AlterEnum
1294 * Adds a new label to an existing enum.
1295 */
1296 ObjectAddress
1298 {
1299 Oid enum_type_oid;
1301 HeapTuple tup;
1302 ObjectAddress address;
1304 /* Make a TypeName so we can use standard type lookup machinery */
1312 /* Check it's an enum and check user has permission to ALTER the enum */
1318 {
1319 /* Rename an existing label */
1321 }
1322 else
1323 {
1324 /* Add a new label */
1328 }
1335 }
1338 /*
1339 * checkEnumOwner
1340 *
1341 * Check that the type is actually an enum and that the current user
1342 * has permission to do ALTER TYPE on it. Throw an error if not.
1343 */
1344 static void
1346 {
1349 /* Check that this is actually an enum */
1356 /* Permission check: must own type */
1359 }
1362 /*
1363 * DefineRange
1364 * Registers a new range type.
1365 *
1366 * Perhaps it might be worthwhile to set pg_type.typelem to the base type,
1367 * and likewise on multiranges to set it to the range type. But having a
1368 * non-zero typelem is treated elsewhere as a synonym for being an array,
1369 * and users might have queries with that same assumption.
1370 */
1371 ObjectAddress
1373 {
1375 Oid typeNamespace;
1376 Oid typoid;
1381 Oid rangeArrayOid;
1382 Oid multirangeOid;
1383 Oid multirangeArrayOid;
1389 Oid rangeSubOpclass;
1390 Oid rangeCollation;
1391 regproc rangeCanonical;
1392 regproc rangeSubtypeDiff;
1393 int16 subtyplen;
1397 AclResult aclresult;
1399 ObjectAddress address;
1400 ObjectAddress mltrngaddress PG_USED_FOR_ASSERTS_ONLY;
1401 Oid castFuncOid;
1403 /* Convert list of names to a name and namespace */
1407 /* Check we have creation rights in target namespace */
1413 /*
1414 * Look to see if type already exists.
1415 */
1420 /*
1421 * If it's not a shell, see if it's an autogenerated array type, and if so
1422 * rename it out of the way.
1423 */
1425 {
1428 else
1432 }
1434 /*
1435 * Unlike DefineType(), we don't insist on a shell type existing first, as
1436 * it's only needed if the user wants to specify a canonical function.
1437 */
1439 /* Extract the parameters from the parameter list */
1441 {
1445 {
1448 /* we can look up the subtype name immediately */
1450 }
1452 {
1456 }
1458 {
1462 }
1464 {
1468 }
1470 {
1474 }
1476 {
1479 /* we can look up the subtype name immediately */
1482 }
1483 else
1488 }
1490 /* Must have a subtype */
1495 /* disallow ranges of pseudotypes */
1502 /* Identify subopclass */
1505 /* Identify collation to use, if any */
1507 {
1510 else
1512 }
1513 else
1514 {
1520 }
1522 /* Identify support functions, if provided */
1524 {
1529 errhint("Create the type as a shell type, then create its canonicalization function, then do a full CREATE TYPE.")));
1531 typoid);
1532 }
1533 else
1538 rangeSubtype);
1539 else
1545 /* alignment must be TYPALIGN_INT or TYPALIGN_DOUBLE for ranges */
1548 /* Allocate OID for array type, its multirange, and its multirange array */
1553 /* Create the pg_type entry */
1554 address =
1590 /* Create the multirange that goes with it */
1592 {
1593 Oid old_typoid;
1595 /*
1596 * Look to see if multirange type already exists.
1597 */
1602 /*
1603 * If it's not a shell, see if it's an autogenerated array type, and
1604 * if so rename it out of the way.
1605 */
1607 {
1612 }
1613 }
1614 else
1615 {
1616 /* Generate multirange name automatically */
1619 }
1621 mltrngaddress =
1656 /* Create the entry in pg_range */
1660 /*
1661 * Create the array type that goes with it.
1662 */
1700 /* Create the multirange's array type */
1737 /* And create the constructor functions for this range type */
1743 /* Create cast from the range type to its multirange type */
1746 DEPENDENCY_INTERNAL);
1751 }
1753 /*
1754 * Because there may exist several range types over the same subtype, the
1755 * range type can't be uniquely determined from the subtype. So it's
1756 * impossible to define a polymorphic constructor; we have to generate new
1757 * constructor functions explicitly for each range type.
1758 *
1759 * We actually define 4 functions, with 0 through 3 arguments. This is just
1760 * to offer more convenience for the user.
1761 */
1762 static void
1765 {
1771 ObjectAddress myself,
1772 referenced;
1784 {
1801 PROKIND_FUNCTION,
1818 /*
1819 * Make the constructors internally-dependent on the range type so
1820 * that they go away silently when the type is dropped. Note that
1821 * pg_dump depends on this choice to avoid dumping the constructors.
1822 */
1824 }
1825 }
1827 /*
1828 * We make a separate multirange constructor for each range type
1829 * so its name can include the base type, like range constructors do.
1830 * If we had an anyrangearray polymorphic type we could use it here,
1831 * but since each type has its own constructor name there's no need.
1832 *
1833 * Sets castFuncOid to the oid of the new constructor that can be used
1834 * to cast from a range to a multirange.
1835 */
1836 static void
1840 {
1841 ObjectAddress myself,
1842 referenced;
1844 Datum allParamTypes;
1846 Datum paramModes;
1853 /* 0-arg constructor - for empty multiranges */
1862 F_FMGR_INTERNAL_VALIDATOR,
1866 PROKIND_FUNCTION,
1883 /*
1884 * Make the constructor internally-dependent on the multirange type so
1885 * that they go away silently when the type is dropped. Note that pg_dump
1886 * depends on this choice to avoid dumping the constructors.
1887 */
1891 /*
1892 * 1-arg constructor - for casts
1893 *
1894 * In theory we shouldn't need both this and the vararg (n-arg)
1895 * constructor, but having a separate 1-arg function lets us define casts
1896 * against it.
1897 */
1906 F_FMGR_INTERNAL_VALIDATOR,
1910 PROKIND_FUNCTION,
1926 /* ditto */
1931 /* n-arg constructor - vararg */
1944 F_FMGR_INTERNAL_VALIDATOR,
1948 PROKIND_FUNCTION,
1964 /* ditto */
1969 }
1971 /*
1972 * Find suitable I/O and other support functions for a type.
1973 *
1974 * typeOid is the type's OID (which will already exist, if only as a shell
1975 * type).
1976 */
1978 static Oid
1980 {
1982 Oid procOid;
1983 Oid procOid2;
1985 /*
1986 * Input functions can take a single argument of type CSTRING, or three
1987 * arguments (string, typioparam OID, typmod). Whine about ambiguity if
1988 * both forms exist.
1989 */
1997 {
2003 }
2004 else
2005 {
2007 /* If not found, reference the 1-argument signature in error msg */
2013 }
2015 /* Input functions must return the target type. */
2022 /*
2023 * Print warnings if any of the type's I/O functions are marked volatile.
2024 * There is a general assumption that I/O functions are stable or
2025 * immutable; this allows us for example to mark record_in/record_out
2026 * stable rather than volatile. Ideally we would throw errors not just
2027 * warnings here; but since this check is new as of 9.5, and since the
2028 * volatility marking might be just an error-of-omission and not a true
2029 * indication of how the function behaves, we'll let it pass as a warning
2030 * for now.
2031 */
2039 }
2041 static Oid
2043 {
2045 Oid procOid;
2047 /*
2048 * Output functions always take a single argument of the type and return
2049 * cstring.
2050 */
2066 /* Just a warning for now, per comments in findTypeInputFunction */
2074 }
2076 static Oid
2078 {
2080 Oid procOid;
2081 Oid procOid2;
2083 /*
2084 * Receive functions can take a single argument of type INTERNAL, or three
2085 * arguments (internal, typioparam OID, typmod). Whine about ambiguity if
2086 * both forms exist.
2087 */
2095 {
2101 }
2102 else
2103 {
2105 /* If not found, reference the 1-argument signature in error msg */
2111 }
2113 /* Receive functions must return the target type. */
2120 /* Just a warning for now, per comments in findTypeInputFunction */
2128 }
2130 static Oid
2132 {
2134 Oid procOid;
2136 /*
2137 * Send functions always take a single argument of the type and return
2138 * bytea.
2139 */
2155 /* Just a warning for now, per comments in findTypeInputFunction */
2163 }
2165 static Oid
2167 {
2169 Oid procOid;
2171 /*
2172 * typmodin functions always take one cstring[] argument and return int4.
2173 */
2189 /* Just a warning for now, per comments in findTypeInputFunction */
2197 }
2199 static Oid
2201 {
2203 Oid procOid;
2205 /*
2206 * typmodout functions always take one int4 argument and return cstring.
2207 */
2223 /* Just a warning for now, per comments in findTypeInputFunction */
2231 }
2233 static Oid
2235 {
2237 Oid procOid;
2239 /*
2240 * Analyze functions always take one INTERNAL argument and return bool.
2241 */
2258 }
2260 static Oid
2262 {
2264 Oid procOid;
2266 /*
2267 * Subscripting support functions always take one INTERNAL argument and
2268 * return INTERNAL. (The argument is not used, but we must have it to
2269 * maintain type safety.)
2270 */
2286 /*
2287 * We disallow array_subscript_handler() from being selected explicitly,
2288 * since that must only be applied to autogenerated array types.
2289 */
2297 }
2299 /*
2300 * Find suitable support functions and opclasses for a range type.
2301 */
2303 /*
2304 * Find named btree opclass for subtype, or default btree opclass if
2305 * opcname is NIL.
2306 */
2307 static Oid
2309 {
2310 Oid opcid;
2311 Oid opInputType;
2314 {
2317 /*
2318 * Verify that the operator class accepts this datatype. Note we will
2319 * accept binary compatibility.
2320 */
2328 }
2329 else
2330 {
2333 {
2334 /* We spell the error message identically to ResolveOpClass */
2339 errhint("You must specify an operator class for the range type or define a default operator class for the subtype.")));
2340 }
2341 }
2344 }
2346 static Oid
2348 {
2350 Oid procOid;
2351 AclResult aclresult;
2353 /*
2354 * Range canonical functions must take and return the range type, and must
2355 * be immutable.
2356 */
2379 /* Also, range type's creator must have permission to call function */
2385 }
2387 static Oid
2389 {
2391 Oid procOid;
2392 AclResult aclresult;
2394 /*
2395 * Range subtype diff functions must take two arguments of the subtype,
2396 * must return float8, and must be immutable.
2397 */
2422 /* Also, range type's creator must have permission to call function */
2428 }
2430 /*
2431 * AssignTypeArrayOid
2432 *
2433 * Pre-assign the type's array OID for use in pg_type.typarray
2434 */
2435 Oid
2437 {
2438 Oid type_array_oid;
2440 /* Use binary-upgrade override for pg_type.typarray? */
2442 {
2450 }
2451 else
2452 {
2456 Anum_pg_type_oid);
2458 }
2461 }
2463 /*
2464 * AssignTypeMultirangeOid
2465 *
2466 * Pre-assign the range type's multirange OID for use in pg_type.oid
2467 */
2468 Oid
2470 {
2471 Oid type_multirange_oid;
2473 /* Use binary-upgrade override for pg_type.oid? */
2475 {
2483 }
2484 else
2485 {
2489 Anum_pg_type_oid);
2491 }
2494 }
2496 /*
2497 * AssignTypeMultirangeArrayOid
2498 *
2499 * Pre-assign the range type's multirange array OID for use in pg_type.typarray
2500 */
2501 Oid
2503 {
2504 Oid type_multirange_array_oid;
2506 /* Use binary-upgrade override for pg_type.oid? */
2508 {
2516 }
2517 else
2518 {
2522 Anum_pg_type_oid);
2524 }
2527 }
2530 /*-------------------------------------------------------------------
2531 * DefineCompositeType
2532 *
2533 * Create a Composite Type relation.
2534 * `DefineRelation' does all the work, we just provide the correct
2535 * arguments!
2536 *
2537 * If the relation already exists, then 'DefineRelation' will abort
2538 * the xact...
2539 *
2540 * Return type is the new type's object address.
2541 *-------------------------------------------------------------------
2542 */
2543 ObjectAddress
2545 {
2547 Oid old_type_oid;
2548 Oid typeNamespace;
2549 ObjectAddress address;
2551 /*
2552 * now set the parameters for keys/inheritance etc. All of these are
2553 * uninteresting for composite types...
2554 */
2564 /*
2565 * Check for collision with an existing type name. If there is one and
2566 * it's an autogenerated array, we can rename it out of the way. This
2567 * check is here mainly to get a better error message about a "type"
2568 * instead of below about a "relation".
2569 */
2573 old_type_oid =
2578 {
2583 }
2585 /*
2586 * Finally create the relation. This also creates the type.
2587 */
2589 NULL);
2592 }
2594 /*
2595 * AlterDomainDefault
2596 *
2597 * Routine implementing ALTER DOMAIN SET/DROP DEFAULT statements.
2598 *
2599 * Returns ObjectAddress of the modified domain.
2600 */
2601 ObjectAddress
2603 {
2605 Oid domainoid;
2606 HeapTuple tup;
2608 Relation rel;
2614 HeapTuple newtuple;
2615 Form_pg_type typTup;
2616 ObjectAddress address;
2618 /* Make a TypeName so we can use standard type lookup machinery */
2622 /* Look up the domain in the type table */
2630 /* Check it's a domain and check user has permission for ALTER DOMAIN */
2633 /* Setup new tuple */
2635 /* Store the new default into the tuple */
2637 {
2638 /* Create a dummy ParseState for transformExpr */
2641 /*
2642 * Cook the colDef->raw_expr into an expression. Note: Name is
2643 * strictly for error message
2644 */
2651 /*
2652 * If the expression is just a NULL constant, we treat the command
2653 * like ALTER ... DROP DEFAULT. (But see note for same test in
2654 * DefineDomain.)
2655 */
2658 {
2659 /* Default is NULL, drop it */
2665 }
2666 else
2667 {
2668 /*
2669 * Expression must be stored as a nodeToString result, but we also
2670 * require a valid textual representation (mainly to make life
2671 * easier for pg_dump).
2672 */
2676 /*
2677 * Form an updated tuple with the new default and write it back.
2678 */
2684 }
2685 }
2686 else
2687 {
2688 /* ALTER ... DROP DEFAULT */
2693 }
2697 new_record_repl);
2701 /* Rebuild dependencies */
2703 rel,
2704 defaultExpr,
2716 /* Clean up */
2721 }
2723 /*
2724 * AlterDomainNotNull
2725 *
2726 * Routine implementing ALTER DOMAIN SET/DROP NOT NULL statements.
2727 *
2728 * Returns ObjectAddress of the modified domain.
2729 */
2730 ObjectAddress
2732 {
2734 Oid domainoid;
2735 Relation typrel;
2736 HeapTuple tup;
2737 Form_pg_type typTup;
2740 /* Make a TypeName so we can use standard type lookup machinery */
2744 /* Look up the domain in the type table */
2752 /* Check it's a domain and check user has permission for ALTER DOMAIN */
2755 /* Is the domain already set to the desired constraint? */
2757 {
2760 }
2763 {
2776 }
2777 else
2778 {
2779 HeapTuple conTup;
2780 ObjectAddress conobj;
2788 }
2790 /*
2791 * Okay to update pg_type row. We can scribble on typTup because it's a
2792 * copy.
2793 */
2802 /* Clean up */
2807 }
2809 /*
2810 * AlterDomainDropConstraint
2811 *
2812 * Implements the ALTER DOMAIN DROP CONSTRAINT statement
2813 *
2814 * Returns ObjectAddress of the modified domain.
2815 */
2816 ObjectAddress
2819 {
2821 Oid domainoid;
2822 HeapTuple tup;
2823 Relation rel;
2824 Relation conrel;
2825 SysScanDesc conscan;
2827 HeapTuple contup;
2829 ObjectAddress address;
2831 /* Make a TypeName so we can use standard type lookup machinery */
2835 /* Look up the domain in the type table */
2842 /* Check it's a domain and check user has permission for ALTER DOMAIN */
2845 /* Grab an appropriate lock on the pg_constraint relation */
2848 /* Find and remove the target constraint */
2850 Anum_pg_constraint_conrelid,
2854 Anum_pg_constraint_contypid,
2858 Anum_pg_constraint_conname,
2865 /* There can be at most one matching row */
2867 {
2869 ObjectAddress conobj;
2872 {
2875 }
2883 }
2885 /* Clean up after the scan */
2890 {
2896 else
2900 }
2902 /*
2903 * We must send out an sinval message for the domain, to ensure that any
2904 * dependent plans get rebuilt. Since this command doesn't change the
2905 * domain's pg_type row, that won't happen automatically; do it manually.
2906 */
2911 /* Clean up */
2915 }
2917 /*
2918 * AlterDomainAddConstraint
2919 *
2920 * Implements the ALTER DOMAIN .. ADD CONSTRAINT statement.
2921 */
2922 ObjectAddress
2925 {
2927 Oid domainoid;
2928 Relation typrel;
2929 HeapTuple tup;
2930 Form_pg_type typTup;
2935 /* Make a TypeName so we can use standard type lookup machinery */
2939 /* Look up the domain in the type table */
2947 /* Check it's a domain and check user has permission for ALTER DOMAIN */
2957 {
2960 /* processed below */
3007 }
3010 {
3011 /*
3012 * First, process the constraint expression and add an entry to
3013 * pg_constraint.
3014 */
3021 /*
3022 * If requested to validate the constraint, test all values stored in
3023 * the attributes based on the domain the constraint is being added
3024 * to.
3025 */
3029 /*
3030 * We must send out an sinval message for the domain, to ensure that
3031 * any dependent plans get rebuilt. Since this command doesn't change
3032 * the domain's pg_type row, that won't happen automatically; do it
3033 * manually.
3034 */
3036 }
3038 {
3039 /* Is the domain already set NOT NULL? */
3041 {
3044 }
3054 }
3058 /* Clean up */
3062 }
3064 /*
3065 * AlterDomainValidateConstraint
3066 *
3067 * Implements the ALTER DOMAIN .. VALIDATE CONSTRAINT statement.
3068 */
3069 ObjectAddress
3071 {
3073 Oid domainoid;
3074 Relation typrel;
3075 Relation conrel;
3076 HeapTuple tup;
3077 Form_pg_constraint con;
3078 Form_pg_constraint copy_con;
3080 SysScanDesc scan;
3081 Datum val;
3082 HeapTuple tuple;
3083 HeapTuple copyTuple;
3085 ObjectAddress address;
3087 /* Make a TypeName so we can use standard type lookup machinery */
3091 /* Look up the domain in the type table */
3098 /* Check it's a domain and check user has permission for ALTER DOMAIN */
3101 /*
3102 * Find and check the target constraint
3103 */
3107 Anum_pg_constraint_conrelid,
3111 Anum_pg_constraint_contypid,
3115 Anum_pg_constraint_conname,
3122 /* There can be at most one matching row */
3141 /*
3142 * Now update the catalog, while we have the door open.
3143 */
3163 }
3165 /*
3166 * Verify that all columns currently using the domain are not null.
3167 */
3168 static void
3170 {
3174 /* Fetch relation list with attributes based on this domain */
3175 /* ShareLock is sufficient to prevent concurrent data changes */
3180 {
3185 TableScanDesc scan;
3186 Snapshot snapshot;
3188 /* Scan all tuples in this relation */
3193 {
3196 /* Test attributes that are of the domain */
3198 {
3203 {
3204 /*
3205 * In principle the auxiliary information for this error
3206 * should be errdatatype(), but errtablecol() seems
3207 * considerably more useful in practice. Since this code
3208 * only executes in an ALTER DOMAIN command, the client
3209 * should already know which domain is in question.
3210 */
3217 }
3218 }
3219 }
3224 /* Close each rel after processing, but keep lock */
3226 }
3227 }
3229 /*
3230 * Verify that all columns currently using the domain satisfy the given check
3231 * constraint expression.
3232 */
3233 static void
3235 {
3243 /* Need an EState to run ExecEvalExpr */
3247 /* build execution state for expr */
3250 /* Fetch relation list with attributes based on this domain */
3251 /* ShareLock is sufficient to prevent concurrent data changes */
3256 {
3261 TableScanDesc scan;
3262 Snapshot snapshot;
3264 /* Scan all tuples in this relation */
3269 {
3272 /* Test attributes that are of the domain */
3274 {
3276 Datum d;
3278 Datum conResult;
3287 econtext,
3291 {
3292 /*
3293 * In principle the auxiliary information for this error
3294 * should be errdomainconstraint(), but errtablecol()
3295 * seems considerably more useful in practice. Since this
3296 * code only executes in an ALTER DOMAIN command, the
3297 * client should already know which domain is in question,
3298 * and which constraint too.
3299 */
3306 }
3307 }
3310 }
3315 /* Hold relation lock till commit (XXX bad for concurrency) */
3317 }
3320 }
3322 /*
3323 * get_rels_with_domain
3324 *
3325 * Fetch all relations / attributes which are using the domain
3326 *
3327 * The result is a list of RelToCheck structs, one for each distinct
3328 * relation, each containing one or more attribute numbers that are of
3329 * the domain type. We have opened each rel and acquired the specified lock
3330 * type on it.
3331 *
3332 * We support nested domains by including attributes that are of derived
3333 * domain types. Current callers do not need to distinguish between attributes
3334 * that are of exactly the given domain and those that are of derived domains.
3335 *
3336 * XXX this is completely broken because there is no way to lock the domain
3337 * to prevent columns from being added or dropped while our command runs.
3338 * We can partially protect against column drops by locking relations as we
3339 * come across them, but there is still a race condition (the window between
3340 * seeing a pg_depend entry and acquiring lock on the relation it references).
3341 * Also, holding locks on all these relations simultaneously creates a non-
3342 * trivial risk of deadlock. We can minimize but not eliminate the deadlock
3343 * risk by using the weakest suitable lock (ShareLock for most callers).
3344 *
3345 * XXX the API for this is not sufficient to support checking domain values
3346 * that are inside container types, such as composite types, arrays, or
3347 * ranges. Currently we just error out if a container type containing the
3348 * target domain is stored anywhere.
3349 *
3350 * Generally used for retrieving a list of tests when adding
3351 * new constraints to a domain.
3352 */
3355 {
3358 Relation depRel;
3360 SysScanDesc depScan;
3361 HeapTuple depTup;
3365 /* since this function recurses, it could be driven to stack overflow */
3368 /*
3369 * We scan pg_depend to find those things that depend on the domain. (We
3370 * assume we can ignore refobjsubid for a domain.)
3371 */
3375 Anum_pg_depend_refclassid,
3379 Anum_pg_depend_refobjid,
3387 {
3391 Form_pg_attribute pg_att;
3394 /* Check for directly dependent types */
3396 {
3398 {
3399 /*
3400 * This is a sub-domain, so recursively add dependent columns
3401 * to the output list. This is a bit inefficient since we may
3402 * fail to combine RelToCheck entries when attributes of the
3403 * same rel have different derived domain types, but it's
3404 * probably not worth improving.
3405 */
3408 lockmode));
3409 }
3410 else
3411 {
3412 /*
3413 * Otherwise, it is some container type using the domain, so
3414 * fail if there are any columns of this type.
3415 */
3417 NULL,
3418 domainTypeName);
3419 }
3421 }
3423 /* Else, ignore dependees that aren't user columns of relations */
3424 /* (we assume system columns are never of domain types) */
3429 /* See if we already have an entry for this relation */
3431 {
3435 {
3438 }
3439 }
3442 {
3443 /* First attribute found for this relation */
3444 Relation rel;
3446 /* Acquire requested lock on relation */
3449 /*
3450 * Check to see if rowtype is stored anyplace as a composite-type
3451 * column; if so we have to fail, for now anyway.
3452 */
3455 NULL,
3456 domainTypeName);
3458 /*
3459 * Otherwise, we can ignore relations except those with both
3460 * storage and user-chosen column types.
3461 *
3462 * XXX If an index-only scan could satisfy "col::some_domain" from
3463 * a suitable expression index, this should also check expression
3464 * index columns.
3465 */
3468 {
3471 }
3473 /* Build the RelToCheck entry with enough space for all atts */
3479 }
3481 /*
3482 * Confirm column has not been dropped, and is of the expected type.
3483 * This defends against an ALTER DROP COLUMN occurring just before we
3484 * acquired lock ... but if the whole table were dropped, we'd still
3485 * have a problem.
3486 */
3493 /*
3494 * Okay, add column to result. We store the columns in column-number
3495 * order; this is just a hack to improve predictability of regression
3496 * test output ...
3497 */
3502 {
3504 ptr--;
3505 }
3507 }
3514 }
3516 /*
3517 * checkDomainOwner
3518 *
3519 * Check that the type is actually a domain and that the current user
3520 * has permission to do ALTER DOMAIN on it. Throw an error if not.
3521 */
3522 void
3524 {
3527 /* Check that this is actually a domain */
3534 /* Permission check: must own type */
3537 }
3539 /*
3540 * domainAddCheckConstraint - code shared between CREATE and ALTER DOMAIN
3541 */
3546 {
3551 Oid ccoid;
3555 /*
3556 * Assign or validate constraint name
3557 */
3559 {
3561 domainOid,
3567 }
3568 else
3570 NULL,
3572 domainNamespace,
3573 NIL);
3575 /*
3576 * Convert the A_EXPR in raw_expr into an EXPR
3577 */
3580 /*
3581 * Set up a CoerceToDomainValue to represent the occurrence of VALUE in
3582 * the expression. Note that it will appear to have the type of the base
3583 * type, not the domain. This seems correct since within the check
3584 * expression, we should not assume the input value can be considered a
3585 * member of the domain.
3586 */
3598 /*
3599 * Make sure it yields a boolean result.
3600 */
3603 /*
3604 * Fix up collation information.
3605 */
3608 /*
3609 * Domains don't allow variables (this is probably dead code now that
3610 * add_missing_from is history, but let's be sure).
3611 */
3618 /*
3619 * Convert to string form for storage.
3620 */
3623 /*
3624 * Store the constraint in pg_constraint
3625 */
3626 ccoid =
3636 NULL,
3642 NULL,
3643 NULL,
3644 NULL,
3645 NULL,
3649 NULL,
3663 /*
3664 * Return the compiled constraint expression so the calling routine can
3665 * perform any additional required tests.
3666 */
3668 }
3670 /* Parser pre_columnref_hook for domain CHECK constraint parsing */
3673 {
3674 /*
3675 * Check for a reference to "value", and if that's what it is, replace
3676 * with a CoerceToDomainValue as prepared for us by
3677 * domainAddCheckConstraint. (We handle VALUE as a name, not a keyword, to
3678 * avoid breaking a lot of applications that have used VALUE as a column
3679 * name in the past.)
3680 */
3682 {
3688 {
3691 /* Propagate location knowledge, if any */
3694 }
3695 }
3697 }
3699 /*
3700 * domainAddNotNullConstraint - code shared between CREATE and ALTER DOMAIN
3701 */
3702 static void
3706 {
3707 Oid ccoid;
3711 /*
3712 * Assign or validate constraint name
3713 */
3715 {
3717 domainOid,
3723 }
3724 else
3726 NULL,
3728 domainNamespace,
3729 NIL);
3731 /*
3732 * Store the constraint in pg_constraint
3733 */
3734 ccoid =
3744 NULL,
3750 NULL,
3751 NULL,
3752 NULL,
3753 NULL,
3757 NULL,
3761 NULL,
3762 NULL,
3771 }
3774 /*
3775 * Execute ALTER TYPE RENAME
3776 */
3777 ObjectAddress
3779 {
3783 Oid typeOid;
3784 Relation rel;
3785 HeapTuple tup;
3786 Form_pg_type typTup;
3787 ObjectAddress address;
3789 /* Make a TypeName so we can use standard type lookup machinery */
3793 /* Look up the type in the type table */
3801 /* check permissions on type */
3805 /* ALTER DOMAIN used on a non-domain? */
3812 /*
3813 * If it's a composite type, we need to check that it really is a
3814 * free-standing composite type, and not a table's rowtype. We want people
3815 * to use ALTER TABLE not ALTER TYPE for that case.
3816 */
3823 /* translator: %s is an SQL ALTER command */
3827 /* don't allow direct alteration of array types, either */
3836 /* we do allow separate renaming of multirange types, though */
3838 /*
3839 * If type is composite we need to rename associated pg_class entry too.
3840 * RenameRelationInternal will call RenameTypeInternal automatically.
3841 */
3844 else
3849 /* Clean up */
3853 }
3855 /*
3856 * Change the owner of a type.
3857 */
3858 ObjectAddress
3860 {
3862 Oid typeOid;
3863 Relation rel;
3864 HeapTuple tup;
3865 HeapTuple newtup;
3866 Form_pg_type typTup;
3867 AclResult aclresult;
3868 ObjectAddress address;
3872 /* Make a TypeName so we can use standard type lookup machinery */
3875 /* Use LookupTypeName here so that shell types can be processed */
3884 /* Copy the syscache entry so we can scribble on it below */
3890 /* Don't allow ALTER DOMAIN on a type */
3897 /*
3898 * If it's a composite type, we need to check that it really is a
3899 * free-standing composite type, and not a table's rowtype. We want people
3900 * to use ALTER TABLE not ALTER TYPE for that case.
3901 */
3908 /* translator: %s is an SQL ALTER command */
3912 /* don't allow direct alteration of array types, either */
3921 /* don't allow direct alteration of multirange types, either */
3923 {
3926 /* We don't expect get_multirange_range to fail, but cope if so */
3934 }
3936 /*
3937 * If the new owner is the same as the existing owner, consider the
3938 * command to have succeeded. This is for dump restoration purposes.
3939 */
3941 {
3942 /* Superusers can always do it */
3944 {
3945 /* Otherwise, must be owner of the existing object */
3949 /* Must be able to become new owner */
3952 /* New owner must have CREATE privilege on namespace */
3954 newOwnerId,
3955 ACL_CREATE);
3959 }
3962 }
3966 /* Clean up */
3970 }
3972 /*
3973 * AlterTypeOwner_oid - change type owner unconditionally
3974 *
3975 * This function recurses to handle dependent types (arrays and multiranges).
3976 * It invokes any necessary access object hooks. If hasDependEntry is true,
3977 * this function modifies the pg_shdepend entry appropriately (this should be
3978 * passed as false only for table rowtypes and dependent types).
3979 *
3980 * This is used by ALTER TABLE/TYPE OWNER commands, as well as by REASSIGN
3981 * OWNED BY. It assumes the caller has done all needed checks.
3982 */
3983 void
3985 {
3986 Relation rel;
3987 HeapTuple tup;
3988 Form_pg_type typTup;
3997 /*
3998 * If it's a composite type, invoke ATExecChangeOwner so that we fix up
3999 * the pg_class entry properly. That will call back to
4000 * AlterTypeOwnerInternal to take care of the pg_type entry(s).
4001 */
4004 else
4007 /* Update owner dependency reference */
4015 }
4017 /*
4018 * AlterTypeOwnerInternal - bare-bones type owner change.
4019 *
4020 * This routine simply modifies the owner of a pg_type entry, and recurses
4021 * to handle any dependent types.
4022 */
4023 void
4025 {
4026 Relation rel;
4027 HeapTuple tup;
4028 Form_pg_type typTup;
4033 Datum aclDatum;
4050 Anum_pg_type_typacl,
4053 /* Null ACLs do not require changes */
4055 {
4060 }
4063 repl_repl);
4067 /* If it has an array type, update that too */
4071 /* If it is a range type, update the associated multirange too */
4073 {
4082 }
4084 /* Clean up */
4086 }
4088 /*
4089 * Execute ALTER TYPE SET SCHEMA
4090 */
4091 ObjectAddress
4094 {
4096 Oid typeOid;
4097 Oid nspOid;
4098 Oid oldNspOid;
4100 ObjectAddress myself;
4102 /* Make a TypeName so we can use standard type lookup machinery */
4106 /* Don't allow ALTER DOMAIN on a non-domain type */
4113 /* get schema OID and check its permissions */
4126 }
4128 /*
4129 * ALTER TYPE SET SCHEMA, where the caller has already looked up the OIDs
4130 * of the type and the target schema and checked the schema's privileges.
4131 *
4132 * If ignoreDependent is true, we silently ignore dependent types
4133 * (array types and table rowtypes) rather than raising errors.
4134 *
4135 * This entry point is exported for use by AlterObjectNamespace_oid,
4136 * which doesn't want errors when it passes OIDs of dependent types.
4137 *
4138 * Returns the type's old namespace OID, or InvalidOid if we did nothing.
4139 */
4140 Oid
4143 {
4144 Oid elemOid;
4146 /* check permissions on type */
4150 /* don't allow direct alteration of array types */
4153 {
4162 }
4164 /* and do the work */
4169 objsMoved);
4170 }
4172 /*
4173 * Move specified type to new namespace.
4174 *
4175 * Caller must have already checked privileges.
4176 *
4177 * The function automatically recurses to process the type's array type,
4178 * if any. isImplicitArray should be true only when doing this internal
4179 * recursion (outside callers must never try to move an array type directly).
4180 *
4181 * If ignoreDependent is true, we silently don't process table types.
4182 *
4183 * If errorOnTableType is true, the function errors out if the type is
4184 * a table type. ALTER TABLE has to be used to move a table to a new
4185 * namespace. (This flag is ignored if ignoreDependent is true.)
4186 *
4187 * We also do nothing if the type is already listed in *objsMoved.
4188 * After a successful move, we add the type to *objsMoved.
4189 *
4190 * Returns the type's old namespace OID, or InvalidOid if we did nothing.
4191 */
4192 Oid
4198 {
4199 Relation rel;
4200 HeapTuple tup;
4201 Form_pg_type typform;
4202 Oid oldNspOid;
4203 Oid arrayOid;
4205 ObjectAddress thisobj;
4207 /*
4208 * Make sure we haven't moved this object previously.
4209 */
4227 /* If the type is already there, we scan skip these next few checks. */
4229 {
4230 /* common checks on switching namespaces */
4233 /* check for duplicate name (more friendly than unique-index failure) */
4242 }
4244 /* Detect whether type is a composite type (but not a table rowtype) */
4245 isCompositeType =
4249 /* Enforce not-table-type if requested */
4251 {
4253 {
4256 }
4262 /* translator: %s is an SQL ALTER command */
4264 }
4267 {
4268 /* OK, modify the pg_type row */
4270 /* tup is a copy, so we can scribble directly on it */
4274 }
4276 /*
4277 * Composite types have pg_class entries.
4278 *
4279 * We need to modify the pg_class tuple as well to reflect the change of
4280 * schema.
4281 */
4283 {
4284 Relation classRel;
4294 /*
4295 * Check for constraints associated with the composite type (we don't
4296 * currently support this, but probably will someday).
4297 */
4300 }
4301 else
4302 {
4303 /* If it's a domain, it might have constraints */
4306 objsMoved);
4307 }
4309 /*
4310 * Update dependency on schema, if any --- a table rowtype has not got
4311 * one, and neither does an implicit array.
4312 */
4329 /* Recursively alter the associated array type, if any */
4335 objsMoved);
4338 }
4340 /*
4341 * AlterType
4342 * ALTER TYPE <type> SET (option = ...)
4343 *
4344 * NOTE: the set of changes that can be allowed here is constrained by many
4345 * non-obvious implementation restrictions. Tread carefully when considering
4346 * adding new flexibility.
4347 */
4348 ObjectAddress
4350 {
4351 ObjectAddress address;
4352 Relation catalog;
4354 HeapTuple tup;
4355 Oid typeOid;
4356 Form_pg_type typForm;
4358 AlterTypeRecurseParams atparams;
4363 /* Make a TypeName so we can use standard type lookup machinery */
4370 /* Process options */
4373 {
4377 {
4388 else
4393 /*
4394 * Validate the storage request. If the type isn't varlena, it
4395 * certainly doesn't support non-PLAIN storage.
4396 */
4402 /*
4403 * Switching from PLAIN to non-PLAIN is allowed, but it requires
4404 * superuser, since we can't validate that the type's C functions
4405 * will support it. Switching from non-PLAIN to PLAIN is
4406 * disallowed outright, because it's not practical to ensure that
4407 * no tables have toasted values of the type. Switching among
4408 * different non-PLAIN settings is OK, since it just constitutes a
4409 * change in the strategy requested for columns created in the
4410 * future.
4411 */
4422 }
4424 {
4428 typeOid);
4429 else
4432 /* Replacing an I/O function requires superuser. */
4434 }
4436 {
4440 typeOid);
4441 else
4444 /* Replacing an I/O function requires superuser. */
4446 }
4448 {
4452 else
4455 /* Replacing an I/O function requires superuser. */
4457 }
4459 {
4463 else
4466 /* Replacing an I/O function requires superuser. */
4468 }
4470 {
4474 typeOid);
4475 else
4478 /* Replacing an analyze function requires superuser. */
4480 }
4482 {
4486 typeOid);
4487 else
4490 /* Replacing a subscript function requires superuser. */
4492 }
4494 /*
4495 * The rest of the options that CREATE accepts cannot be changed.
4496 * Check for them so that we can give a meaningful error message.
4497 */
4514 else
4519 }
4521 /*
4522 * Permissions check. Require superuser if we decided the command
4523 * requires that, else must own the type.
4524 */
4526 {
4531 }
4532 else
4533 {
4536 }
4538 /*
4539 * We disallow all forms of ALTER TYPE SET on types that aren't plain base
4540 * types. It would for example be highly unsafe, not to mention
4541 * pointless, to change the send/receive functions for a composite type.
4542 * Moreover, pg_dump has no support for changing these properties on
4543 * non-base types. We might weaken this someday, but not now.
4544 *
4545 * Note: if you weaken this enough to allow composite types, be sure to
4546 * adjust the GenerateTypeDependencies call in AlterTypeRecurse.
4547 */
4554 /*
4555 * For the same reasons, don't allow direct alteration of array types.
4556 */
4563 /* OK, recursively update this type and any arrays/domains over it */
4566 /* Clean up */
4574 }
4576 /*
4577 * AlterTypeRecurse: one recursion step for AlterType()
4578 *
4579 * Apply the changes specified by "atparams" to the type identified by
4580 * "typeOid", whose existing pg_type tuple is "tup". If necessary,
4581 * recursively update its array type as well. Then search for any domains
4582 * over this type, and recursively apply (most of) the same changes to those
4583 * domains.
4584 *
4585 * We need this because the system generally assumes that a domain inherits
4586 * many properties from its base type. See DefineDomain() above for details
4587 * of what is inherited. Arrays inherit a smaller number of properties,
4588 * but not none.
4589 *
4590 * There's a race condition here, in that some other transaction could
4591 * concurrently add another domain atop this base type; we'd miss updating
4592 * that one. Hence, be wary of allowing ALTER TYPE to change properties for
4593 * which it'd be really fatal for a domain to be out of sync with its base
4594 * type (typlen, for example). In practice, races seem unlikely to be an
4595 * issue for plausible use-cases for ALTER TYPE. If one does happen, it could
4596 * be fixed by re-doing the same ALTER TYPE once all prior transactions have
4597 * committed.
4598 */
4599 static void
4603 {
4607 HeapTuple newtup;
4608 SysScanDesc scan;
4610 HeapTuple domainTup;
4612 /* Since this function recurses, it could be driven to stack overflow */
4615 /* Update the current type's tuple */
4621 {
4624 }
4626 {
4629 }
4631 {
4634 }
4636 {
4639 }
4641 {
4644 }
4646 {
4649 }
4651 {
4654 }
4661 /* Rebuild dependencies for this type */
4663 catalog,
4674 /*
4675 * Arrays inherit their base type's typmodin and typmodout, but none of
4676 * the other properties we're concerned with here. Recurse to the array
4677 * type if needed.
4678 */
4681 {
4685 {
4686 HeapTuple arrtup;
4687 AlterTypeRecurseParams arrparams;
4702 }
4703 }
4705 /*
4706 * Now we need to recurse to domains. However, some properties are not
4707 * inherited by domains, so clear the update flags for those.
4708 */
4714 /* Skip the scan if nothing remains to be done */
4720 /* Search pg_type for possible domains over this type */
4722 Anum_pg_type_typbasetype,
4730 {
4733 /*
4734 * Shouldn't have a nonzero typbasetype in a non-domain, but let's
4735 * check
4736 */
4741 }
4744 }