| blob | 528a9172346d2f21cb12a9072be11f2da0161fec |
1 /*-------------------------------------------------------------------------
2 *
3 * typecmds.c
4 * Routines for SQL commands that manipulate types (and domains).
5 *
6 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
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 "FooDefine" routines (in src/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 */
68 /* result structure for get_rels_with_domain() */
70 {
74 /* atts[] is of allocated length RelationGetNumberOfAttributes(rel) */
88 Oid baseTypeOid,
93 /*
94 * DefineType
95 * Registers a new base type.
96 */
97 void
99 {
101 Oid typeNamespace;
135 Oid inputOid;
136 Oid outputOid;
143 Oid array_oid;
144 Oid typoid;
145 Oid resulttype;
146 Relation pg_type;
149 /*
150 * As of Postgres 8.4, we require superuser privilege to create a base
151 * type. This is simple paranoia: there are too many ways to mess up the
152 * system with an incorrect type definition (for instance, representation
153 * parameters that don't match what the C code expects). In practice it
154 * takes superuser privilege to create the I/O functions, and so the
155 * former requirement that you own the I/O functions pretty much forced
156 * superuserness anyway. We're just making doubly sure here.
157 *
158 * XXX re-enable NOT_USED code sections below if you remove this test.
159 */
165 /* Convert list of names to a name and namespace */
168 #ifdef NOT_USED
169 /* XXX this is unnecessary given the superuser check above */
170 /* Check we have creation rights in target namespace */
175 #endif
177 /*
178 * Look to see if type already exists (presumably as a shell; if not,
179 * TypeCreate will complain).
180 */
186 /*
187 * If it's not a shell, see if it's an autogenerated array type, and if so
188 * rename it out of the way.
189 */
191 {
194 }
196 /*
197 * If it doesn't exist, create it as a shell, so that the OID is known for
198 * use in the I/O function definitions.
199 */
201 {
203 /* Make new shell type visible for modification below */
206 /*
207 * If the command was a parameterless CREATE TYPE, we're done ---
208 * creating the shell type was all we're supposed to do.
209 */
212 }
213 else
214 {
215 /* Complain if dummy CREATE TYPE and entry already exists */
220 }
222 /* Extract the parameters from the parameter list */
224 {
263 else
264 {
265 /* WARNING, not ERROR, for historical backwards-compatibility */
271 }
277 }
279 /*
280 * Now interpret the options; we do this separately so that LIKE can be
281 * overridden by other options regardless of the ordering in the parameter
282 * list.
283 */
285 {
286 Type likeType;
287 Form_pg_type likeForm;
296 }
314 {
318 /* restrict to non-control ASCII */
323 p)));
324 }
328 {
332 /* XXX shouldn't we restrict the delimiter? */
333 }
335 {
337 /* disallow arrays of pseudotypes */
343 }
349 {
352 /*
353 * Note: if argument was an unquoted identifier, parser will have
354 * applied translations to it, so be prepared to recognize translated
355 * type names as well as the nominal form.
356 */
370 else
374 }
376 {
387 else
391 }
393 /*
394 * make sure we have our required definitions
395 */
410 /*
411 * Convert I/O proc names to OIDs
412 */
420 /*
421 * Verify that I/O procs return the expected thing. If we see OPAQUE,
422 * complain and change it to the correct type-safe choice.
423 */
426 {
428 {
429 /* backwards-compatibility hack */
434 }
435 else
440 }
443 {
445 {
446 /* backwards-compatibility hack */
451 }
452 else
457 }
459 {
466 }
468 {
475 }
477 /*
478 * Convert typmodin/out function proc names to OIDs.
479 */
485 /*
486 * Convert analysis function proc name to an OID. If no analysis function
487 * is specified, we'll use zero to select the built-in default algorithm.
488 */
492 /*
493 * Check permissions on functions. We choose to require the creator/owner
494 * of a type to also own the underlying functions. Since creating a type
495 * is tantamount to granting public execute access on the functions, the
496 * minimum sane check would be for execute-with-grant-option. But we
497 * don't have a way to make the type go away if the grant option is
498 * revoked, so ownership seems better.
499 */
500 #ifdef NOT_USED
501 /* XXX this is unnecessary given the superuser check above */
523 #endif
525 /* Preassign array type OID so we can insert it in pg_type.typarray */
530 /*
531 * now have TypeCreate do all the real work.
532 */
533 typoid =
565 /*
566 * Create the array type that goes with it.
567 */
570 /* alignment must be 'i' or 'd' for arrays */
605 }
608 /*
609 * RemoveTypes
610 * Implements DROP TYPE and DROP DOMAIN
611 *
612 * Note: if DOMAIN is specified, we enforce that each type is a domain, but
613 * we don't enforce the converse for DROP TYPE
614 */
615 void
617 {
621 /*
622 * First we identify all the types, then we delete them in a single
623 * performMultipleDeletions() call. This is to avoid unwanted DROP
624 * RESTRICT errors if one of the types depends on another.
625 */
629 {
632 Oid typeoid;
633 HeapTuple tup;
634 ObjectAddress object;
635 Form_pg_type typ;
637 /* Make a TypeName so we can use standard type lookup machinery */
640 /* Use LookupTypeName here so that shell types can be removed. */
643 {
645 {
650 }
651 else
652 {
656 }
658 }
663 /* Permission check: must own type or its namespace */
670 {
671 /* Check that this is actually a domain */
677 }
679 /*
680 * Note: we need no special check for array types here, as the normal
681 * treatment of internal dependencies handles it just fine
682 */
691 }
696 }
699 /*
700 * Guts of type deletion.
701 */
702 void
704 {
705 Relation relation;
706 HeapTuple tup;
718 /*
719 * If it is an enum, delete the pg_enum entries too; we don't bother with
720 * making dependency entries for those, so it has to be done "by hand"
721 * here.
722 */
729 }
732 /*
733 * DefineDomain
734 * Registers a new domain.
735 */
736 void
738 {
740 Oid domainNamespace;
741 AclResult aclresult;
742 int16 internalLength;
743 Oid inputProcedure;
744 Oid outputProcedure;
745 Oid receiveProcedure;
746 Oid sendProcedure;
747 Oid analyzeProcedure;
749 Oid typelem;
755 Datum datum;
763 HeapTuple typeTup;
766 Oid basetypeoid;
767 Oid domainoid;
768 Oid old_type_oid;
769 Form_pg_type baseType;
770 int32 basetypeMod;
772 /* Convert list of names to a name and namespace */
776 /* Check we have creation rights in target namespace */
778 ACL_CREATE);
783 /*
784 * Check for collision with an existing type name. If there is one and
785 * it's an autogenerated array, we can rename it out of the way.
786 */
792 {
797 }
799 /*
800 * Look up the base type.
801 */
806 /*
807 * Base type must be a plain base type, another domain or an enum. Domains
808 * over pseudotypes would create a security hole. Domains over composite
809 * types might be made to work in the future, but not today.
810 */
820 /* passed by value */
823 /* Required Alignment */
826 /* TOAST Strategy */
829 /* Storage Length */
832 /* Type Category */
835 /* Array element type (in case base type is an array) */
838 /* Array element Delimiter */
841 /* I/O Functions */
847 /* Domains never accept typmods, so no typmodin/typmodout needed */
849 /* Analysis function */
852 /* Inherited default value */
858 /* Inherited default binary value */
864 /*
865 * Run through constraints manually to avoid the additional processing
866 * conducted by DefineRelation() and friends.
867 */
869 {
873 /* Check for unsupported constraint types */
879 /* otherwise it should be a plain Constraint */
887 {
890 /*
891 * The inherited default value may be overridden by the user
892 * with the DEFAULT <expr> clause ... but only once.
893 */
901 {
905 /* Create a dummy ParseState for transformExpr */
908 /*
909 * Cook the constr->raw_expr into an expression. Note:
910 * name is strictly for error message
911 */
913 basetypeoid,
914 basetypeMod,
915 domainName);
917 /*
918 * If the expression is just a NULL constant, we treat it
919 * like not having a default.
920 *
921 * Note that if the basetype is another domain, we'll see
922 * a CoerceToDomain expr here and not discard the default.
923 * This is critical because the domain default needs to be
924 * retained to override any default that the base domain
925 * might have.
926 */
930 {
933 }
934 else
935 {
936 /*
937 * Expression must be stored as a nodeToString result,
938 * but we also require a valid textual representation
939 * (mainly to make life easier for pg_dump).
940 */
941 defaultValue =
944 InvalidOid),
947 }
948 }
949 else
950 {
951 /* No default (can this still happen?) */
954 }
977 /*
978 * Check constraints are handled after domain creation, as
979 * they require the Oid of the domain
980 */
983 /*
984 * All else are error cases
985 */
1011 }
1012 }
1014 /*
1015 * Have TypeCreate do all the real work.
1016 */
1017 domainoid =
1049 /*
1050 * Process constraints which refer to the domain ID returned by TypeCreate
1051 */
1053 {
1056 /* it must be a Constraint, per check above */
1059 {
1066 /* Other constraint types were fully processed above */
1070 }
1072 /* CCI so we can detect duplicate constraint names */
1074 }
1076 /*
1077 * Now we can clean up.
1078 */
1080 }
1083 /*
1084 * DefineEnum
1085 * Registers a new enum.
1086 */
1087 void
1089 {
1092 Oid enumNamespace;
1093 Oid enumTypeOid;
1094 AclResult aclresult;
1095 Oid old_type_oid;
1096 Oid enumArrayOid;
1097 Relation pg_type;
1099 /* Convert list of names to a name and namespace */
1103 /* Check we have creation rights in target namespace */
1109 /*
1110 * Check for collision with an existing type name. If there is one and
1111 * it's an autogenerated array, we can rename it out of the way.
1112 */
1118 {
1123 }
1125 /* Preassign array type OID so we can insert it in pg_type.typarray */
1130 /* Create the pg_type entry */
1131 enumTypeOid =
1163 /* Enter the enum's values into pg_enum */
1166 /*
1167 * Create the array type that goes with it.
1168 */
1203 }
1206 /*
1207 * Find suitable I/O functions for a type.
1208 *
1209 * typeOid is the type's OID (which will already exist, if only as a shell
1210 * type).
1211 */
1213 static Oid
1215 {
1217 Oid procOid;
1219 /*
1220 * Input functions can take a single argument of type CSTRING, or three
1221 * arguments (string, typioparam OID, typmod).
1222 *
1223 * For backwards compatibility we allow OPAQUE in place of CSTRING; if we
1224 * see this, we issue a warning and fix up the pg_proc entry.
1225 */
1239 /* No luck, try it with OPAQUE */
1245 {
1250 }
1253 {
1254 /* Found, but must complain and fix the pg_proc entry */
1260 /*
1261 * Need CommandCounterIncrement since DefineType will likely try to
1262 * alter the pg_proc tuple again.
1263 */
1267 }
1269 /* Use CSTRING (preferred) in the error message */
1278 }
1280 static Oid
1282 {
1284 Oid procOid;
1286 /*
1287 * Output functions can take a single argument of the type.
1288 *
1289 * For backwards compatibility we allow OPAQUE in place of the actual type
1290 * name; if we see this, we issue a warning and fix up the pg_proc entry.
1291 */
1298 /* No luck, try it with OPAQUE */
1304 {
1305 /* Found, but must complain and fix the pg_proc entry */
1311 /*
1312 * Need CommandCounterIncrement since DefineType will likely try to
1313 * alter the pg_proc tuple again.
1314 */
1318 }
1320 /* Use type name, not OPAQUE, in the failure message. */
1329 }
1331 static Oid
1333 {
1335 Oid procOid;
1337 /*
1338 * Receive functions can take a single argument of type INTERNAL, or three
1339 * arguments (internal, typioparam OID, typmod).
1340 */
1360 }
1362 static Oid
1364 {
1366 Oid procOid;
1368 /*
1369 * Send functions can take a single argument of the type.
1370 */
1383 }
1385 static Oid
1387 {
1389 Oid procOid;
1391 /*
1392 * typmodin functions always take one cstring[] argument and return int4.
1393 */
1410 }
1412 static Oid
1414 {
1416 Oid procOid;
1418 /*
1419 * typmodout functions always take one int4 argument and return cstring.
1420 */
1437 }
1439 static Oid
1441 {
1443 Oid procOid;
1445 /*
1446 * Analyze functions always take one INTERNAL argument and return bool.
1447 */
1464 }
1467 /*-------------------------------------------------------------------
1468 * DefineCompositeType
1469 *
1470 * Create a Composite Type relation.
1471 * `DefineRelation' does all the work, we just provide the correct
1472 * arguments!
1473 *
1474 * If the relation already exists, then 'DefineRelation' will abort
1475 * the xact...
1476 *
1477 * DefineCompositeType returns relid for use when creating
1478 * an implicit composite type during function creation
1479 *-------------------------------------------------------------------
1480 */
1481 Oid
1483 {
1491 /*
1492 * now set the parameters for keys/inheritance etc. All of these are
1493 * uninteresting for composite types...
1494 */
1503 /*
1504 * finally create the relation...
1505 */
1507 }
1509 /*
1510 * AlterDomainDefault
1511 *
1512 * Routine implementing ALTER DOMAIN SET/DROP DEFAULT statements.
1513 */
1514 void
1516 {
1518 Oid domainoid;
1519 HeapTuple tup;
1521 Relation rel;
1527 HeapTuple newtuple;
1528 Form_pg_type typTup;
1530 /* Make a TypeName so we can use standard type lookup machinery */
1534 /* Look up the domain in the type table */
1544 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1547 /* Setup new tuple */
1552 /* Store the new default into the tuple */
1554 {
1555 /* Create a dummy ParseState for transformExpr */
1558 /*
1559 * Cook the colDef->raw_expr into an expression. Note: Name is
1560 * strictly for error message
1561 */
1567 /*
1568 * If the expression is just a NULL constant, we treat the command
1569 * like ALTER ... DROP DEFAULT. (But see note for same test in
1570 * DefineDomain.)
1571 */
1574 {
1575 /* Default is NULL, drop it */
1580 }
1581 else
1582 {
1583 /*
1584 * Expression must be stored as a nodeToString result, but we also
1585 * require a valid textual representation (mainly to make life
1586 * easier for pg_dump).
1587 */
1590 InvalidOid),
1593 /*
1594 * Form an updated tuple with the new default and write it back.
1595 */
1601 }
1602 }
1603 else
1604 {
1605 /* ALTER ... DROP DEFAULT */
1610 }
1614 new_record_repl);
1620 /* Rebuild dependencies */
1622 domainoid,
1636 defaultExpr,
1639 /* Clean up */
1642 }
1644 /*
1645 * AlterDomainNotNull
1646 *
1647 * Routine implementing ALTER DOMAIN SET/DROP NOT NULL statements.
1648 */
1649 void
1651 {
1653 Oid domainoid;
1654 Relation typrel;
1655 HeapTuple tup;
1656 Form_pg_type typTup;
1658 /* Make a TypeName so we can use standard type lookup machinery */
1662 /* Look up the domain in the type table */
1672 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1675 /* Is the domain already set to the desired constraint? */
1677 {
1680 }
1682 /* Adding a NOT NULL constraint requires checking existing columns */
1684 {
1688 /* Fetch relation list with attributes based on this domain */
1689 /* ShareLock is sufficient to prevent concurrent data changes */
1694 {
1698 HeapScanDesc scan;
1699 HeapTuple tuple;
1701 /* Scan all tuples in this relation */
1704 {
1707 /* Test attributes that are of the domain */
1709 {
1718 }
1719 }
1722 /* Close each rel after processing, but keep lock */
1724 }
1725 }
1727 /*
1728 * Okay to update pg_type row. We can scribble on typTup because it's a
1729 * copy.
1730 */
1737 /* Clean up */
1740 }
1742 /*
1743 * AlterDomainDropConstraint
1744 *
1745 * Implements the ALTER DOMAIN DROP CONSTRAINT statement
1746 */
1747 void
1749 DropBehavior behavior)
1750 {
1752 Oid domainoid;
1753 HeapTuple tup;
1754 Relation rel;
1755 Relation conrel;
1756 SysScanDesc conscan;
1758 HeapTuple contup;
1760 /* Make a TypeName so we can use standard type lookup machinery */
1764 /* Look up the domain in the type table */
1773 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1776 /* Grab an appropriate lock on the pg_constraint relation */
1779 /* Use the index to scan only constraints of the target relation */
1781 Anum_pg_constraint_contypid,
1788 /*
1789 * Scan over the result set, removing any matching entries.
1790 */
1792 {
1796 {
1797 ObjectAddress conobj;
1804 }
1805 }
1806 /* Clean up after the scan */
1811 }
1813 /*
1814 * AlterDomainAddConstraint
1815 *
1816 * Implements the ALTER DOMAIN .. ADD CONSTRAINT statement.
1817 */
1818 void
1820 {
1822 Oid domainoid;
1823 Relation typrel;
1824 HeapTuple tup;
1825 Form_pg_type typTup;
1835 /* Make a TypeName so we can use standard type lookup machinery */
1839 /* Look up the domain in the type table */
1849 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1852 /* Check for unsupported constraint types */
1858 /* otherwise it should be a plain Constraint */
1866 {
1868 /* processed below */
1896 }
1898 /*
1899 * Since all other constraint types throw errors, this must be a check
1900 * constraint. First, process the constraint expression and add an entry
1901 * to pg_constraint.
1902 */
1908 /*
1909 * Test all values stored in the attributes based on the domain the
1910 * constraint is being added to.
1911 */
1914 /* Need an EState to run ExecEvalExpr */
1918 /* build execution state for expr */
1921 /* Fetch relation list with attributes based on this domain */
1922 /* ShareLock is sufficient to prevent concurrent data changes */
1927 {
1931 HeapScanDesc scan;
1932 HeapTuple tuple;
1934 /* Scan all tuples in this relation */
1937 {
1940 /* Test attributes that are of the domain */
1942 {
1944 Datum d;
1946 Datum conResult;
1954 econtext,
1963 }
1966 }
1969 /* Hold relation lock till commit (XXX bad for concurrency) */
1971 }
1975 /* Clean up */
1977 }
1979 /*
1980 * get_rels_with_domain
1981 *
1982 * Fetch all relations / attributes which are using the domain
1983 *
1984 * The result is a list of RelToCheck structs, one for each distinct
1985 * relation, each containing one or more attribute numbers that are of
1986 * the domain type. We have opened each rel and acquired the specified lock
1987 * type on it.
1988 *
1989 * We support nested domains by including attributes that are of derived
1990 * domain types. Current callers do not need to distinguish between attributes
1991 * that are of exactly the given domain and those that are of derived domains.
1992 *
1993 * XXX this is completely broken because there is no way to lock the domain
1994 * to prevent columns from being added or dropped while our command runs.
1995 * We can partially protect against column drops by locking relations as we
1996 * come across them, but there is still a race condition (the window between
1997 * seeing a pg_depend entry and acquiring lock on the relation it references).
1998 * Also, holding locks on all these relations simultaneously creates a non-
1999 * trivial risk of deadlock. We can minimize but not eliminate the deadlock
2000 * risk by using the weakest suitable lock (ShareLock for most callers).
2001 *
2002 * XXX the API for this is not sufficient to support checking domain values
2003 * that are inside composite types or arrays. Currently we just error out
2004 * if a composite type containing the target domain is stored anywhere.
2005 * There are not currently arrays of domains; if there were, we could take
2006 * the same approach, but it'd be nicer to fix it properly.
2007 *
2008 * Generally used for retrieving a list of tests when adding
2009 * new constraints to a domain.
2010 */
2013 {
2015 Relation depRel;
2017 SysScanDesc depScan;
2018 HeapTuple depTup;
2022 /*
2023 * We scan pg_depend to find those things that depend on the domain. (We
2024 * assume we can ignore refobjsubid for a domain.)
2025 */
2029 Anum_pg_depend_refclassid,
2033 Anum_pg_depend_refobjid,
2041 {
2045 Form_pg_attribute pg_att;
2048 /* Check for directly dependent types --- must be domains */
2050 {
2053 /*
2054 * Recursively add dependent columns to the output list. This is
2055 * a bit inefficient since we may fail to combine RelToCheck
2056 * entries when attributes of the same rel have different derived
2057 * domain types, but it's probably not worth improving.
2058 */
2061 lockmode));
2063 }
2065 /* Else, ignore dependees that aren't user columns of relations */
2066 /* (we assume system columns are never of domain types) */
2071 /* See if we already have an entry for this relation */
2073 {
2077 {
2080 }
2081 }
2084 {
2085 /* First attribute found for this relation */
2086 Relation rel;
2088 /* Acquire requested lock on relation */
2091 /*
2092 * Check to see if rowtype is stored anyplace as a composite-type
2093 * column; if so we have to fail, for now anyway.
2094 */
2097 NULL,
2100 /* Otherwise we can ignore views, composite types, etc */
2102 {
2105 }
2107 /* Build the RelToCheck entry with enough space for all atts */
2113 }
2115 /*
2116 * Confirm column has not been dropped, and is of the expected type.
2117 * This defends against an ALTER DROP COLUMN occuring just before we
2118 * acquired lock ... but if the whole table were dropped, we'd still
2119 * have a problem.
2120 */
2127 /*
2128 * Okay, add column to result. We store the columns in column-number
2129 * order; this is just a hack to improve predictability of regression
2130 * test output ...
2131 */
2136 {
2138 ptr--;
2139 }
2141 }
2148 }
2150 /*
2151 * checkDomainOwner
2152 *
2153 * Check that the type is actually a domain and that the current user
2154 * has permission to do ALTER DOMAIN on it. Throw an error if not.
2155 */
2156 static void
2158 {
2161 /* Check that this is actually a domain */
2168 /* Permission check: must own type */
2172 }
2174 /*
2175 * domainAddConstraint - code shared between CREATE and ALTER DOMAIN
2176 */
2181 {
2188 /*
2189 * Assign or validate constraint name
2190 */
2192 {
2194 domainOid,
2195 domainNamespace,
2201 }
2202 else
2204 NULL,
2206 domainNamespace,
2207 NIL);
2209 /*
2210 * Convert the A_EXPR in raw_expr into an EXPR
2211 */
2214 /*
2215 * Set up a CoerceToDomainValue to represent the occurrence of VALUE in
2216 * the expression. Note that it will appear to have the type of the base
2217 * type, not the domain. This seems correct since within the check
2218 * expression, we should not assume the input value can be considered a
2219 * member of the domain.
2220 */
2230 /*
2231 * Make sure it yields a boolean result.
2232 */
2235 /*
2236 * Make sure no outside relations are referred to.
2237 */
2243 /*
2244 * Domains don't allow var clauses (this should be redundant with the
2245 * above check, but make it anyway)
2246 */
2252 /*
2253 * No subplans or aggregates, either...
2254 */
2268 /*
2269 * Convert to string form for storage.
2270 */
2273 /*
2274 * Deparse it to produce text for consrc.
2275 *
2276 * Since VARNOs aren't allowed in domain constraints, relation context
2277 * isn't required as anything other than a shell.
2278 */
2281 InvalidOid),
2284 /*
2285 * Store the constraint in pg_constraint
2286 */
2293 NULL,
2297 NULL,
2298 NULL,
2299 NULL,
2300 NULL,
2305 InvalidOid,
2312 /*
2313 * Return the compiled constraint expression so the calling routine can
2314 * perform any additional required tests.
2315 */
2317 }
2319 /*
2320 * GetDomainConstraints - get a list of the current constraints of domain
2321 *
2322 * Returns a possibly-empty list of DomainConstraintState nodes.
2323 *
2324 * This is called by the executor during plan startup for a CoerceToDomain
2325 * expression node. The given constraints will be checked for each value
2326 * passed through the node.
2327 *
2328 * We allow this to be called for non-domain types, in which case the result
2329 * is always NIL.
2330 */
2331 List *
2333 {
2336 Relation conRel;
2341 {
2342 HeapTuple tup;
2343 HeapTuple conTup;
2344 Form_pg_type typTup;
2346 SysScanDesc scan;
2356 {
2357 /* Not a domain, so done */
2360 }
2362 /* Test for NOT NULL Constraint */
2366 /* Look for CHECK Constraints on this domain */
2368 Anum_pg_constraint_contypid,
2376 {
2378 Datum val;
2383 /* Ignore non-CHECK constraints (presently, shouldn't be any) */
2387 /*
2388 * Not expecting conbin to be NULL, but we'll test for it anyway
2389 */
2398 /* ExecInitExpr assumes we've planned the expression */
2406 /*
2407 * use lcons() here because constraints of lower domains should be
2408 * applied earlier.
2409 */
2411 }
2415 /* loop to next domain in stack */
2418 }
2422 /*
2423 * Only need to add one NOT NULL check regardless of how many domains in
2424 * the stack request it.
2425 */
2427 {
2434 /* lcons to apply the nullness check FIRST */
2436 }
2439 }
2442 /*
2443 * Execute ALTER TYPE RENAME
2444 */
2445 void
2447 {
2449 Oid typeOid;
2450 Relation rel;
2451 HeapTuple tup;
2452 Form_pg_type typTup;
2454 /* Make a TypeName so we can use standard type lookup machinery */
2458 /* Look up the type in the type table */
2468 /* check permissions on type */
2473 /*
2474 * If it's a composite type, we need to check that it really is a
2475 * free-standing composite type, and not a table's rowtype. We want people
2476 * to use ALTER TABLE not ALTER TYPE for that case.
2477 */
2486 /* don't allow direct alteration of array types, either */
2496 /*
2497 * If type is composite we need to rename associated pg_class entry too.
2498 * RenameRelationInternal will call RenameTypeInternal automatically.
2499 */
2503 else
2507 /* Clean up */
2509 }
2511 /*
2512 * Change the owner of a type.
2513 */
2514 void
2516 {
2518 Oid typeOid;
2519 Relation rel;
2520 HeapTuple tup;
2521 HeapTuple newtup;
2522 Form_pg_type typTup;
2523 AclResult aclresult;
2527 /* Make a TypeName so we can use standard type lookup machinery */
2530 /* Use LookupTypeName here so that shell types can be processed */
2539 /* Copy the syscache entry so we can scribble on it below */
2545 /*
2546 * If it's a composite type, we need to check that it really is a
2547 * free-standing composite type, and not a table's rowtype. We want people
2548 * to use ALTER TABLE not ALTER TYPE for that case.
2549 */
2558 /* don't allow direct alteration of array types, either */
2568 /*
2569 * If the new owner is the same as the existing owner, consider the
2570 * command to have succeeded. This is for dump restoration purposes.
2571 */
2573 {
2574 /* Superusers can always do it */
2576 {
2577 /* Otherwise, must be owner of the existing object */
2582 /* Must be able to become new owner */
2585 /* New owner must have CREATE privilege on namespace */
2587 newOwnerId,
2588 ACL_CREATE);
2592 }
2594 /*
2595 * If it's a composite type, invoke ATExecChangeOwner so that we fix
2596 * up the pg_class entry properly. That will call back to
2597 * AlterTypeOwnerInternal to take care of the pg_type entry(s).
2598 */
2601 else
2602 {
2603 /*
2604 * We can just apply the modification directly.
2605 *
2606 * okay to scribble on typTup because it's a copy
2607 */
2614 /* Update owner dependency reference */
2617 /* If it has an array type, update that too */
2620 }
2621 }
2623 /* Clean up */
2625 }
2627 /*
2628 * AlterTypeOwnerInternal - change type owner unconditionally
2629 *
2630 * This is currently only used to propagate ALTER TABLE/TYPE OWNER to a
2631 * table's rowtype or an array type, and to implement REASSIGN OWNED BY.
2632 * It assumes the caller has done all needed checks. The function will
2633 * automatically recurse to an array type if the type has one.
2634 *
2635 * hasDependEntry should be TRUE if type is expected to have a pg_shdepend
2636 * entry (ie, it's not a table rowtype nor an array type).
2637 */
2638 void
2641 {
2642 Relation rel;
2643 HeapTuple tup;
2644 Form_pg_type typTup;
2655 /*
2656 * Modify the owner --- okay to scribble on typTup because it's a copy
2657 */
2664 /* Update owner dependency reference, if it has one */
2668 /* If it has an array type, update that too */
2672 /* Clean up */
2674 }
2676 /*
2677 * Execute ALTER TYPE SET SCHEMA
2678 */
2679 void
2681 {
2683 Oid typeOid;
2684 Oid nspOid;
2685 Oid elemOid;
2687 /* Make a TypeName so we can use standard type lookup machinery */
2691 /* check permissions on type */
2696 /* get schema OID and check its permissions */
2699 /* don't allow direct alteration of array types */
2709 /* and do the work */
2711 }
2713 /*
2714 * Move specified type to new namespace.
2715 *
2716 * Caller must have already checked privileges.
2717 *
2718 * The function automatically recurses to process the type's array type,
2719 * if any. isImplicitArray should be TRUE only when doing this internal
2720 * recursion (outside callers must never try to move an array type directly).
2721 *
2722 * If errorOnTableType is TRUE, the function errors out if the type is
2723 * a table type. ALTER TABLE has to be used to move a table to a new
2724 * namespace.
2725 */
2726 void
2730 {
2731 Relation rel;
2732 HeapTuple tup;
2733 Form_pg_type typform;
2734 Oid oldNspOid;
2735 Oid arrayOid;
2757 /* disallow renaming into or out of temp schemas */
2763 /* same for TOAST schema */
2769 /* check for duplicate name (more friendly than unique-index failure) */
2780 /* Detect whether type is a composite type (but not a table rowtype) */
2781 isCompositeType =
2785 /* Enforce not-table-type if requested */
2787 errorOnTableType)
2794 /* OK, modify the pg_type row */
2796 /* tup is a copy, so we can scribble directly on it */
2802 /*
2803 * Composite types have pg_class entries.
2804 *
2805 * We need to modify the pg_class tuple as well to reflect the change of
2806 * schema.
2807 */
2809 {
2810 Relation classRel;
2820 /*
2821 * Check for constraints associated with the composite type (we don't
2822 * currently support this, but probably will someday).
2823 */
2826 }
2827 else
2828 {
2829 /* If it's a domain, it might have constraints */
2832 }
2834 /*
2835 * Update dependency on schema, if any --- a table rowtype has not got
2836 * one, and neither does an implicit array.
2837 */
2849 /* Recursively alter the associated array type, if any */
2852 }