| blob | a1c009d4a9706af23ddd3cc79c1f8bc1bc307482 |
1 /*-------------------------------------------------------------------------
2 *
3 * typecmds.c
4 * Routines for SQL commands that manipulate types (and domains).
5 *
6 * Portions Copyright (c) 1996-2008, 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;
118 Oid inputOid;
119 Oid outputOid;
126 Oid array_oid;
128 Oid typoid;
129 Oid resulttype;
130 Relation pg_type;
132 /*
133 * As of Postgres 8.4, we require superuser privilege to create a base
134 * type. This is simple paranoia: there are too many ways to mess up the
135 * system with an incorrect type definition (for instance, representation
136 * parameters that don't match what the C code expects). In practice
137 * it takes superuser privilege to create the I/O functions, and so the
138 * former requirement that you own the I/O functions pretty much forced
139 * superuserness anyway. We're just making doubly sure here.
140 *
141 * XXX re-enable NOT_USED code sections below if you remove this test.
142 */
148 /* Convert list of names to a name and namespace */
151 #ifdef NOT_USED
152 /* XXX this is unnecessary given the superuser check above */
153 /* Check we have creation rights in target namespace */
158 #endif
160 /*
161 * Look to see if type already exists (presumably as a shell; if not,
162 * TypeCreate will complain).
163 */
169 /*
170 * If it's not a shell, see if it's an autogenerated array type, and if so
171 * rename it out of the way.
172 */
174 {
177 }
179 /*
180 * If it doesn't exist, create it as a shell, so that the OID is known for
181 * use in the I/O function definitions.
182 */
184 {
186 /* Make new shell type visible for modification below */
189 /*
190 * If the command was a parameterless CREATE TYPE, we're done ---
191 * creating the shell type was all we're supposed to do.
192 */
195 }
196 else
197 {
198 /* Complain if dummy CREATE TYPE and entry already exists */
203 }
206 {
227 {
231 /* restrict to non-control ASCII */
236 p)));
237 }
241 {
245 /* XXX shouldn't we restrict the delimiter? */
246 }
248 {
250 /* disallow arrays of pseudotypes */
256 }
262 {
265 /*
266 * Note: if argument was an unquoted identifier, parser will have
267 * applied translations to it, so be prepared to recognize
268 * translated type names as well as the nominal form.
269 */
283 else
287 }
289 {
300 else
304 }
305 else
310 }
312 /*
313 * make sure we have our required definitions
314 */
329 /*
330 * Convert I/O proc names to OIDs
331 */
339 /*
340 * Verify that I/O procs return the expected thing. If we see OPAQUE,
341 * complain and change it to the correct type-safe choice.
342 */
345 {
347 {
348 /* backwards-compatibility hack */
353 }
354 else
359 }
362 {
364 {
365 /* backwards-compatibility hack */
370 }
371 else
376 }
378 {
385 }
387 {
394 }
396 /*
397 * Convert typmodin/out function proc names to OIDs.
398 */
404 /*
405 * Convert analysis function proc name to an OID. If no analysis function
406 * is specified, we'll use zero to select the built-in default algorithm.
407 */
411 /*
412 * Check permissions on functions. We choose to require the creator/owner
413 * of a type to also own the underlying functions. Since creating a type
414 * is tantamount to granting public execute access on the functions, the
415 * minimum sane check would be for execute-with-grant-option. But we
416 * don't have a way to make the type go away if the grant option is
417 * revoked, so ownership seems better.
418 */
419 #ifdef NOT_USED
420 /* XXX this is unnecessary given the superuser check above */
442 #endif
444 /* Preassign array type OID so we can insert it in pg_type.typarray */
449 /*
450 * now have TypeCreate do all the real work.
451 */
452 typoid =
483 /*
484 * Create the array type that goes with it.
485 */
488 /* alignment must be 'i' or 'd' for arrays */
522 }
525 /*
526 * RemoveTypes
527 * Implements DROP TYPE and DROP DOMAIN
528 *
529 * Note: if DOMAIN is specified, we enforce that each type is a domain, but
530 * we don't enforce the converse for DROP TYPE
531 */
532 void
534 {
538 /*
539 * First we identify all the types, then we delete them in a single
540 * performMultipleDeletions() call. This is to avoid unwanted
541 * DROP RESTRICT errors if one of the types depends on another.
542 */
546 {
549 Oid typeoid;
550 HeapTuple tup;
551 ObjectAddress object;
552 Form_pg_type typ;
554 /* Make a TypeName so we can use standard type lookup machinery */
557 /* Use LookupTypeName here so that shell types can be removed. */
560 {
562 {
567 }
568 else
569 {
573 }
575 }
580 /* Permission check: must own type or its namespace */
587 {
588 /* Check that this is actually a domain */
594 }
596 /*
597 * Note: we need no special check for array types here, as the normal
598 * treatment of internal dependencies handles it just fine
599 */
608 }
613 }
616 /*
617 * Guts of type deletion.
618 */
619 void
621 {
622 Relation relation;
623 HeapTuple tup;
635 /*
636 * If it is an enum, delete the pg_enum entries too; we don't bother with
637 * making dependency entries for those, so it has to be done "by hand"
638 * here.
639 */
646 }
649 /*
650 * DefineDomain
651 * Registers a new domain.
652 */
653 void
655 {
657 Oid domainNamespace;
658 AclResult aclresult;
659 int16 internalLength;
660 Oid inputProcedure;
661 Oid outputProcedure;
662 Oid receiveProcedure;
663 Oid sendProcedure;
664 Oid analyzeProcedure;
666 Oid typelem;
672 Datum datum;
680 HeapTuple typeTup;
683 Oid basetypeoid;
684 Oid domainoid;
685 Oid old_type_oid;
686 Form_pg_type baseType;
687 int32 basetypeMod;
689 /* Convert list of names to a name and namespace */
693 /* Check we have creation rights in target namespace */
695 ACL_CREATE);
700 /*
701 * Check for collision with an existing type name. If there is one and
702 * it's an autogenerated array, we can rename it out of the way.
703 */
709 {
714 }
716 /*
717 * Look up the base type.
718 */
723 /*
724 * Base type must be a plain base type, another domain or an enum. Domains
725 * over pseudotypes would create a security hole. Domains over composite
726 * types might be made to work in the future, but not today.
727 */
737 /* passed by value */
740 /* Required Alignment */
743 /* TOAST Strategy */
746 /* Storage Length */
749 /* Type Category */
752 /* Array element type (in case base type is an array) */
755 /* Array element Delimiter */
758 /* I/O Functions */
764 /* Domains never accept typmods, so no typmodin/typmodout needed */
766 /* Analysis function */
769 /* Inherited default value */
775 /* Inherited default binary value */
781 /*
782 * Run through constraints manually to avoid the additional processing
783 * conducted by DefineRelation() and friends.
784 */
786 {
790 /* Check for unsupported constraint types */
796 /* otherwise it should be a plain Constraint */
804 {
807 /*
808 * The inherited default value may be overridden by the user
809 * with the DEFAULT <expr> clause ... but only once.
810 */
818 {
822 /* Create a dummy ParseState for transformExpr */
825 /*
826 * Cook the constr->raw_expr into an expression. Note:
827 * name is strictly for error message
828 */
830 basetypeoid,
831 basetypeMod,
832 domainName);
834 /*
835 * If the expression is just a NULL constant, we treat it
836 * like not having a default.
837 *
838 * Note that if the basetype is another domain, we'll see
839 * a CoerceToDomain expr here and not discard the default.
840 * This is critical because the domain default needs to be
841 * retained to override any default that the base domain
842 * might have.
843 */
847 {
850 }
851 else
852 {
853 /*
854 * Expression must be stored as a nodeToString result,
855 * but we also require a valid textual representation
856 * (mainly to make life easier for pg_dump).
857 */
858 defaultValue =
861 InvalidOid),
864 }
865 }
866 else
867 {
868 /* No default (can this still happen?) */
871 }
894 /*
895 * Check constraints are handled after domain creation, as
896 * they require the Oid of the domain
897 */
900 /*
901 * All else are error cases
902 */
928 }
929 }
931 /*
932 * Have TypeCreate do all the real work.
933 */
934 domainoid =
965 /*
966 * Process constraints which refer to the domain ID returned by TypeCreate
967 */
969 {
972 /* it must be a Constraint, per check above */
975 {
982 /* Other constraint types were fully processed above */
986 }
988 /* CCI so we can detect duplicate constraint names */
990 }
992 /*
993 * Now we can clean up.
994 */
996 }
999 /*
1000 * DefineEnum
1001 * Registers a new enum.
1002 */
1003 void
1005 {
1008 Oid enumNamespace;
1009 Oid enumTypeOid;
1010 AclResult aclresult;
1011 Oid old_type_oid;
1012 Oid enumArrayOid;
1013 Relation pg_type;
1015 /* Convert list of names to a name and namespace */
1019 /* Check we have creation rights in target namespace */
1025 /*
1026 * Check for collision with an existing type name. If there is one and
1027 * it's an autogenerated array, we can rename it out of the way.
1028 */
1034 {
1039 }
1041 /* Preassign array type OID so we can insert it in pg_type.typarray */
1046 /* Create the pg_type entry */
1047 enumTypeOid =
1078 /* Enter the enum's values into pg_enum */
1081 /*
1082 * Create the array type that goes with it.
1083 */
1117 }
1120 /*
1121 * Find suitable I/O functions for a type.
1122 *
1123 * typeOid is the type's OID (which will already exist, if only as a shell
1124 * type).
1125 */
1127 static Oid
1129 {
1131 Oid procOid;
1133 /*
1134 * Input functions can take a single argument of type CSTRING, or three
1135 * arguments (string, typioparam OID, typmod).
1136 *
1137 * For backwards compatibility we allow OPAQUE in place of CSTRING; if we
1138 * see this, we issue a warning and fix up the pg_proc entry.
1139 */
1153 /* No luck, try it with OPAQUE */
1159 {
1164 }
1167 {
1168 /* Found, but must complain and fix the pg_proc entry */
1174 /*
1175 * Need CommandCounterIncrement since DefineType will likely try to
1176 * alter the pg_proc tuple again.
1177 */
1181 }
1183 /* Use CSTRING (preferred) in the error message */
1192 }
1194 static Oid
1196 {
1198 Oid procOid;
1200 /*
1201 * Output functions can take a single argument of the type.
1202 *
1203 * For backwards compatibility we allow OPAQUE in place of the actual type
1204 * name; if we see this, we issue a warning and fix up the pg_proc entry.
1205 */
1212 /* No luck, try it with OPAQUE */
1218 {
1219 /* Found, but must complain and fix the pg_proc entry */
1225 /*
1226 * Need CommandCounterIncrement since DefineType will likely try to
1227 * alter the pg_proc tuple again.
1228 */
1232 }
1234 /* Use type name, not OPAQUE, in the failure message. */
1243 }
1245 static Oid
1247 {
1249 Oid procOid;
1251 /*
1252 * Receive functions can take a single argument of type INTERNAL, or three
1253 * arguments (internal, typioparam OID, typmod).
1254 */
1274 }
1276 static Oid
1278 {
1280 Oid procOid;
1282 /*
1283 * Send functions can take a single argument of the type.
1284 */
1297 }
1299 static Oid
1301 {
1303 Oid procOid;
1305 /*
1306 * typmodin functions always take one cstring[] argument and return int4.
1307 */
1324 }
1326 static Oid
1328 {
1330 Oid procOid;
1332 /*
1333 * typmodout functions always take one int4 argument and return cstring.
1334 */
1351 }
1353 static Oid
1355 {
1357 Oid procOid;
1359 /*
1360 * Analyze functions always take one INTERNAL argument and return bool.
1361 */
1378 }
1381 /*-------------------------------------------------------------------
1382 * DefineCompositeType
1383 *
1384 * Create a Composite Type relation.
1385 * `DefineRelation' does all the work, we just provide the correct
1386 * arguments!
1387 *
1388 * If the relation already exists, then 'DefineRelation' will abort
1389 * the xact...
1390 *
1391 * DefineCompositeType returns relid for use when creating
1392 * an implicit composite type during function creation
1393 *-------------------------------------------------------------------
1394 */
1395 Oid
1397 {
1405 /*
1406 * now set the parameters for keys/inheritance etc. All of these are
1407 * uninteresting for composite types...
1408 */
1417 /*
1418 * finally create the relation...
1419 */
1421 }
1423 /*
1424 * AlterDomainDefault
1425 *
1426 * Routine implementing ALTER DOMAIN SET/DROP DEFAULT statements.
1427 */
1428 void
1430 {
1432 Oid domainoid;
1433 HeapTuple tup;
1435 Relation rel;
1441 HeapTuple newtuple;
1442 Form_pg_type typTup;
1444 /* Make a TypeName so we can use standard type lookup machinery */
1448 /* Look up the domain in the type table */
1458 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1461 /* Setup new tuple */
1466 /* Store the new default into the tuple */
1468 {
1469 /* Create a dummy ParseState for transformExpr */
1472 /*
1473 * Cook the colDef->raw_expr into an expression. Note: Name is
1474 * strictly for error message
1475 */
1481 /*
1482 * If the expression is just a NULL constant, we treat the command
1483 * like ALTER ... DROP DEFAULT. (But see note for same test in
1484 * DefineDomain.)
1485 */
1488 {
1489 /* Default is NULL, drop it */
1494 }
1495 else
1496 {
1497 /*
1498 * Expression must be stored as a nodeToString result, but we also
1499 * require a valid textual representation (mainly to make life
1500 * easier for pg_dump).
1501 */
1504 InvalidOid),
1507 /*
1508 * Form an updated tuple with the new default and write it back.
1509 */
1515 }
1516 }
1517 else
1518 {
1519 /* ALTER ... DROP DEFAULT */
1524 }
1528 new_record_repl);
1534 /* Rebuild dependencies */
1536 domainoid,
1550 defaultExpr,
1553 /* Clean up */
1556 }
1558 /*
1559 * AlterDomainNotNull
1560 *
1561 * Routine implementing ALTER DOMAIN SET/DROP NOT NULL statements.
1562 */
1563 void
1565 {
1567 Oid domainoid;
1568 Relation typrel;
1569 HeapTuple tup;
1570 Form_pg_type typTup;
1572 /* Make a TypeName so we can use standard type lookup machinery */
1576 /* Look up the domain in the type table */
1586 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1589 /* Is the domain already set to the desired constraint? */
1591 {
1594 }
1596 /* Adding a NOT NULL constraint requires checking existing columns */
1598 {
1602 /* Fetch relation list with attributes based on this domain */
1603 /* ShareLock is sufficient to prevent concurrent data changes */
1608 {
1612 HeapScanDesc scan;
1613 HeapTuple tuple;
1615 /* Scan all tuples in this relation */
1618 {
1621 /* Test attributes that are of the domain */
1623 {
1632 }
1633 }
1636 /* Close each rel after processing, but keep lock */
1638 }
1639 }
1641 /*
1642 * Okay to update pg_type row. We can scribble on typTup because it's a
1643 * copy.
1644 */
1651 /* Clean up */
1654 }
1656 /*
1657 * AlterDomainDropConstraint
1658 *
1659 * Implements the ALTER DOMAIN DROP CONSTRAINT statement
1660 */
1661 void
1663 DropBehavior behavior)
1664 {
1666 Oid domainoid;
1667 HeapTuple tup;
1668 Relation rel;
1669 Relation conrel;
1670 SysScanDesc conscan;
1672 HeapTuple contup;
1674 /* Make a TypeName so we can use standard type lookup machinery */
1678 /* Look up the domain in the type table */
1687 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1690 /* Grab an appropriate lock on the pg_constraint relation */
1693 /* Use the index to scan only constraints of the target relation */
1695 Anum_pg_constraint_contypid,
1702 /*
1703 * Scan over the result set, removing any matching entries.
1704 */
1706 {
1710 {
1711 ObjectAddress conobj;
1718 }
1719 }
1720 /* Clean up after the scan */
1725 }
1727 /*
1728 * AlterDomainAddConstraint
1729 *
1730 * Implements the ALTER DOMAIN .. ADD CONSTRAINT statement.
1731 */
1732 void
1734 {
1736 Oid domainoid;
1737 Relation typrel;
1738 HeapTuple tup;
1739 Form_pg_type typTup;
1749 /* Make a TypeName so we can use standard type lookup machinery */
1753 /* Look up the domain in the type table */
1763 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1766 /* Check for unsupported constraint types */
1772 /* otherwise it should be a plain Constraint */
1780 {
1782 /* processed below */
1810 }
1812 /*
1813 * Since all other constraint types throw errors, this must be a check
1814 * constraint. First, process the constraint expression and add an entry
1815 * to pg_constraint.
1816 */
1822 /*
1823 * Test all values stored in the attributes based on the domain the
1824 * constraint is being added to.
1825 */
1828 /* Need an EState to run ExecEvalExpr */
1832 /* build execution state for expr */
1835 /* Fetch relation list with attributes based on this domain */
1836 /* ShareLock is sufficient to prevent concurrent data changes */
1841 {
1845 HeapScanDesc scan;
1846 HeapTuple tuple;
1848 /* Scan all tuples in this relation */
1851 {
1854 /* Test attributes that are of the domain */
1856 {
1858 Datum d;
1860 Datum conResult;
1868 econtext,
1877 }
1880 }
1883 /* Hold relation lock till commit (XXX bad for concurrency) */
1885 }
1889 /* Clean up */
1891 }
1893 /*
1894 * get_rels_with_domain
1895 *
1896 * Fetch all relations / attributes which are using the domain
1897 *
1898 * The result is a list of RelToCheck structs, one for each distinct
1899 * relation, each containing one or more attribute numbers that are of
1900 * the domain type. We have opened each rel and acquired the specified lock
1901 * type on it.
1902 *
1903 * We support nested domains by including attributes that are of derived
1904 * domain types. Current callers do not need to distinguish between attributes
1905 * that are of exactly the given domain and those that are of derived domains.
1906 *
1907 * XXX this is completely broken because there is no way to lock the domain
1908 * to prevent columns from being added or dropped while our command runs.
1909 * We can partially protect against column drops by locking relations as we
1910 * come across them, but there is still a race condition (the window between
1911 * seeing a pg_depend entry and acquiring lock on the relation it references).
1912 * Also, holding locks on all these relations simultaneously creates a non-
1913 * trivial risk of deadlock. We can minimize but not eliminate the deadlock
1914 * risk by using the weakest suitable lock (ShareLock for most callers).
1915 *
1916 * XXX the API for this is not sufficient to support checking domain values
1917 * that are inside composite types or arrays. Currently we just error out
1918 * if a composite type containing the target domain is stored anywhere.
1919 * There are not currently arrays of domains; if there were, we could take
1920 * the same approach, but it'd be nicer to fix it properly.
1921 *
1922 * Generally used for retrieving a list of tests when adding
1923 * new constraints to a domain.
1924 */
1927 {
1929 Relation depRel;
1931 SysScanDesc depScan;
1932 HeapTuple depTup;
1936 /*
1937 * We scan pg_depend to find those things that depend on the domain. (We
1938 * assume we can ignore refobjsubid for a domain.)
1939 */
1943 Anum_pg_depend_refclassid,
1947 Anum_pg_depend_refobjid,
1955 {
1959 Form_pg_attribute pg_att;
1962 /* Check for directly dependent types --- must be domains */
1964 {
1967 /*
1968 * Recursively add dependent columns to the output list. This is
1969 * a bit inefficient since we may fail to combine RelToCheck
1970 * entries when attributes of the same rel have different derived
1971 * domain types, but it's probably not worth improving.
1972 */
1975 lockmode));
1977 }
1979 /* Else, ignore dependees that aren't user columns of relations */
1980 /* (we assume system columns are never of domain types) */
1985 /* See if we already have an entry for this relation */
1987 {
1991 {
1994 }
1995 }
1998 {
1999 /* First attribute found for this relation */
2000 Relation rel;
2002 /* Acquire requested lock on relation */
2005 /*
2006 * Check to see if rowtype is stored anyplace as a composite-type
2007 * column; if so we have to fail, for now anyway.
2008 */
2011 NULL,
2014 /* Otherwise we can ignore views, composite types, etc */
2016 {
2019 }
2021 /* Build the RelToCheck entry with enough space for all atts */
2027 }
2029 /*
2030 * Confirm column has not been dropped, and is of the expected type.
2031 * This defends against an ALTER DROP COLUMN occuring just before we
2032 * acquired lock ... but if the whole table were dropped, we'd still
2033 * have a problem.
2034 */
2041 /*
2042 * Okay, add column to result. We store the columns in column-number
2043 * order; this is just a hack to improve predictability of regression
2044 * test output ...
2045 */
2050 {
2052 ptr--;
2053 }
2055 }
2062 }
2064 /*
2065 * checkDomainOwner
2066 *
2067 * Check that the type is actually a domain and that the current user
2068 * has permission to do ALTER DOMAIN on it. Throw an error if not.
2069 */
2070 static void
2072 {
2075 /* Check that this is actually a domain */
2082 /* Permission check: must own type */
2086 }
2088 /*
2089 * domainAddConstraint - code shared between CREATE and ALTER DOMAIN
2090 */
2095 {
2102 /*
2103 * Assign or validate constraint name
2104 */
2106 {
2108 domainOid,
2109 domainNamespace,
2115 }
2116 else
2118 NULL,
2120 domainNamespace,
2121 NIL);
2123 /*
2124 * Convert the A_EXPR in raw_expr into an EXPR
2125 */
2128 /*
2129 * Set up a CoerceToDomainValue to represent the occurrence of VALUE in
2130 * the expression. Note that it will appear to have the type of the base
2131 * type, not the domain. This seems correct since within the check
2132 * expression, we should not assume the input value can be considered a
2133 * member of the domain.
2134 */
2144 /*
2145 * Make sure it yields a boolean result.
2146 */
2149 /*
2150 * Make sure no outside relations are referred to.
2151 */
2157 /*
2158 * Domains don't allow var clauses (this should be redundant with the
2159 * above check, but make it anyway)
2160 */
2166 /*
2167 * No subplans or aggregates, either...
2168 */
2178 /*
2179 * Convert to string form for storage.
2180 */
2183 /*
2184 * Deparse it to produce text for consrc.
2185 *
2186 * Since VARNOs aren't allowed in domain constraints, relation context
2187 * isn't required as anything other than a shell.
2188 */
2191 InvalidOid),
2194 /*
2195 * Store the constraint in pg_constraint
2196 */
2203 NULL,
2207 NULL,
2208 NULL,
2209 NULL,
2210 NULL,
2215 InvalidOid,
2222 /*
2223 * Return the compiled constraint expression so the calling routine can
2224 * perform any additional required tests.
2225 */
2227 }
2229 /*
2230 * GetDomainConstraints - get a list of the current constraints of domain
2231 *
2232 * Returns a possibly-empty list of DomainConstraintState nodes.
2233 *
2234 * This is called by the executor during plan startup for a CoerceToDomain
2235 * expression node. The given constraints will be checked for each value
2236 * passed through the node.
2237 *
2238 * We allow this to be called for non-domain types, in which case the result
2239 * is always NIL.
2240 */
2241 List *
2243 {
2246 Relation conRel;
2251 {
2252 HeapTuple tup;
2253 HeapTuple conTup;
2254 Form_pg_type typTup;
2256 SysScanDesc scan;
2266 {
2267 /* Not a domain, so done */
2270 }
2272 /* Test for NOT NULL Constraint */
2276 /* Look for CHECK Constraints on this domain */
2278 Anum_pg_constraint_contypid,
2286 {
2288 Datum val;
2293 /* Ignore non-CHECK constraints (presently, shouldn't be any) */
2297 /*
2298 * Not expecting conbin to be NULL, but we'll test for it anyway
2299 */
2308 /* ExecInitExpr assumes we already fixed opfuncids */
2316 /*
2317 * use lcons() here because constraints of lower domains should be
2318 * applied earlier.
2319 */
2321 }
2325 /* loop to next domain in stack */
2328 }
2332 /*
2333 * Only need to add one NOT NULL check regardless of how many domains in
2334 * the stack request it.
2335 */
2337 {
2344 /* lcons to apply the nullness check FIRST */
2346 }
2349 }
2352 /*
2353 * Execute ALTER TYPE RENAME
2354 */
2355 void
2357 {
2359 Oid typeOid;
2360 Relation rel;
2361 HeapTuple tup;
2362 Form_pg_type typTup;
2364 /* Make a TypeName so we can use standard type lookup machinery */
2368 /* Look up the type in the type table */
2378 /* check permissions on type */
2383 /*
2384 * If it's a composite type, we need to check that it really is a
2385 * free-standing composite type, and not a table's rowtype. We
2386 * want people to use ALTER TABLE not ALTER TYPE for that case.
2387 */
2396 /* don't allow direct alteration of array types, either */
2406 /*
2407 * If type is composite we need to rename associated pg_class entry too.
2408 * RenameRelationInternal will call RenameTypeInternal automatically.
2409 */
2413 else
2417 /* Clean up */
2419 }
2421 /*
2422 * Change the owner of a type.
2423 */
2424 void
2426 {
2428 Oid typeOid;
2429 Relation rel;
2430 HeapTuple tup;
2431 HeapTuple newtup;
2432 Form_pg_type typTup;
2433 AclResult aclresult;
2437 /* Make a TypeName so we can use standard type lookup machinery */
2440 /* Use LookupTypeName here so that shell types can be processed */
2449 /* Copy the syscache entry so we can scribble on it below */
2455 /*
2456 * If it's a composite type, we need to check that it really is a
2457 * free-standing composite type, and not a table's rowtype. We want people
2458 * to use ALTER TABLE not ALTER TYPE for that case.
2459 */
2468 /* don't allow direct alteration of array types, either */
2478 /*
2479 * If the new owner is the same as the existing owner, consider the
2480 * command to have succeeded. This is for dump restoration purposes.
2481 */
2483 {
2484 /* Superusers can always do it */
2486 {
2487 /* Otherwise, must be owner of the existing object */
2492 /* Must be able to become new owner */
2495 /* New owner must have CREATE privilege on namespace */
2497 newOwnerId,
2498 ACL_CREATE);
2502 }
2504 /*
2505 * If it's a composite type, invoke ATExecChangeOwner so that we fix
2506 * up the pg_class entry properly. That will call back to
2507 * AlterTypeOwnerInternal to take care of the pg_type entry(s).
2508 */
2511 else
2512 {
2513 /*
2514 * We can just apply the modification directly.
2515 *
2516 * okay to scribble on typTup because it's a copy
2517 */
2524 /* Update owner dependency reference */
2527 /* If it has an array type, update that too */
2530 }
2531 }
2533 /* Clean up */
2535 }
2537 /*
2538 * AlterTypeOwnerInternal - change type owner unconditionally
2539 *
2540 * This is currently only used to propagate ALTER TABLE/TYPE OWNER to a
2541 * table's rowtype or an array type, and to implement REASSIGN OWNED BY.
2542 * It assumes the caller has done all needed checks. The function will
2543 * automatically recurse to an array type if the type has one.
2544 *
2545 * hasDependEntry should be TRUE if type is expected to have a pg_shdepend
2546 * entry (ie, it's not a table rowtype nor an array type).
2547 */
2548 void
2551 {
2552 Relation rel;
2553 HeapTuple tup;
2554 Form_pg_type typTup;
2565 /*
2566 * Modify the owner --- okay to scribble on typTup because it's a copy
2567 */
2574 /* Update owner dependency reference, if it has one */
2578 /* If it has an array type, update that too */
2582 /* Clean up */
2584 }
2586 /*
2587 * Execute ALTER TYPE SET SCHEMA
2588 */
2589 void
2591 {
2593 Oid typeOid;
2594 Oid nspOid;
2595 Oid elemOid;
2597 /* Make a TypeName so we can use standard type lookup machinery */
2601 /* check permissions on type */
2606 /* get schema OID and check its permissions */
2609 /* don't allow direct alteration of array types */
2619 /* and do the work */
2621 }
2623 /*
2624 * Move specified type to new namespace.
2625 *
2626 * Caller must have already checked privileges.
2627 *
2628 * The function automatically recurses to process the type's array type,
2629 * if any. isImplicitArray should be TRUE only when doing this internal
2630 * recursion (outside callers must never try to move an array type directly).
2631 *
2632 * If errorOnTableType is TRUE, the function errors out if the type is
2633 * a table type. ALTER TABLE has to be used to move a table to a new
2634 * namespace.
2635 */
2636 void
2640 {
2641 Relation rel;
2642 HeapTuple tup;
2643 Form_pg_type typform;
2644 Oid oldNspOid;
2645 Oid arrayOid;
2667 /* disallow renaming into or out of temp schemas */
2673 /* same for TOAST schema */
2679 /* check for duplicate name (more friendly than unique-index failure) */
2690 /* Detect whether type is a composite type (but not a table rowtype) */
2691 isCompositeType =
2695 /* Enforce not-table-type if requested */
2697 errorOnTableType)
2704 /* OK, modify the pg_type row */
2706 /* tup is a copy, so we can scribble directly on it */
2712 /*
2713 * Composite types have pg_class entries.
2714 *
2715 * We need to modify the pg_class tuple as well to reflect the change of
2716 * schema.
2717 */
2719 {
2720 Relation classRel;
2730 /*
2731 * Check for constraints associated with the composite type (we don't
2732 * currently support this, but probably will someday).
2733 */
2736 }
2737 else
2738 {
2739 /* If it's a domain, it might have constraints */
2742 }
2744 /*
2745 * Update dependency on schema, if any --- a table rowtype has not got
2746 * one, and neither does an implicit array.
2747 */
2759 /* Recursively alter the associated array type, if any */
2762 }