| blob | ecd54be078e2e09d18410e41ed91562dc4005bf1 |
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 type.
96 */
97 void
99 {
101 Oid typeNamespace;
102 AclResult aclresult;
117 Oid inputOid;
118 Oid outputOid;
125 Oid array_oid;
127 Oid typoid;
128 Oid resulttype;
129 Relation pg_type;
131 /* Convert list of names to a name and namespace */
134 /* Check we have creation rights in target namespace */
140 /*
141 * Look to see if type already exists (presumably as a shell; if not,
142 * TypeCreate will complain).
143 */
149 /*
150 * If it's not a shell, see if it's an autogenerated array type, and if so
151 * rename it out of the way.
152 */
154 {
157 }
159 /*
160 * If it doesn't exist, create it as a shell, so that the OID is known for
161 * use in the I/O function definitions.
162 */
164 {
166 /* Make new shell type visible for modification below */
169 /*
170 * If the command was a parameterless CREATE TYPE, we're done ---
171 * creating the shell type was all we're supposed to do.
172 */
175 }
176 else
177 {
178 /* Complain if dummy CREATE TYPE and entry already exists */
183 }
186 {
209 {
213 }
215 {
217 /* disallow arrays of pseudotypes */
223 }
229 {
232 /*
233 * Note: if argument was an unquoted identifier, parser will have
234 * applied translations to it, so be prepared to recognize
235 * translated type names as well as the nominal form.
236 */
250 else
254 }
256 {
267 else
271 }
272 else
277 }
279 /*
280 * make sure we have our required definitions
281 */
296 /*
297 * Convert I/O proc names to OIDs
298 */
306 /*
307 * Verify that I/O procs return the expected thing. If we see OPAQUE,
308 * complain and change it to the correct type-safe choice.
309 */
312 {
314 {
315 /* backwards-compatibility hack */
320 }
321 else
326 }
329 {
331 {
332 /* backwards-compatibility hack */
337 }
338 else
343 }
345 {
352 }
354 {
361 }
363 /*
364 * Convert typmodin/out function proc names to OIDs.
365 */
371 /*
372 * Convert analysis function proc name to an OID. If no analysis function
373 * is specified, we'll use zero to select the built-in default algorithm.
374 */
378 /*
379 * Check permissions on functions. We choose to require the creator/owner
380 * of a type to also own the underlying functions. Since creating a type
381 * is tantamount to granting public execute access on the functions, the
382 * minimum sane check would be for execute-with-grant-option. But we
383 * don't have a way to make the type go away if the grant option is
384 * revoked, so ownership seems better.
385 */
408 /* Preassign array type OID so we can insert it in pg_type.typarray */
413 /*
414 * now have TypeCreate do all the real work.
415 */
416 typoid =
445 /*
446 * Create the array type that goes with it.
447 */
450 /* alignment must be 'i' or 'd' for arrays */
482 }
485 /*
486 * RemoveTypes
487 * Implements DROP TYPE and DROP DOMAIN
488 *
489 * Note: if DOMAIN is specified, we enforce that each type is a domain, but
490 * we don't enforce the converse for DROP TYPE
491 */
492 void
494 {
498 /*
499 * First we identify all the types, then we delete them in a single
500 * performMultipleDeletions() call. This is to avoid unwanted
501 * DROP RESTRICT errors if one of the types depends on another.
502 */
506 {
509 Oid typeoid;
510 HeapTuple tup;
511 ObjectAddress object;
512 Form_pg_type typ;
514 /* Make a TypeName so we can use standard type lookup machinery */
517 /* Use LookupTypeName here so that shell types can be removed. */
520 {
522 {
527 }
528 else
529 {
533 }
535 }
540 /* Permission check: must own type or its namespace */
547 {
548 /* Check that this is actually a domain */
554 }
556 /*
557 * Note: we need no special check for array types here, as the normal
558 * treatment of internal dependencies handles it just fine
559 */
568 }
573 }
576 /*
577 * Guts of type deletion.
578 */
579 void
581 {
582 Relation relation;
583 HeapTuple tup;
595 /*
596 * If it is an enum, delete the pg_enum entries too; we don't bother with
597 * making dependency entries for those, so it has to be done "by hand"
598 * here.
599 */
606 }
609 /*
610 * DefineDomain
611 * Registers a new domain.
612 */
613 void
615 {
617 Oid domainNamespace;
618 AclResult aclresult;
619 int16 internalLength;
620 Oid inputProcedure;
621 Oid outputProcedure;
622 Oid receiveProcedure;
623 Oid sendProcedure;
624 Oid analyzeProcedure;
626 Oid typelem;
631 Datum datum;
639 HeapTuple typeTup;
642 Oid basetypeoid;
643 Oid domainoid;
644 Oid old_type_oid;
645 Form_pg_type baseType;
646 int32 basetypeMod;
648 /* Convert list of names to a name and namespace */
652 /* Check we have creation rights in target namespace */
654 ACL_CREATE);
659 /*
660 * Check for collision with an existing type name. If there is one and
661 * it's an autogenerated array, we can rename it out of the way.
662 */
668 {
673 }
675 /*
676 * Look up the base type.
677 */
682 /*
683 * Base type must be a plain base type, another domain or an enum. Domains
684 * over pseudotypes would create a security hole. Domains over composite
685 * types might be made to work in the future, but not today.
686 */
696 /* passed by value */
699 /* Required Alignment */
702 /* TOAST Strategy */
705 /* Storage Length */
708 /* Array element type (in case base type is an array) */
711 /* Array element Delimiter */
714 /* I/O Functions */
720 /* Domains never accept typmods, so no typmodin/typmodout needed */
722 /* Analysis function */
725 /* Inherited default value */
731 /* Inherited default binary value */
737 /*
738 * Run through constraints manually to avoid the additional processing
739 * conducted by DefineRelation() and friends.
740 */
742 {
746 /* Check for unsupported constraint types */
752 /* otherwise it should be a plain Constraint */
760 {
763 /*
764 * The inherited default value may be overridden by the user
765 * with the DEFAULT <expr> clause ... but only once.
766 */
774 {
778 /* Create a dummy ParseState for transformExpr */
781 /*
782 * Cook the constr->raw_expr into an expression. Note:
783 * name is strictly for error message
784 */
786 basetypeoid,
787 basetypeMod,
788 domainName);
790 /*
791 * If the expression is just a NULL constant, we treat it
792 * like not having a default.
793 *
794 * Note that if the basetype is another domain, we'll see
795 * a CoerceToDomain expr here and not discard the default.
796 * This is critical because the domain default needs to be
797 * retained to override any default that the base domain
798 * might have.
799 */
803 {
806 }
807 else
808 {
809 /*
810 * Expression must be stored as a nodeToString result,
811 * but we also require a valid textual representation
812 * (mainly to make life easier for pg_dump).
813 */
814 defaultValue =
817 InvalidOid),
820 }
821 }
822 else
823 {
824 /* No default (can this still happen?) */
827 }
850 /*
851 * Check constraints are handled after domain creation, as
852 * they require the Oid of the domain
853 */
856 /*
857 * All else are error cases
858 */
884 }
885 }
887 /*
888 * Have TypeCreate do all the real work.
889 */
890 domainoid =
919 /*
920 * Process constraints which refer to the domain ID returned by TypeCreate
921 */
923 {
926 /* it must be a Constraint, per check above */
929 {
936 /* Other constraint types were fully processed above */
940 }
942 /* CCI so we can detect duplicate constraint names */
944 }
946 /*
947 * Now we can clean up.
948 */
950 }
953 /*
954 * DefineEnum
955 * Registers a new enum.
956 */
957 void
959 {
962 Oid enumNamespace;
963 Oid enumTypeOid;
964 AclResult aclresult;
965 Oid old_type_oid;
966 Oid enumArrayOid;
967 Relation pg_type;
969 /* Convert list of names to a name and namespace */
973 /* Check we have creation rights in target namespace */
979 /*
980 * Check for collision with an existing type name. If there is one and
981 * it's an autogenerated array, we can rename it out of the way.
982 */
988 {
993 }
995 /* Preassign array type OID so we can insert it in pg_type.typarray */
1000 /* Create the pg_type entry */
1001 enumTypeOid =
1030 /* Enter the enum's values into pg_enum */
1033 /*
1034 * Create the array type that goes with it.
1035 */
1067 }
1070 /*
1071 * Find suitable I/O functions for a type.
1072 *
1073 * typeOid is the type's OID (which will already exist, if only as a shell
1074 * type).
1075 */
1077 static Oid
1079 {
1081 Oid procOid;
1083 /*
1084 * Input functions can take a single argument of type CSTRING, or three
1085 * arguments (string, typioparam OID, typmod).
1086 *
1087 * For backwards compatibility we allow OPAQUE in place of CSTRING; if we
1088 * see this, we issue a warning and fix up the pg_proc entry.
1089 */
1103 /* No luck, try it with OPAQUE */
1109 {
1114 }
1117 {
1118 /* Found, but must complain and fix the pg_proc entry */
1124 /*
1125 * Need CommandCounterIncrement since DefineType will likely try to
1126 * alter the pg_proc tuple again.
1127 */
1131 }
1133 /* Use CSTRING (preferred) in the error message */
1142 }
1144 static Oid
1146 {
1148 Oid procOid;
1150 /*
1151 * Output functions can take a single argument of the type.
1152 *
1153 * For backwards compatibility we allow OPAQUE in place of the actual type
1154 * name; if we see this, we issue a warning and fix up the pg_proc entry.
1155 */
1162 /* No luck, try it with OPAQUE */
1168 {
1169 /* Found, but must complain and fix the pg_proc entry */
1175 /*
1176 * Need CommandCounterIncrement since DefineType will likely try to
1177 * alter the pg_proc tuple again.
1178 */
1182 }
1184 /* Use type name, not OPAQUE, in the failure message. */
1193 }
1195 static Oid
1197 {
1199 Oid procOid;
1201 /*
1202 * Receive functions can take a single argument of type INTERNAL, or three
1203 * arguments (internal, typioparam OID, typmod).
1204 */
1224 }
1226 static Oid
1228 {
1230 Oid procOid;
1232 /*
1233 * Send functions can take a single argument of the type.
1234 */
1247 }
1249 static Oid
1251 {
1253 Oid procOid;
1255 /*
1256 * typmodin functions always take one cstring[] argument and return int4.
1257 */
1274 }
1276 static Oid
1278 {
1280 Oid procOid;
1282 /*
1283 * typmodout functions always take one int4 argument and return cstring.
1284 */
1301 }
1303 static Oid
1305 {
1307 Oid procOid;
1309 /*
1310 * Analyze functions always take one INTERNAL argument and return bool.
1311 */
1328 }
1331 /*-------------------------------------------------------------------
1332 * DefineCompositeType
1333 *
1334 * Create a Composite Type relation.
1335 * `DefineRelation' does all the work, we just provide the correct
1336 * arguments!
1337 *
1338 * If the relation already exists, then 'DefineRelation' will abort
1339 * the xact...
1340 *
1341 * DefineCompositeType returns relid for use when creating
1342 * an implicit composite type during function creation
1343 *-------------------------------------------------------------------
1344 */
1345 Oid
1347 {
1355 /*
1356 * now set the parameters for keys/inheritance etc. All of these are
1357 * uninteresting for composite types...
1358 */
1367 /*
1368 * finally create the relation...
1369 */
1371 }
1373 /*
1374 * AlterDomainDefault
1375 *
1376 * Routine implementing ALTER DOMAIN SET/DROP DEFAULT statements.
1377 */
1378 void
1380 {
1382 Oid domainoid;
1383 HeapTuple tup;
1385 Relation rel;
1391 HeapTuple newtuple;
1392 Form_pg_type typTup;
1394 /* Make a TypeName so we can use standard type lookup machinery */
1398 /* Look up the domain in the type table */
1408 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1411 /* Setup new tuple */
1416 /* Store the new default into the tuple */
1418 {
1419 /* Create a dummy ParseState for transformExpr */
1422 /*
1423 * Cook the colDef->raw_expr into an expression. Note: Name is
1424 * strictly for error message
1425 */
1431 /*
1432 * If the expression is just a NULL constant, we treat the command
1433 * like ALTER ... DROP DEFAULT. (But see note for same test in
1434 * DefineDomain.)
1435 */
1438 {
1439 /* Default is NULL, drop it */
1444 }
1445 else
1446 {
1447 /*
1448 * Expression must be stored as a nodeToString result, but we also
1449 * require a valid textual representation (mainly to make life
1450 * easier for pg_dump).
1451 */
1454 InvalidOid),
1457 /*
1458 * Form an updated tuple with the new default and write it back.
1459 */
1465 }
1466 }
1467 else
1468 {
1469 /* ALTER ... DROP DEFAULT */
1474 }
1478 new_record_repl);
1484 /* Rebuild dependencies */
1486 domainoid,
1500 defaultExpr,
1503 /* Clean up */
1506 }
1508 /*
1509 * AlterDomainNotNull
1510 *
1511 * Routine implementing ALTER DOMAIN SET/DROP NOT NULL statements.
1512 */
1513 void
1515 {
1517 Oid domainoid;
1518 Relation typrel;
1519 HeapTuple tup;
1520 Form_pg_type typTup;
1522 /* Make a TypeName so we can use standard type lookup machinery */
1526 /* Look up the domain in the type table */
1536 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1539 /* Is the domain already set to the desired constraint? */
1541 {
1544 }
1546 /* Adding a NOT NULL constraint requires checking existing columns */
1548 {
1552 /* Fetch relation list with attributes based on this domain */
1553 /* ShareLock is sufficient to prevent concurrent data changes */
1558 {
1562 HeapScanDesc scan;
1563 HeapTuple tuple;
1565 /* Scan all tuples in this relation */
1568 {
1571 /* Test attributes that are of the domain */
1573 {
1582 }
1583 }
1586 /* Close each rel after processing, but keep lock */
1588 }
1589 }
1591 /*
1592 * Okay to update pg_type row. We can scribble on typTup because it's a
1593 * copy.
1594 */
1601 /* Clean up */
1604 }
1606 /*
1607 * AlterDomainDropConstraint
1608 *
1609 * Implements the ALTER DOMAIN DROP CONSTRAINT statement
1610 */
1611 void
1613 DropBehavior behavior)
1614 {
1616 Oid domainoid;
1617 HeapTuple tup;
1618 Relation rel;
1619 Relation conrel;
1620 SysScanDesc conscan;
1622 HeapTuple contup;
1624 /* Make a TypeName so we can use standard type lookup machinery */
1628 /* Look up the domain in the type table */
1637 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1640 /* Grab an appropriate lock on the pg_constraint relation */
1643 /* Use the index to scan only constraints of the target relation */
1645 Anum_pg_constraint_contypid,
1652 /*
1653 * Scan over the result set, removing any matching entries.
1654 */
1656 {
1660 {
1661 ObjectAddress conobj;
1668 }
1669 }
1670 /* Clean up after the scan */
1675 }
1677 /*
1678 * AlterDomainAddConstraint
1679 *
1680 * Implements the ALTER DOMAIN .. ADD CONSTRAINT statement.
1681 */
1682 void
1684 {
1686 Oid domainoid;
1687 Relation typrel;
1688 HeapTuple tup;
1689 Form_pg_type typTup;
1699 /* Make a TypeName so we can use standard type lookup machinery */
1703 /* Look up the domain in the type table */
1713 /* Check it's a domain and check user has permission for ALTER DOMAIN */
1716 /* Check for unsupported constraint types */
1722 /* otherwise it should be a plain Constraint */
1730 {
1732 /* processed below */
1760 }
1762 /*
1763 * Since all other constraint types throw errors, this must be a check
1764 * constraint. First, process the constraint expression and add an entry
1765 * to pg_constraint.
1766 */
1772 /*
1773 * Test all values stored in the attributes based on the domain the
1774 * constraint is being added to.
1775 */
1778 /* Need an EState to run ExecEvalExpr */
1782 /* build execution state for expr */
1785 /* Fetch relation list with attributes based on this domain */
1786 /* ShareLock is sufficient to prevent concurrent data changes */
1791 {
1795 HeapScanDesc scan;
1796 HeapTuple tuple;
1798 /* Scan all tuples in this relation */
1801 {
1804 /* Test attributes that are of the domain */
1806 {
1808 Datum d;
1810 Datum conResult;
1818 econtext,
1827 }
1830 }
1833 /* Hold relation lock till commit (XXX bad for concurrency) */
1835 }
1839 /* Clean up */
1841 }
1843 /*
1844 * get_rels_with_domain
1845 *
1846 * Fetch all relations / attributes which are using the domain
1847 *
1848 * The result is a list of RelToCheck structs, one for each distinct
1849 * relation, each containing one or more attribute numbers that are of
1850 * the domain type. We have opened each rel and acquired the specified lock
1851 * type on it.
1852 *
1853 * We support nested domains by including attributes that are of derived
1854 * domain types. Current callers do not need to distinguish between attributes
1855 * that are of exactly the given domain and those that are of derived domains.
1856 *
1857 * XXX this is completely broken because there is no way to lock the domain
1858 * to prevent columns from being added or dropped while our command runs.
1859 * We can partially protect against column drops by locking relations as we
1860 * come across them, but there is still a race condition (the window between
1861 * seeing a pg_depend entry and acquiring lock on the relation it references).
1862 * Also, holding locks on all these relations simultaneously creates a non-
1863 * trivial risk of deadlock. We can minimize but not eliminate the deadlock
1864 * risk by using the weakest suitable lock (ShareLock for most callers).
1865 *
1866 * XXX the API for this is not sufficient to support checking domain values
1867 * that are inside composite types or arrays. Currently we just error out
1868 * if a composite type containing the target domain is stored anywhere.
1869 * There are not currently arrays of domains; if there were, we could take
1870 * the same approach, but it'd be nicer to fix it properly.
1871 *
1872 * Generally used for retrieving a list of tests when adding
1873 * new constraints to a domain.
1874 */
1877 {
1879 Relation depRel;
1881 SysScanDesc depScan;
1882 HeapTuple depTup;
1886 /*
1887 * We scan pg_depend to find those things that depend on the domain. (We
1888 * assume we can ignore refobjsubid for a domain.)
1889 */
1893 Anum_pg_depend_refclassid,
1897 Anum_pg_depend_refobjid,
1905 {
1909 Form_pg_attribute pg_att;
1912 /* Check for directly dependent types --- must be domains */
1914 {
1917 /*
1918 * Recursively add dependent columns to the output list. This is
1919 * a bit inefficient since we may fail to combine RelToCheck
1920 * entries when attributes of the same rel have different derived
1921 * domain types, but it's probably not worth improving.
1922 */
1925 lockmode));
1927 }
1929 /* Else, ignore dependees that aren't user columns of relations */
1930 /* (we assume system columns are never of domain types) */
1935 /* See if we already have an entry for this relation */
1937 {
1941 {
1944 }
1945 }
1948 {
1949 /* First attribute found for this relation */
1950 Relation rel;
1952 /* Acquire requested lock on relation */
1955 /*
1956 * Check to see if rowtype is stored anyplace as a composite-type
1957 * column; if so we have to fail, for now anyway.
1958 */
1961 NULL,
1964 /* Otherwise we can ignore views, composite types, etc */
1966 {
1969 }
1971 /* Build the RelToCheck entry with enough space for all atts */
1977 }
1979 /*
1980 * Confirm column has not been dropped, and is of the expected type.
1981 * This defends against an ALTER DROP COLUMN occuring just before we
1982 * acquired lock ... but if the whole table were dropped, we'd still
1983 * have a problem.
1984 */
1991 /*
1992 * Okay, add column to result. We store the columns in column-number
1993 * order; this is just a hack to improve predictability of regression
1994 * test output ...
1995 */
2000 {
2002 ptr--;
2003 }
2005 }
2012 }
2014 /*
2015 * checkDomainOwner
2016 *
2017 * Check that the type is actually a domain and that the current user
2018 * has permission to do ALTER DOMAIN on it. Throw an error if not.
2019 */
2020 static void
2022 {
2025 /* Check that this is actually a domain */
2032 /* Permission check: must own type */
2036 }
2038 /*
2039 * domainAddConstraint - code shared between CREATE and ALTER DOMAIN
2040 */
2045 {
2052 /*
2053 * Assign or validate constraint name
2054 */
2056 {
2058 domainOid,
2059 domainNamespace,
2065 }
2066 else
2068 NULL,
2070 domainNamespace,
2071 NIL);
2073 /*
2074 * Convert the A_EXPR in raw_expr into an EXPR
2075 */
2078 /*
2079 * Set up a CoerceToDomainValue to represent the occurrence of VALUE in
2080 * the expression. Note that it will appear to have the type of the base
2081 * type, not the domain. This seems correct since within the check
2082 * expression, we should not assume the input value can be considered a
2083 * member of the domain.
2084 */
2093 /*
2094 * Make sure it yields a boolean result.
2095 */
2098 /*
2099 * Make sure no outside relations are referred to.
2100 */
2106 /*
2107 * Domains don't allow var clauses (this should be redundant with the
2108 * above check, but make it anyway)
2109 */
2115 /*
2116 * No subplans or aggregates, either...
2117 */
2127 /*
2128 * Convert to string form for storage.
2129 */
2132 /*
2133 * Deparse it to produce text for consrc.
2134 *
2135 * Since VARNOs aren't allowed in domain constraints, relation context
2136 * isn't required as anything other than a shell.
2137 */
2140 InvalidOid),
2143 /*
2144 * Store the constraint in pg_constraint
2145 */
2152 NULL,
2156 NULL,
2157 NULL,
2158 NULL,
2159 NULL,
2164 InvalidOid,
2171 /*
2172 * Return the compiled constraint expression so the calling routine can
2173 * perform any additional required tests.
2174 */
2176 }
2178 /*
2179 * GetDomainConstraints - get a list of the current constraints of domain
2180 *
2181 * Returns a possibly-empty list of DomainConstraintState nodes.
2182 *
2183 * This is called by the executor during plan startup for a CoerceToDomain
2184 * expression node. The given constraints will be checked for each value
2185 * passed through the node.
2186 *
2187 * We allow this to be called for non-domain types, in which case the result
2188 * is always NIL.
2189 */
2190 List *
2192 {
2195 Relation conRel;
2200 {
2201 HeapTuple tup;
2202 HeapTuple conTup;
2203 Form_pg_type typTup;
2205 SysScanDesc scan;
2215 {
2216 /* Not a domain, so done */
2219 }
2221 /* Test for NOT NULL Constraint */
2225 /* Look for CHECK Constraints on this domain */
2227 Anum_pg_constraint_contypid,
2235 {
2237 Datum val;
2242 /* Ignore non-CHECK constraints (presently, shouldn't be any) */
2246 /*
2247 * Not expecting conbin to be NULL, but we'll test for it anyway
2248 */
2257 /* ExecInitExpr assumes we already fixed opfuncids */
2265 /*
2266 * use lcons() here because constraints of lower domains should be
2267 * applied earlier.
2268 */
2270 }
2274 /* loop to next domain in stack */
2277 }
2281 /*
2282 * Only need to add one NOT NULL check regardless of how many domains in
2283 * the stack request it.
2284 */
2286 {
2293 /* lcons to apply the nullness check FIRST */
2295 }
2298 }
2301 /*
2302 * Execute ALTER TYPE RENAME
2303 */
2304 void
2306 {
2308 Oid typeOid;
2309 Relation rel;
2310 HeapTuple tup;
2311 Form_pg_type typTup;
2313 /* Make a TypeName so we can use standard type lookup machinery */
2317 /* Look up the type in the type table */
2327 /* check permissions on type */
2332 /*
2333 * If it's a composite type, we need to check that it really is a
2334 * free-standing composite type, and not a table's rowtype. We
2335 * want people to use ALTER TABLE not ALTER TYPE for that case.
2336 */
2345 /* don't allow direct alteration of array types, either */
2355 /*
2356 * If type is composite we need to rename associated pg_class entry too.
2357 * RenameRelationInternal will call RenameTypeInternal automatically.
2358 */
2362 else
2366 /* Clean up */
2368 }
2370 /*
2371 * Change the owner of a type.
2372 */
2373 void
2375 {
2377 Oid typeOid;
2378 Relation rel;
2379 HeapTuple tup;
2380 HeapTuple newtup;
2381 Form_pg_type typTup;
2382 AclResult aclresult;
2386 /* Make a TypeName so we can use standard type lookup machinery */
2389 /* Use LookupTypeName here so that shell types can be processed */
2398 /* Copy the syscache entry so we can scribble on it below */
2404 /*
2405 * If it's a composite type, we need to check that it really is a
2406 * free-standing composite type, and not a table's rowtype. We want people
2407 * to use ALTER TABLE not ALTER TYPE for that case.
2408 */
2417 /* don't allow direct alteration of array types, either */
2427 /*
2428 * If the new owner is the same as the existing owner, consider the
2429 * command to have succeeded. This is for dump restoration purposes.
2430 */
2432 {
2433 /* Superusers can always do it */
2435 {
2436 /* Otherwise, must be owner of the existing object */
2441 /* Must be able to become new owner */
2444 /* New owner must have CREATE privilege on namespace */
2446 newOwnerId,
2447 ACL_CREATE);
2451 }
2453 /*
2454 * If it's a composite type, invoke ATExecChangeOwner so that we fix
2455 * up the pg_class entry properly. That will call back to
2456 * AlterTypeOwnerInternal to take care of the pg_type entry(s).
2457 */
2460 else
2461 {
2462 /*
2463 * We can just apply the modification directly.
2464 *
2465 * okay to scribble on typTup because it's a copy
2466 */
2473 /* Update owner dependency reference */
2476 /* If it has an array type, update that too */
2479 }
2480 }
2482 /* Clean up */
2484 }
2486 /*
2487 * AlterTypeOwnerInternal - change type owner unconditionally
2488 *
2489 * This is currently only used to propagate ALTER TABLE/TYPE OWNER to a
2490 * table's rowtype or an array type, and to implement REASSIGN OWNED BY.
2491 * It assumes the caller has done all needed checks. The function will
2492 * automatically recurse to an array type if the type has one.
2493 *
2494 * hasDependEntry should be TRUE if type is expected to have a pg_shdepend
2495 * entry (ie, it's not a table rowtype nor an array type).
2496 */
2497 void
2500 {
2501 Relation rel;
2502 HeapTuple tup;
2503 Form_pg_type typTup;
2514 /*
2515 * Modify the owner --- okay to scribble on typTup because it's a copy
2516 */
2523 /* Update owner dependency reference, if it has one */
2527 /* If it has an array type, update that too */
2531 /* Clean up */
2533 }
2535 /*
2536 * Execute ALTER TYPE SET SCHEMA
2537 */
2538 void
2540 {
2542 Oid typeOid;
2543 Oid nspOid;
2544 Oid elemOid;
2546 /* Make a TypeName so we can use standard type lookup machinery */
2550 /* check permissions on type */
2555 /* get schema OID and check its permissions */
2558 /* don't allow direct alteration of array types */
2568 /* and do the work */
2570 }
2572 /*
2573 * Move specified type to new namespace.
2574 *
2575 * Caller must have already checked privileges.
2576 *
2577 * The function automatically recurses to process the type's array type,
2578 * if any. isImplicitArray should be TRUE only when doing this internal
2579 * recursion (outside callers must never try to move an array type directly).
2580 *
2581 * If errorOnTableType is TRUE, the function errors out if the type is
2582 * a table type. ALTER TABLE has to be used to move a table to a new
2583 * namespace.
2584 */
2585 void
2589 {
2590 Relation rel;
2591 HeapTuple tup;
2592 Form_pg_type typform;
2593 Oid oldNspOid;
2594 Oid arrayOid;
2616 /* disallow renaming into or out of temp schemas */
2622 /* same for TOAST schema */
2628 /* check for duplicate name (more friendly than unique-index failure) */
2639 /* Detect whether type is a composite type (but not a table rowtype) */
2640 isCompositeType =
2644 /* Enforce not-table-type if requested */
2646 errorOnTableType)
2653 /* OK, modify the pg_type row */
2655 /* tup is a copy, so we can scribble directly on it */
2661 /*
2662 * Composite types have pg_class entries.
2663 *
2664 * We need to modify the pg_class tuple as well to reflect the change of
2665 * schema.
2666 */
2668 {
2669 Relation classRel;
2679 /*
2680 * Check for constraints associated with the composite type (we don't
2681 * currently support this, but probably will someday).
2682 */
2685 }
2686 else
2687 {
2688 /* If it's a domain, it might have constraints */
2691 }
2693 /*
2694 * Update dependency on schema, if any --- a table rowtype has not got
2695 * one, and neither does an implicit array.
2696 */
2708 /* Recursively alter the associated array type, if any */
2711 }