Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * typecmds.c
4 : * Routines for SQL commands that manipulate types (and domains).
5 : *
6 : * Portions Copyright (c) 1996-2023, 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 "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 : */
32 : #include "postgres.h"
33 :
34 : #include "access/genam.h"
35 : #include "access/heapam.h"
36 : #include "access/htup_details.h"
37 : #include "access/tableam.h"
38 : #include "access/xact.h"
39 : #include "catalog/binary_upgrade.h"
40 : #include "catalog/catalog.h"
41 : #include "catalog/heap.h"
42 : #include "catalog/objectaccess.h"
43 : #include "catalog/pg_am.h"
44 : #include "catalog/pg_authid.h"
45 : #include "catalog/pg_cast.h"
46 : #include "catalog/pg_collation.h"
47 : #include "catalog/pg_constraint.h"
48 : #include "catalog/pg_depend.h"
49 : #include "catalog/pg_enum.h"
50 : #include "catalog/pg_language.h"
51 : #include "catalog/pg_namespace.h"
52 : #include "catalog/pg_proc.h"
53 : #include "catalog/pg_range.h"
54 : #include "catalog/pg_type.h"
55 : #include "commands/defrem.h"
56 : #include "commands/tablecmds.h"
57 : #include "commands/typecmds.h"
58 : #include "executor/executor.h"
59 : #include "miscadmin.h"
60 : #include "nodes/makefuncs.h"
61 : #include "optimizer/optimizer.h"
62 : #include "parser/parse_coerce.h"
63 : #include "parser/parse_collate.h"
64 : #include "parser/parse_expr.h"
65 : #include "parser/parse_func.h"
66 : #include "parser/parse_type.h"
67 : #include "utils/builtins.h"
68 : #include "utils/fmgroids.h"
69 : #include "utils/inval.h"
70 : #include "utils/lsyscache.h"
71 : #include "utils/memutils.h"
72 : #include "utils/rel.h"
73 : #include "utils/ruleutils.h"
74 : #include "utils/snapmgr.h"
75 : #include "utils/syscache.h"
76 :
77 :
78 : /* result structure for get_rels_with_domain() */
79 : typedef struct
80 : {
81 : Relation rel; /* opened and locked relation */
82 : int natts; /* number of attributes of interest */
83 : int *atts; /* attribute numbers */
84 : /* atts[] is of allocated length RelationGetNumberOfAttributes(rel) */
85 : } RelToCheck;
86 :
87 : /* parameter structure for AlterTypeRecurse() */
88 : typedef struct
89 : {
90 : /* Flags indicating which type attributes to update */
91 : bool updateStorage;
92 : bool updateReceive;
93 : bool updateSend;
94 : bool updateTypmodin;
95 : bool updateTypmodout;
96 : bool updateAnalyze;
97 : bool updateSubscript;
98 : /* New values for relevant attributes */
99 : char storage;
100 : Oid receiveOid;
101 : Oid sendOid;
102 : Oid typmodinOid;
103 : Oid typmodoutOid;
104 : Oid analyzeOid;
105 : Oid subscriptOid;
106 : } AlterTypeRecurseParams;
107 :
108 : /* Potentially set by pg_upgrade_support functions */
109 : Oid binary_upgrade_next_array_pg_type_oid = InvalidOid;
110 : Oid binary_upgrade_next_mrng_pg_type_oid = InvalidOid;
111 : Oid binary_upgrade_next_mrng_array_pg_type_oid = InvalidOid;
112 :
113 : static void makeRangeConstructors(const char *name, Oid namespace,
114 : Oid rangeOid, Oid subtype);
115 : static void makeMultirangeConstructors(const char *name, Oid namespace,
116 : Oid multirangeOid, Oid rangeOid,
117 : Oid rangeArrayOid, Oid *castFuncOid);
118 : static Oid findTypeInputFunction(List *procname, Oid typeOid);
119 : static Oid findTypeOutputFunction(List *procname, Oid typeOid);
120 : static Oid findTypeReceiveFunction(List *procname, Oid typeOid);
121 : static Oid findTypeSendFunction(List *procname, Oid typeOid);
122 : static Oid findTypeTypmodinFunction(List *procname);
123 : static Oid findTypeTypmodoutFunction(List *procname);
124 : static Oid findTypeAnalyzeFunction(List *procname, Oid typeOid);
125 : static Oid findTypeSubscriptingFunction(List *procname, Oid typeOid);
126 : static Oid findRangeSubOpclass(List *opcname, Oid subtype);
127 : static Oid findRangeCanonicalFunction(List *procname, Oid typeOid);
128 : static Oid findRangeSubtypeDiffFunction(List *procname, Oid subtype);
129 : static void validateDomainConstraint(Oid domainoid, char *ccbin);
130 : static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode);
131 : static void checkEnumOwner(HeapTuple tup);
132 : static char *domainAddConstraint(Oid domainOid, Oid domainNamespace,
133 : Oid baseTypeOid,
134 : int typMod, Constraint *constr,
135 : const char *domainName, ObjectAddress *constrAddr);
136 : static Node *replace_domain_constraint_value(ParseState *pstate,
137 : ColumnRef *cref);
138 : static void AlterTypeRecurse(Oid typeOid, bool isImplicitArray,
139 : HeapTuple tup, Relation catalog,
140 : AlterTypeRecurseParams *atparams);
141 :
142 :
143 : /*
144 : * DefineType
145 : * Registers a new base type.
146 : */
147 : ObjectAddress
148 362 : DefineType(ParseState *pstate, List *names, List *parameters)
149 : {
150 : char *typeName;
151 : Oid typeNamespace;
152 362 : int16 internalLength = -1; /* default: variable-length */
153 362 : List *inputName = NIL;
154 362 : List *outputName = NIL;
155 362 : List *receiveName = NIL;
156 362 : List *sendName = NIL;
157 362 : List *typmodinName = NIL;
158 362 : List *typmodoutName = NIL;
159 362 : List *analyzeName = NIL;
160 362 : List *subscriptName = NIL;
161 362 : char category = TYPCATEGORY_USER;
162 362 : bool preferred = false;
163 362 : char delimiter = DEFAULT_TYPDELIM;
164 362 : Oid elemType = InvalidOid;
165 362 : char *defaultValue = NULL;
166 362 : bool byValue = false;
167 362 : char alignment = TYPALIGN_INT; /* default alignment */
168 362 : char storage = TYPSTORAGE_PLAIN; /* default TOAST storage method */
169 362 : Oid collation = InvalidOid;
170 362 : DefElem *likeTypeEl = NULL;
171 362 : DefElem *internalLengthEl = NULL;
172 362 : DefElem *inputNameEl = NULL;
173 362 : DefElem *outputNameEl = NULL;
174 362 : DefElem *receiveNameEl = NULL;
175 362 : DefElem *sendNameEl = NULL;
176 362 : DefElem *typmodinNameEl = NULL;
177 362 : DefElem *typmodoutNameEl = NULL;
178 362 : DefElem *analyzeNameEl = NULL;
179 362 : DefElem *subscriptNameEl = NULL;
180 362 : DefElem *categoryEl = NULL;
181 362 : DefElem *preferredEl = NULL;
182 362 : DefElem *delimiterEl = NULL;
183 362 : DefElem *elemTypeEl = NULL;
184 362 : DefElem *defaultValueEl = NULL;
185 362 : DefElem *byValueEl = NULL;
186 362 : DefElem *alignmentEl = NULL;
187 362 : DefElem *storageEl = NULL;
188 362 : DefElem *collatableEl = NULL;
189 : Oid inputOid;
190 : Oid outputOid;
191 362 : Oid receiveOid = InvalidOid;
192 362 : Oid sendOid = InvalidOid;
193 362 : Oid typmodinOid = InvalidOid;
194 362 : Oid typmodoutOid = InvalidOid;
195 362 : Oid analyzeOid = InvalidOid;
196 362 : Oid subscriptOid = InvalidOid;
197 : char *array_type;
198 : Oid array_oid;
199 : Oid typoid;
200 : ListCell *pl;
201 : ObjectAddress address;
202 :
203 : /*
204 : * As of Postgres 8.4, we require superuser privilege to create a base
205 : * type. This is simple paranoia: there are too many ways to mess up the
206 : * system with an incorrect type definition (for instance, representation
207 : * parameters that don't match what the C code expects). In practice it
208 : * takes superuser privilege to create the I/O functions, and so the
209 : * former requirement that you own the I/O functions pretty much forced
210 : * superuserness anyway. We're just making doubly sure here.
211 : *
212 : * XXX re-enable NOT_USED code sections below if you remove this test.
213 : */
214 362 : if (!superuser())
215 0 : ereport(ERROR,
216 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
217 : errmsg("must be superuser to create a base type")));
218 :
219 : /* Convert list of names to a name and namespace */
220 362 : typeNamespace = QualifiedNameGetCreationNamespace(names, &typeName);
221 :
222 : #ifdef NOT_USED
223 : /* XXX this is unnecessary given the superuser check above */
224 : /* Check we have creation rights in target namespace */
225 : aclresult = object_aclcheck(NamespaceRelationId, typeNamespace, GetUserId(), ACL_CREATE);
226 : if (aclresult != ACLCHECK_OK)
227 : aclcheck_error(aclresult, OBJECT_SCHEMA,
228 : get_namespace_name(typeNamespace));
229 : #endif
230 :
231 : /*
232 : * Look to see if type already exists.
233 : */
234 362 : typoid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
235 : CStringGetDatum(typeName),
236 : ObjectIdGetDatum(typeNamespace));
237 :
238 : /*
239 : * If it's not a shell, see if it's an autogenerated array type, and if so
240 : * rename it out of the way.
241 : */
242 362 : if (OidIsValid(typoid) && get_typisdefined(typoid))
243 : {
244 6 : if (moveArrayTypeName(typoid, typeName, typeNamespace))
245 0 : typoid = InvalidOid;
246 : else
247 6 : ereport(ERROR,
248 : (errcode(ERRCODE_DUPLICATE_OBJECT),
249 : errmsg("type \"%s\" already exists", typeName)));
250 : }
251 :
252 : /*
253 : * If this command is a parameterless CREATE TYPE, then we're just here to
254 : * make a shell type, so do that (or fail if there already is a shell).
255 : */
256 356 : if (parameters == NIL)
257 : {
258 148 : if (OidIsValid(typoid))
259 6 : ereport(ERROR,
260 : (errcode(ERRCODE_DUPLICATE_OBJECT),
261 : errmsg("type \"%s\" already exists", typeName)));
262 :
263 142 : address = TypeShellMake(typeName, typeNamespace, GetUserId());
264 142 : return address;
265 : }
266 :
267 : /*
268 : * Otherwise, we must already have a shell type, since there is no other
269 : * way that the I/O functions could have been created.
270 : */
271 208 : if (!OidIsValid(typoid))
272 6 : ereport(ERROR,
273 : (errcode(ERRCODE_DUPLICATE_OBJECT),
274 : errmsg("type \"%s\" does not exist", typeName),
275 : errhint("Create the type as a shell type, then create its I/O functions, then do a full CREATE TYPE.")));
276 :
277 : /* Extract the parameters from the parameter list */
278 1048 : foreach(pl, parameters)
279 : {
280 846 : DefElem *defel = (DefElem *) lfirst(pl);
281 : DefElem **defelp;
282 :
283 846 : if (strcmp(defel->defname, "like") == 0)
284 50 : defelp = &likeTypeEl;
285 796 : else if (strcmp(defel->defname, "internallength") == 0)
286 130 : defelp = &internalLengthEl;
287 666 : else if (strcmp(defel->defname, "input") == 0)
288 196 : defelp = &inputNameEl;
289 470 : else if (strcmp(defel->defname, "output") == 0)
290 196 : defelp = &outputNameEl;
291 274 : else if (strcmp(defel->defname, "receive") == 0)
292 18 : defelp = &receiveNameEl;
293 256 : else if (strcmp(defel->defname, "send") == 0)
294 18 : defelp = &sendNameEl;
295 238 : else if (strcmp(defel->defname, "typmod_in") == 0)
296 8 : defelp = &typmodinNameEl;
297 230 : else if (strcmp(defel->defname, "typmod_out") == 0)
298 8 : defelp = &typmodoutNameEl;
299 222 : else if (strcmp(defel->defname, "analyze") == 0 ||
300 222 : strcmp(defel->defname, "analyse") == 0)
301 0 : defelp = &analyzeNameEl;
302 222 : else if (strcmp(defel->defname, "subscript") == 0)
303 2 : defelp = &subscriptNameEl;
304 220 : else if (strcmp(defel->defname, "category") == 0)
305 12 : defelp = &categoryEl;
306 208 : else if (strcmp(defel->defname, "preferred") == 0)
307 12 : defelp = &preferredEl;
308 196 : else if (strcmp(defel->defname, "delimiter") == 0)
309 0 : defelp = &delimiterEl;
310 196 : else if (strcmp(defel->defname, "element") == 0)
311 14 : defelp = &elemTypeEl;
312 182 : else if (strcmp(defel->defname, "default") == 0)
313 18 : defelp = &defaultValueEl;
314 164 : else if (strcmp(defel->defname, "passedbyvalue") == 0)
315 14 : defelp = &byValueEl;
316 150 : else if (strcmp(defel->defname, "alignment") == 0)
317 54 : defelp = &alignmentEl;
318 96 : else if (strcmp(defel->defname, "storage") == 0)
319 56 : defelp = &storageEl;
320 40 : else if (strcmp(defel->defname, "collatable") == 0)
321 4 : defelp = &collatableEl;
322 : else
323 : {
324 : /* WARNING, not ERROR, for historical backwards-compatibility */
325 36 : ereport(WARNING,
326 : (errcode(ERRCODE_SYNTAX_ERROR),
327 : errmsg("type attribute \"%s\" not recognized",
328 : defel->defname),
329 : parser_errposition(pstate, defel->location)));
330 36 : continue;
331 : }
332 810 : if (*defelp != NULL)
333 0 : errorConflictingDefElem(defel, pstate);
334 810 : *defelp = defel;
335 : }
336 :
337 : /*
338 : * Now interpret the options; we do this separately so that LIKE can be
339 : * overridden by other options regardless of the ordering in the parameter
340 : * list.
341 : */
342 202 : if (likeTypeEl)
343 : {
344 : Type likeType;
345 : Form_pg_type likeForm;
346 :
347 50 : likeType = typenameType(NULL, defGetTypeName(likeTypeEl), NULL);
348 50 : likeForm = (Form_pg_type) GETSTRUCT(likeType);
349 50 : internalLength = likeForm->typlen;
350 50 : byValue = likeForm->typbyval;
351 50 : alignment = likeForm->typalign;
352 50 : storage = likeForm->typstorage;
353 50 : ReleaseSysCache(likeType);
354 : }
355 202 : if (internalLengthEl)
356 130 : internalLength = defGetTypeLength(internalLengthEl);
357 202 : if (inputNameEl)
358 196 : inputName = defGetQualifiedName(inputNameEl);
359 202 : if (outputNameEl)
360 196 : outputName = defGetQualifiedName(outputNameEl);
361 202 : if (receiveNameEl)
362 18 : receiveName = defGetQualifiedName(receiveNameEl);
363 202 : if (sendNameEl)
364 18 : sendName = defGetQualifiedName(sendNameEl);
365 202 : if (typmodinNameEl)
366 8 : typmodinName = defGetQualifiedName(typmodinNameEl);
367 202 : if (typmodoutNameEl)
368 8 : typmodoutName = defGetQualifiedName(typmodoutNameEl);
369 202 : if (analyzeNameEl)
370 0 : analyzeName = defGetQualifiedName(analyzeNameEl);
371 202 : if (subscriptNameEl)
372 2 : subscriptName = defGetQualifiedName(subscriptNameEl);
373 202 : if (categoryEl)
374 : {
375 12 : char *p = defGetString(categoryEl);
376 :
377 12 : category = p[0];
378 : /* restrict to non-control ASCII */
379 12 : if (category < 32 || category > 126)
380 0 : ereport(ERROR,
381 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
382 : errmsg("invalid type category \"%s\": must be simple ASCII",
383 : p)));
384 : }
385 202 : if (preferredEl)
386 12 : preferred = defGetBoolean(preferredEl);
387 202 : if (delimiterEl)
388 : {
389 0 : char *p = defGetString(delimiterEl);
390 :
391 0 : delimiter = p[0];
392 : /* XXX shouldn't we restrict the delimiter? */
393 : }
394 202 : if (elemTypeEl)
395 : {
396 14 : elemType = typenameTypeId(NULL, defGetTypeName(elemTypeEl));
397 : /* disallow arrays of pseudotypes */
398 14 : if (get_typtype(elemType) == TYPTYPE_PSEUDO)
399 0 : ereport(ERROR,
400 : (errcode(ERRCODE_DATATYPE_MISMATCH),
401 : errmsg("array element type cannot be %s",
402 : format_type_be(elemType))));
403 : }
404 202 : if (defaultValueEl)
405 18 : defaultValue = defGetString(defaultValueEl);
406 202 : if (byValueEl)
407 14 : byValue = defGetBoolean(byValueEl);
408 202 : if (alignmentEl)
409 : {
410 54 : char *a = defGetString(alignmentEl);
411 :
412 : /*
413 : * Note: if argument was an unquoted identifier, parser will have
414 : * applied translations to it, so be prepared to recognize translated
415 : * type names as well as the nominal form.
416 : */
417 90 : if (pg_strcasecmp(a, "double") == 0 ||
418 72 : pg_strcasecmp(a, "float8") == 0 ||
419 36 : pg_strcasecmp(a, "pg_catalog.float8") == 0)
420 18 : alignment = TYPALIGN_DOUBLE;
421 42 : else if (pg_strcasecmp(a, "int4") == 0 ||
422 6 : pg_strcasecmp(a, "pg_catalog.int4") == 0)
423 36 : alignment = TYPALIGN_INT;
424 0 : else if (pg_strcasecmp(a, "int2") == 0 ||
425 0 : pg_strcasecmp(a, "pg_catalog.int2") == 0)
426 0 : alignment = TYPALIGN_SHORT;
427 0 : else if (pg_strcasecmp(a, "char") == 0 ||
428 0 : pg_strcasecmp(a, "pg_catalog.bpchar") == 0)
429 0 : alignment = TYPALIGN_CHAR;
430 : else
431 0 : ereport(ERROR,
432 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
433 : errmsg("alignment \"%s\" not recognized", a)));
434 : }
435 202 : if (storageEl)
436 : {
437 56 : char *a = defGetString(storageEl);
438 :
439 56 : if (pg_strcasecmp(a, "plain") == 0)
440 18 : storage = TYPSTORAGE_PLAIN;
441 38 : else if (pg_strcasecmp(a, "external") == 0)
442 0 : storage = TYPSTORAGE_EXTERNAL;
443 38 : else if (pg_strcasecmp(a, "extended") == 0)
444 32 : storage = TYPSTORAGE_EXTENDED;
445 6 : else if (pg_strcasecmp(a, "main") == 0)
446 6 : storage = TYPSTORAGE_MAIN;
447 : else
448 0 : ereport(ERROR,
449 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
450 : errmsg("storage \"%s\" not recognized", a)));
451 : }
452 202 : if (collatableEl)
453 4 : collation = defGetBoolean(collatableEl) ? DEFAULT_COLLATION_OID : InvalidOid;
454 :
455 : /*
456 : * make sure we have our required definitions
457 : */
458 202 : if (inputName == NIL)
459 6 : ereport(ERROR,
460 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
461 : errmsg("type input function must be specified")));
462 196 : if (outputName == NIL)
463 0 : ereport(ERROR,
464 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
465 : errmsg("type output function must be specified")));
466 :
467 196 : if (typmodinName == NIL && typmodoutName != NIL)
468 0 : ereport(ERROR,
469 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
470 : errmsg("type modifier output function is useless without a type modifier input function")));
471 :
472 : /*
473 : * Convert I/O proc names to OIDs
474 : */
475 196 : inputOid = findTypeInputFunction(inputName, typoid);
476 190 : outputOid = findTypeOutputFunction(outputName, typoid);
477 190 : if (receiveName)
478 18 : receiveOid = findTypeReceiveFunction(receiveName, typoid);
479 190 : if (sendName)
480 18 : sendOid = findTypeSendFunction(sendName, typoid);
481 :
482 : /*
483 : * Convert typmodin/out function proc names to OIDs.
484 : */
485 190 : if (typmodinName)
486 8 : typmodinOid = findTypeTypmodinFunction(typmodinName);
487 190 : if (typmodoutName)
488 8 : typmodoutOid = findTypeTypmodoutFunction(typmodoutName);
489 :
490 : /*
491 : * Convert analysis function proc name to an OID. If no analysis function
492 : * is specified, we'll use zero to select the built-in default algorithm.
493 : */
494 190 : if (analyzeName)
495 0 : analyzeOid = findTypeAnalyzeFunction(analyzeName, typoid);
496 :
497 : /*
498 : * Likewise look up the subscripting function if any. If it is not
499 : * specified, but a typelem is specified, allow that if
500 : * raw_array_subscript_handler can be used. (This is for backwards
501 : * compatibility; maybe someday we should throw an error instead.)
502 : */
503 190 : if (subscriptName)
504 2 : subscriptOid = findTypeSubscriptingFunction(subscriptName, typoid);
505 188 : else if (OidIsValid(elemType))
506 : {
507 6 : if (internalLength > 0 && !byValue && get_typlen(elemType) > 0)
508 6 : subscriptOid = F_RAW_ARRAY_SUBSCRIPT_HANDLER;
509 : else
510 0 : ereport(ERROR,
511 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
512 : errmsg("element type cannot be specified without a subscripting function")));
513 : }
514 :
515 : /*
516 : * Check permissions on functions. We choose to require the creator/owner
517 : * of a type to also own the underlying functions. Since creating a type
518 : * is tantamount to granting public execute access on the functions, the
519 : * minimum sane check would be for execute-with-grant-option. But we
520 : * don't have a way to make the type go away if the grant option is
521 : * revoked, so ownership seems better.
522 : *
523 : * XXX For now, this is all unnecessary given the superuser check above.
524 : * If we ever relax that, these calls likely should be moved into
525 : * findTypeInputFunction et al, where they could be shared by AlterType.
526 : */
527 : #ifdef NOT_USED
528 : if (inputOid && !object_ownercheck(ProcedureRelationId, inputOid, GetUserId()))
529 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
530 : NameListToString(inputName));
531 : if (outputOid && !object_ownercheck(ProcedureRelationId, outputOid, GetUserId()))
532 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
533 : NameListToString(outputName));
534 : if (receiveOid && !object_ownercheck(ProcedureRelationId, receiveOid, GetUserId()))
535 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
536 : NameListToString(receiveName));
537 : if (sendOid && !object_ownercheck(ProcedureRelationId, sendOid, GetUserId()))
538 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
539 : NameListToString(sendName));
540 : if (typmodinOid && !object_ownercheck(ProcedureRelationId, typmodinOid, GetUserId()))
541 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
542 : NameListToString(typmodinName));
543 : if (typmodoutOid && !object_ownercheck(ProcedureRelationId, typmodoutOid, GetUserId()))
544 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
545 : NameListToString(typmodoutName));
546 : if (analyzeOid && !object_ownercheck(ProcedureRelationId, analyzeOid, GetUserId()))
547 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
548 : NameListToString(analyzeName));
549 : if (subscriptOid && !object_ownercheck(ProcedureRelationId, subscriptOid, GetUserId()))
550 : aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
551 : NameListToString(subscriptName));
552 : #endif
553 :
554 : /*
555 : * OK, we're done checking, time to make the type. We must assign the
556 : * array type OID ahead of calling TypeCreate, since the base type and
557 : * array type each refer to the other.
558 : */
559 190 : array_oid = AssignTypeArrayOid();
560 :
561 : /*
562 : * now have TypeCreate do all the real work.
563 : *
564 : * Note: the pg_type.oid is stored in user tables as array elements (base
565 : * types) in ArrayType and in composite types in DatumTupleFields. This
566 : * oid must be preserved by binary upgrades.
567 : */
568 : address =
569 190 : TypeCreate(InvalidOid, /* no predetermined type OID */
570 : typeName, /* type name */
571 : typeNamespace, /* namespace */
572 : InvalidOid, /* relation oid (n/a here) */
573 : 0, /* relation kind (ditto) */
574 : GetUserId(), /* owner's ID */
575 : internalLength, /* internal size */
576 : TYPTYPE_BASE, /* type-type (base type) */
577 : category, /* type-category */
578 : preferred, /* is it a preferred type? */
579 : delimiter, /* array element delimiter */
580 : inputOid, /* input procedure */
581 : outputOid, /* output procedure */
582 : receiveOid, /* receive procedure */
583 : sendOid, /* send procedure */
584 : typmodinOid, /* typmodin procedure */
585 : typmodoutOid, /* typmodout procedure */
586 : analyzeOid, /* analyze procedure */
587 : subscriptOid, /* subscript procedure */
588 : elemType, /* element type ID */
589 : false, /* this is not an implicit array type */
590 : array_oid, /* array type we are about to create */
591 : InvalidOid, /* base type ID (only for domains) */
592 : defaultValue, /* default type value */
593 : NULL, /* no binary form available */
594 : byValue, /* passed by value */
595 : alignment, /* required alignment */
596 : storage, /* TOAST strategy */
597 : -1, /* typMod (Domains only) */
598 : 0, /* Array Dimensions of typbasetype */
599 : false, /* Type NOT NULL */
600 : collation); /* type's collation */
601 : Assert(typoid == address.objectId);
602 :
603 : /*
604 : * Create the array type that goes with it.
605 : */
606 190 : array_type = makeArrayTypeName(typeName, typeNamespace);
607 :
608 : /* alignment must be TYPALIGN_INT or TYPALIGN_DOUBLE for arrays */
609 190 : alignment = (alignment == TYPALIGN_DOUBLE) ? TYPALIGN_DOUBLE : TYPALIGN_INT;
610 :
611 190 : TypeCreate(array_oid, /* force assignment of this type OID */
612 : array_type, /* type name */
613 : typeNamespace, /* namespace */
614 : InvalidOid, /* relation oid (n/a here) */
615 : 0, /* relation kind (ditto) */
616 : GetUserId(), /* owner's ID */
617 : -1, /* internal size (always varlena) */
618 : TYPTYPE_BASE, /* type-type (base type) */
619 : TYPCATEGORY_ARRAY, /* type-category (array) */
620 : false, /* array types are never preferred */
621 : delimiter, /* array element delimiter */
622 : F_ARRAY_IN, /* input procedure */
623 : F_ARRAY_OUT, /* output procedure */
624 : F_ARRAY_RECV, /* receive procedure */
625 : F_ARRAY_SEND, /* send procedure */
626 : typmodinOid, /* typmodin procedure */
627 : typmodoutOid, /* typmodout procedure */
628 : F_ARRAY_TYPANALYZE, /* analyze procedure */
629 : F_ARRAY_SUBSCRIPT_HANDLER, /* array subscript procedure */
630 : typoid, /* element type ID */
631 : true, /* yes this is an array type */
632 : InvalidOid, /* no further array type */
633 : InvalidOid, /* base type ID */
634 : NULL, /* never a default type value */
635 : NULL, /* binary default isn't sent either */
636 : false, /* never passed by value */
637 : alignment, /* see above */
638 : TYPSTORAGE_EXTENDED, /* ARRAY is always toastable */
639 : -1, /* typMod (Domains only) */
640 : 0, /* Array dimensions of typbasetype */
641 : false, /* Type NOT NULL */
642 : collation); /* type's collation */
643 :
644 190 : pfree(array_type);
645 :
646 190 : return address;
647 : }
648 :
649 : /*
650 : * Guts of type deletion.
651 : */
652 : void
653 59386 : RemoveTypeById(Oid typeOid)
654 : {
655 : Relation relation;
656 : HeapTuple tup;
657 :
658 59386 : relation = table_open(TypeRelationId, RowExclusiveLock);
659 :
660 59386 : tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
661 59386 : if (!HeapTupleIsValid(tup))
662 0 : elog(ERROR, "cache lookup failed for type %u", typeOid);
663 :
664 59386 : CatalogTupleDelete(relation, &tup->t_self);
665 :
666 : /*
667 : * If it is an enum, delete the pg_enum entries too; we don't bother with
668 : * making dependency entries for those, so it has to be done "by hand"
669 : * here.
670 : */
671 59386 : if (((Form_pg_type) GETSTRUCT(tup))->typtype == TYPTYPE_ENUM)
672 312 : EnumValuesDelete(typeOid);
673 :
674 : /*
675 : * If it is a range type, delete the pg_range entry too; we don't bother
676 : * with making a dependency entry for that, so it has to be done "by hand"
677 : * here.
678 : */
679 59386 : if (((Form_pg_type) GETSTRUCT(tup))->typtype == TYPTYPE_RANGE)
680 78 : RangeDelete(typeOid);
681 :
682 59386 : ReleaseSysCache(tup);
683 :
684 59386 : table_close(relation, RowExclusiveLock);
685 59386 : }
686 :
687 :
688 : /*
689 : * DefineDomain
690 : * Registers a new domain.
691 : */
692 : ObjectAddress
693 3680 : DefineDomain(CreateDomainStmt *stmt)
694 : {
695 : char *domainName;
696 : char *domainArrayName;
697 : Oid domainNamespace;
698 : AclResult aclresult;
699 : int16 internalLength;
700 : Oid inputProcedure;
701 : Oid outputProcedure;
702 : Oid receiveProcedure;
703 : Oid sendProcedure;
704 : Oid analyzeProcedure;
705 : bool byValue;
706 : char category;
707 : char delimiter;
708 : char alignment;
709 : char storage;
710 : char typtype;
711 : Datum datum;
712 : bool isnull;
713 3680 : char *defaultValue = NULL;
714 3680 : char *defaultValueBin = NULL;
715 3680 : bool saw_default = false;
716 3680 : bool typNotNull = false;
717 3680 : bool nullDefined = false;
718 3680 : int32 typNDims = list_length(stmt->typeName->arrayBounds);
719 : HeapTuple typeTup;
720 3680 : List *schema = stmt->constraints;
721 : ListCell *listptr;
722 : Oid basetypeoid;
723 : Oid old_type_oid;
724 : Oid domaincoll;
725 : Oid domainArrayOid;
726 : Form_pg_type baseType;
727 : int32 basetypeMod;
728 : Oid baseColl;
729 : ObjectAddress address;
730 :
731 : /* Convert list of names to a name and namespace */
732 3680 : domainNamespace = QualifiedNameGetCreationNamespace(stmt->domainname,
733 : &domainName);
734 :
735 : /* Check we have creation rights in target namespace */
736 3680 : aclresult = object_aclcheck(NamespaceRelationId, domainNamespace, GetUserId(),
737 : ACL_CREATE);
738 3680 : if (aclresult != ACLCHECK_OK)
739 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
740 0 : get_namespace_name(domainNamespace));
741 :
742 : /*
743 : * Check for collision with an existing type name. If there is one and
744 : * it's an autogenerated array, we can rename it out of the way.
745 : */
746 3680 : old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
747 : CStringGetDatum(domainName),
748 : ObjectIdGetDatum(domainNamespace));
749 3680 : if (OidIsValid(old_type_oid))
750 : {
751 0 : if (!moveArrayTypeName(old_type_oid, domainName, domainNamespace))
752 0 : ereport(ERROR,
753 : (errcode(ERRCODE_DUPLICATE_OBJECT),
754 : errmsg("type \"%s\" already exists", domainName)));
755 : }
756 :
757 : /*
758 : * Look up the base type.
759 : */
760 3680 : typeTup = typenameType(NULL, stmt->typeName, &basetypeMod);
761 3680 : baseType = (Form_pg_type) GETSTRUCT(typeTup);
762 3680 : basetypeoid = baseType->oid;
763 :
764 : /*
765 : * Base type must be a plain base type, a composite type, another domain,
766 : * an enum or a range type. Domains over pseudotypes would create a
767 : * security hole. (It would be shorter to code this to just check for
768 : * pseudotypes; but it seems safer to call out the specific typtypes that
769 : * are supported, rather than assume that all future typtypes would be
770 : * automatically supported.)
771 : */
772 3680 : typtype = baseType->typtype;
773 3680 : if (typtype != TYPTYPE_BASE &&
774 62 : typtype != TYPTYPE_COMPOSITE &&
775 18 : typtype != TYPTYPE_DOMAIN &&
776 12 : typtype != TYPTYPE_ENUM &&
777 6 : typtype != TYPTYPE_RANGE &&
778 : typtype != TYPTYPE_MULTIRANGE)
779 0 : ereport(ERROR,
780 : (errcode(ERRCODE_DATATYPE_MISMATCH),
781 : errmsg("\"%s\" is not a valid base type for a domain",
782 : TypeNameToString(stmt->typeName))));
783 :
784 3680 : aclresult = object_aclcheck(TypeRelationId, basetypeoid, GetUserId(), ACL_USAGE);
785 3680 : if (aclresult != ACLCHECK_OK)
786 6 : aclcheck_error_type(aclresult, basetypeoid);
787 :
788 : /*
789 : * Collect the properties of the new domain. Some are inherited from the
790 : * base type, some are not. If you change any of this inheritance
791 : * behavior, be sure to update AlterTypeRecurse() to match!
792 : */
793 :
794 : /*
795 : * Identify the collation if any
796 : */
797 3674 : baseColl = baseType->typcollation;
798 3674 : if (stmt->collClause)
799 1236 : domaincoll = get_collation_oid(stmt->collClause->collname, false);
800 : else
801 2438 : domaincoll = baseColl;
802 :
803 : /* Complain if COLLATE is applied to an uncollatable type */
804 3674 : if (OidIsValid(domaincoll) && !OidIsValid(baseColl))
805 12 : ereport(ERROR,
806 : (errcode(ERRCODE_DATATYPE_MISMATCH),
807 : errmsg("collations are not supported by type %s",
808 : format_type_be(basetypeoid))));
809 :
810 : /* passed by value */
811 3662 : byValue = baseType->typbyval;
812 :
813 : /* Required Alignment */
814 3662 : alignment = baseType->typalign;
815 :
816 : /* TOAST Strategy */
817 3662 : storage = baseType->typstorage;
818 :
819 : /* Storage Length */
820 3662 : internalLength = baseType->typlen;
821 :
822 : /* Type Category */
823 3662 : category = baseType->typcategory;
824 :
825 : /* Array element Delimiter */
826 3662 : delimiter = baseType->typdelim;
827 :
828 : /* I/O Functions */
829 3662 : inputProcedure = F_DOMAIN_IN;
830 3662 : outputProcedure = baseType->typoutput;
831 3662 : receiveProcedure = F_DOMAIN_RECV;
832 3662 : sendProcedure = baseType->typsend;
833 :
834 : /* Domains never accept typmods, so no typmodin/typmodout needed */
835 :
836 : /* Analysis function */
837 3662 : analyzeProcedure = baseType->typanalyze;
838 :
839 : /*
840 : * Domains don't need a subscript function, since they are not
841 : * subscriptable on their own. If the base type is subscriptable, the
842 : * parser will reduce the type to the base type before subscripting.
843 : */
844 :
845 : /* Inherited default value */
846 3662 : datum = SysCacheGetAttr(TYPEOID, typeTup,
847 : Anum_pg_type_typdefault, &isnull);
848 3662 : if (!isnull)
849 0 : defaultValue = TextDatumGetCString(datum);
850 :
851 : /* Inherited default binary value */
852 3662 : datum = SysCacheGetAttr(TYPEOID, typeTup,
853 : Anum_pg_type_typdefaultbin, &isnull);
854 3662 : if (!isnull)
855 0 : defaultValueBin = TextDatumGetCString(datum);
856 :
857 : /*
858 : * Run through constraints manually to avoid the additional processing
859 : * conducted by DefineRelation() and friends.
860 : */
861 5828 : foreach(listptr, schema)
862 : {
863 2166 : Constraint *constr = lfirst(listptr);
864 :
865 2166 : if (!IsA(constr, Constraint))
866 0 : elog(ERROR, "unrecognized node type: %d",
867 : (int) nodeTag(constr));
868 2166 : switch (constr->contype)
869 : {
870 644 : case CONSTR_DEFAULT:
871 :
872 : /*
873 : * The inherited default value may be overridden by the user
874 : * with the DEFAULT <expr> clause ... but only once.
875 : */
876 644 : if (saw_default)
877 0 : ereport(ERROR,
878 : (errcode(ERRCODE_SYNTAX_ERROR),
879 : errmsg("multiple default expressions")));
880 644 : saw_default = true;
881 :
882 644 : if (constr->raw_expr)
883 : {
884 : ParseState *pstate;
885 : Node *defaultExpr;
886 :
887 : /* Create a dummy ParseState for transformExpr */
888 644 : pstate = make_parsestate(NULL);
889 :
890 : /*
891 : * Cook the constr->raw_expr into an expression. Note:
892 : * name is strictly for error message
893 : */
894 644 : defaultExpr = cookDefault(pstate, constr->raw_expr,
895 : basetypeoid,
896 : basetypeMod,
897 : domainName,
898 : 0);
899 :
900 : /*
901 : * If the expression is just a NULL constant, we treat it
902 : * like not having a default.
903 : *
904 : * Note that if the basetype is another domain, we'll see
905 : * a CoerceToDomain expr here and not discard the default.
906 : * This is critical because the domain default needs to be
907 : * retained to override any default that the base domain
908 : * might have.
909 : */
910 644 : if (defaultExpr == NULL ||
911 644 : (IsA(defaultExpr, Const) &&
912 24 : ((Const *) defaultExpr)->constisnull))
913 : {
914 0 : defaultValue = NULL;
915 0 : defaultValueBin = NULL;
916 : }
917 : else
918 : {
919 : /*
920 : * Expression must be stored as a nodeToString result,
921 : * but we also require a valid textual representation
922 : * (mainly to make life easier for pg_dump).
923 : */
924 : defaultValue =
925 644 : deparse_expression(defaultExpr,
926 : NIL, false, false);
927 644 : defaultValueBin = nodeToString(defaultExpr);
928 : }
929 : }
930 : else
931 : {
932 : /* No default (can this still happen?) */
933 0 : defaultValue = NULL;
934 0 : defaultValueBin = NULL;
935 : }
936 644 : break;
937 :
938 60 : case CONSTR_NOTNULL:
939 60 : if (nullDefined && !typNotNull)
940 0 : ereport(ERROR,
941 : (errcode(ERRCODE_SYNTAX_ERROR),
942 : errmsg("conflicting NULL/NOT NULL constraints")));
943 60 : typNotNull = true;
944 60 : nullDefined = true;
945 60 : break;
946 :
947 0 : case CONSTR_NULL:
948 0 : if (nullDefined && typNotNull)
949 0 : ereport(ERROR,
950 : (errcode(ERRCODE_SYNTAX_ERROR),
951 : errmsg("conflicting NULL/NOT NULL constraints")));
952 0 : typNotNull = false;
953 0 : nullDefined = true;
954 0 : break;
955 :
956 1462 : case CONSTR_CHECK:
957 :
958 : /*
959 : * Check constraints are handled after domain creation, as
960 : * they require the Oid of the domain; at this point we can
961 : * only check that they're not marked NO INHERIT, because that
962 : * would be bogus.
963 : */
964 1462 : if (constr->is_no_inherit)
965 0 : ereport(ERROR,
966 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
967 : errmsg("check constraints for domains cannot be marked NO INHERIT")));
968 1462 : break;
969 :
970 : /*
971 : * All else are error cases
972 : */
973 0 : case CONSTR_UNIQUE:
974 0 : ereport(ERROR,
975 : (errcode(ERRCODE_SYNTAX_ERROR),
976 : errmsg("unique constraints not possible for domains")));
977 : break;
978 :
979 0 : case CONSTR_PRIMARY:
980 0 : ereport(ERROR,
981 : (errcode(ERRCODE_SYNTAX_ERROR),
982 : errmsg("primary key constraints not possible for domains")));
983 : break;
984 :
985 0 : case CONSTR_EXCLUSION:
986 0 : ereport(ERROR,
987 : (errcode(ERRCODE_SYNTAX_ERROR),
988 : errmsg("exclusion constraints not possible for domains")));
989 : break;
990 :
991 0 : case CONSTR_FOREIGN:
992 0 : ereport(ERROR,
993 : (errcode(ERRCODE_SYNTAX_ERROR),
994 : errmsg("foreign key constraints not possible for domains")));
995 : break;
996 :
997 0 : case CONSTR_ATTR_DEFERRABLE:
998 : case CONSTR_ATTR_NOT_DEFERRABLE:
999 : case CONSTR_ATTR_DEFERRED:
1000 : case CONSTR_ATTR_IMMEDIATE:
1001 0 : ereport(ERROR,
1002 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1003 : errmsg("specifying constraint deferrability not supported for domains")));
1004 : break;
1005 :
1006 0 : default:
1007 0 : elog(ERROR, "unrecognized constraint subtype: %d",
1008 : (int) constr->contype);
1009 : break;
1010 : }
1011 : }
1012 :
1013 : /* Allocate OID for array type */
1014 3662 : domainArrayOid = AssignTypeArrayOid();
1015 :
1016 : /*
1017 : * Have TypeCreate do all the real work.
1018 : */
1019 : address =
1020 3662 : TypeCreate(InvalidOid, /* no predetermined type OID */
1021 : domainName, /* type name */
1022 : domainNamespace, /* namespace */
1023 : InvalidOid, /* relation oid (n/a here) */
1024 : 0, /* relation kind (ditto) */
1025 : GetUserId(), /* owner's ID */
1026 : internalLength, /* internal size */
1027 : TYPTYPE_DOMAIN, /* type-type (domain type) */
1028 : category, /* type-category */
1029 : false, /* domain types are never preferred */
1030 : delimiter, /* array element delimiter */
1031 : inputProcedure, /* input procedure */
1032 : outputProcedure, /* output procedure */
1033 : receiveProcedure, /* receive procedure */
1034 : sendProcedure, /* send procedure */
1035 : InvalidOid, /* typmodin procedure - none */
1036 : InvalidOid, /* typmodout procedure - none */
1037 : analyzeProcedure, /* analyze procedure */
1038 : InvalidOid, /* subscript procedure - none */
1039 : InvalidOid, /* no array element type */
1040 : false, /* this isn't an array */
1041 : domainArrayOid, /* array type we are about to create */
1042 : basetypeoid, /* base type ID */
1043 : defaultValue, /* default type value (text) */
1044 : defaultValueBin, /* default type value (binary) */
1045 : byValue, /* passed by value */
1046 : alignment, /* required alignment */
1047 : storage, /* TOAST strategy */
1048 : basetypeMod, /* typeMod value */
1049 : typNDims, /* Array dimensions for base type */
1050 : typNotNull, /* Type NOT NULL */
1051 : domaincoll); /* type's collation */
1052 :
1053 : /*
1054 : * Create the array type that goes with it.
1055 : */
1056 3662 : domainArrayName = makeArrayTypeName(domainName, domainNamespace);
1057 :
1058 : /* alignment must be TYPALIGN_INT or TYPALIGN_DOUBLE for arrays */
1059 3662 : alignment = (alignment == TYPALIGN_DOUBLE) ? TYPALIGN_DOUBLE : TYPALIGN_INT;
1060 :
1061 3662 : TypeCreate(domainArrayOid, /* force assignment of this type OID */
1062 : domainArrayName, /* type name */
1063 : domainNamespace, /* namespace */
1064 : InvalidOid, /* relation oid (n/a here) */
1065 : 0, /* relation kind (ditto) */
1066 : GetUserId(), /* owner's ID */
1067 : -1, /* internal size (always varlena) */
1068 : TYPTYPE_BASE, /* type-type (base type) */
1069 : TYPCATEGORY_ARRAY, /* type-category (array) */
1070 : false, /* array types are never preferred */
1071 : delimiter, /* array element delimiter */
1072 : F_ARRAY_IN, /* input procedure */
1073 : F_ARRAY_OUT, /* output procedure */
1074 : F_ARRAY_RECV, /* receive procedure */
1075 : F_ARRAY_SEND, /* send procedure */
1076 : InvalidOid, /* typmodin procedure - none */
1077 : InvalidOid, /* typmodout procedure - none */
1078 : F_ARRAY_TYPANALYZE, /* analyze procedure */
1079 : F_ARRAY_SUBSCRIPT_HANDLER, /* array subscript procedure */
1080 : address.objectId, /* element type ID */
1081 : true, /* yes this is an array type */
1082 : InvalidOid, /* no further array type */
1083 : InvalidOid, /* base type ID */
1084 : NULL, /* never a default type value */
1085 : NULL, /* binary default isn't sent either */
1086 : false, /* never passed by value */
1087 : alignment, /* see above */
1088 : TYPSTORAGE_EXTENDED, /* ARRAY is always toastable */
1089 : -1, /* typMod (Domains only) */
1090 : 0, /* Array dimensions of typbasetype */
1091 : false, /* Type NOT NULL */
1092 : domaincoll); /* type's collation */
1093 :
1094 3662 : pfree(domainArrayName);
1095 :
1096 : /*
1097 : * Process constraints which refer to the domain ID returned by TypeCreate
1098 : */
1099 5828 : foreach(listptr, schema)
1100 : {
1101 2166 : Constraint *constr = lfirst(listptr);
1102 :
1103 : /* it must be a Constraint, per check above */
1104 :
1105 2166 : switch (constr->contype)
1106 : {
1107 1462 : case CONSTR_CHECK:
1108 1462 : domainAddConstraint(address.objectId, domainNamespace,
1109 : basetypeoid, basetypeMod,
1110 : constr, domainName, NULL);
1111 1462 : break;
1112 :
1113 : /* Other constraint types were fully processed above */
1114 :
1115 704 : default:
1116 704 : break;
1117 : }
1118 :
1119 : /* CCI so we can detect duplicate constraint names */
1120 2166 : CommandCounterIncrement();
1121 : }
1122 :
1123 : /*
1124 : * Now we can clean up.
1125 : */
1126 3662 : ReleaseSysCache(typeTup);
1127 :
1128 3662 : return address;
1129 : }
1130 :
1131 :
1132 : /*
1133 : * DefineEnum
1134 : * Registers a new enum.
1135 : */
1136 : ObjectAddress
1137 416 : DefineEnum(CreateEnumStmt *stmt)
1138 : {
1139 : char *enumName;
1140 : char *enumArrayName;
1141 : Oid enumNamespace;
1142 : AclResult aclresult;
1143 : Oid old_type_oid;
1144 : Oid enumArrayOid;
1145 : ObjectAddress enumTypeAddr;
1146 :
1147 : /* Convert list of names to a name and namespace */
1148 416 : enumNamespace = QualifiedNameGetCreationNamespace(stmt->typeName,
1149 : &enumName);
1150 :
1151 : /* Check we have creation rights in target namespace */
1152 416 : aclresult = object_aclcheck(NamespaceRelationId, enumNamespace, GetUserId(), ACL_CREATE);
1153 416 : if (aclresult != ACLCHECK_OK)
1154 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
1155 0 : get_namespace_name(enumNamespace));
1156 :
1157 : /*
1158 : * Check for collision with an existing type name. If there is one and
1159 : * it's an autogenerated array, we can rename it out of the way.
1160 : */
1161 416 : old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
1162 : CStringGetDatum(enumName),
1163 : ObjectIdGetDatum(enumNamespace));
1164 416 : if (OidIsValid(old_type_oid))
1165 : {
1166 8 : if (!moveArrayTypeName(old_type_oid, enumName, enumNamespace))
1167 0 : ereport(ERROR,
1168 : (errcode(ERRCODE_DUPLICATE_OBJECT),
1169 : errmsg("type \"%s\" already exists", enumName)));
1170 : }
1171 :
1172 : /* Allocate OID for array type */
1173 416 : enumArrayOid = AssignTypeArrayOid();
1174 :
1175 : /* Create the pg_type entry */
1176 : enumTypeAddr =
1177 416 : TypeCreate(InvalidOid, /* no predetermined type OID */
1178 : enumName, /* type name */
1179 : enumNamespace, /* namespace */
1180 : InvalidOid, /* relation oid (n/a here) */
1181 : 0, /* relation kind (ditto) */
1182 : GetUserId(), /* owner's ID */
1183 : sizeof(Oid), /* internal size */
1184 : TYPTYPE_ENUM, /* type-type (enum type) */
1185 : TYPCATEGORY_ENUM, /* type-category (enum type) */
1186 : false, /* enum types are never preferred */
1187 : DEFAULT_TYPDELIM, /* array element delimiter */
1188 : F_ENUM_IN, /* input procedure */
1189 : F_ENUM_OUT, /* output procedure */
1190 : F_ENUM_RECV, /* receive procedure */
1191 : F_ENUM_SEND, /* send procedure */
1192 : InvalidOid, /* typmodin procedure - none */
1193 : InvalidOid, /* typmodout procedure - none */
1194 : InvalidOid, /* analyze procedure - default */
1195 : InvalidOid, /* subscript procedure - none */
1196 : InvalidOid, /* element type ID */
1197 : false, /* this is not an array type */
1198 : enumArrayOid, /* array type we are about to create */
1199 : InvalidOid, /* base type ID (only for domains) */
1200 : NULL, /* never a default type value */
1201 : NULL, /* binary default isn't sent either */
1202 : true, /* always passed by value */
1203 : TYPALIGN_INT, /* int alignment */
1204 : TYPSTORAGE_PLAIN, /* TOAST strategy always plain */
1205 : -1, /* typMod (Domains only) */
1206 : 0, /* Array dimensions of typbasetype */
1207 : false, /* Type NOT NULL */
1208 : InvalidOid); /* type's collation */
1209 :
1210 : /* Enter the enum's values into pg_enum */
1211 414 : EnumValuesCreate(enumTypeAddr.objectId, stmt->vals);
1212 :
1213 : /*
1214 : * Create the array type that goes with it.
1215 : */
1216 414 : enumArrayName = makeArrayTypeName(enumName, enumNamespace);
1217 :
1218 414 : TypeCreate(enumArrayOid, /* force assignment of this type OID */
1219 : enumArrayName, /* type name */
1220 : enumNamespace, /* namespace */
1221 : InvalidOid, /* relation oid (n/a here) */
1222 : 0, /* relation kind (ditto) */
1223 : GetUserId(), /* owner's ID */
1224 : -1, /* internal size (always varlena) */
1225 : TYPTYPE_BASE, /* type-type (base type) */
1226 : TYPCATEGORY_ARRAY, /* type-category (array) */
1227 : false, /* array types are never preferred */
1228 : DEFAULT_TYPDELIM, /* array element delimiter */
1229 : F_ARRAY_IN, /* input procedure */
1230 : F_ARRAY_OUT, /* output procedure */
1231 : F_ARRAY_RECV, /* receive procedure */
1232 : F_ARRAY_SEND, /* send procedure */
1233 : InvalidOid, /* typmodin procedure - none */
1234 : InvalidOid, /* typmodout procedure - none */
1235 : F_ARRAY_TYPANALYZE, /* analyze procedure */
1236 : F_ARRAY_SUBSCRIPT_HANDLER, /* array subscript procedure */
1237 : enumTypeAddr.objectId, /* element type ID */
1238 : true, /* yes this is an array type */
1239 : InvalidOid, /* no further array type */
1240 : InvalidOid, /* base type ID */
1241 : NULL, /* never a default type value */
1242 : NULL, /* binary default isn't sent either */
1243 : false, /* never passed by value */
1244 : TYPALIGN_INT, /* enums have int align, so do their arrays */
1245 : TYPSTORAGE_EXTENDED, /* ARRAY is always toastable */
1246 : -1, /* typMod (Domains only) */
1247 : 0, /* Array dimensions of typbasetype */
1248 : false, /* Type NOT NULL */
1249 : InvalidOid); /* type's collation */
1250 :
1251 414 : pfree(enumArrayName);
1252 :
1253 414 : return enumTypeAddr;
1254 : }
1255 :
1256 : /*
1257 : * AlterEnum
1258 : * Adds a new label to an existing enum.
1259 : */
1260 : ObjectAddress
1261 382 : AlterEnum(AlterEnumStmt *stmt)
1262 : {
1263 : Oid enum_type_oid;
1264 : TypeName *typename;
1265 : HeapTuple tup;
1266 : ObjectAddress address;
1267 :
1268 : /* Make a TypeName so we can use standard type lookup machinery */
1269 382 : typename = makeTypeNameFromNameList(stmt->typeName);
1270 382 : enum_type_oid = typenameTypeId(NULL, typename);
1271 :
1272 382 : tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(enum_type_oid));
1273 382 : if (!HeapTupleIsValid(tup))
1274 0 : elog(ERROR, "cache lookup failed for type %u", enum_type_oid);
1275 :
1276 : /* Check it's an enum and check user has permission to ALTER the enum */
1277 382 : checkEnumOwner(tup);
1278 :
1279 382 : ReleaseSysCache(tup);
1280 :
1281 382 : if (stmt->oldVal)
1282 : {
1283 : /* Rename an existing label */
1284 24 : RenameEnumLabel(enum_type_oid, stmt->oldVal, stmt->newVal);
1285 : }
1286 : else
1287 : {
1288 : /* Add a new label */
1289 358 : AddEnumLabel(enum_type_oid, stmt->newVal,
1290 358 : stmt->newValNeighbor, stmt->newValIsAfter,
1291 358 : stmt->skipIfNewValExists);
1292 : }
1293 :
1294 352 : InvokeObjectPostAlterHook(TypeRelationId, enum_type_oid, 0);
1295 :
1296 352 : ObjectAddressSet(address, TypeRelationId, enum_type_oid);
1297 :
1298 352 : return address;
1299 : }
1300 :
1301 :
1302 : /*
1303 : * checkEnumOwner
1304 : *
1305 : * Check that the type is actually an enum and that the current user
1306 : * has permission to do ALTER TYPE on it. Throw an error if not.
1307 : */
1308 : static void
1309 382 : checkEnumOwner(HeapTuple tup)
1310 : {
1311 382 : Form_pg_type typTup = (Form_pg_type) GETSTRUCT(tup);
1312 :
1313 : /* Check that this is actually an enum */
1314 382 : if (typTup->typtype != TYPTYPE_ENUM)
1315 0 : ereport(ERROR,
1316 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1317 : errmsg("%s is not an enum",
1318 : format_type_be(typTup->oid))));
1319 :
1320 : /* Permission check: must own type */
1321 382 : if (!object_ownercheck(TypeRelationId, typTup->oid, GetUserId()))
1322 0 : aclcheck_error_type(ACLCHECK_NOT_OWNER, typTup->oid);
1323 382 : }
1324 :
1325 :
1326 : /*
1327 : * DefineRange
1328 : * Registers a new range type.
1329 : *
1330 : * Perhaps it might be worthwhile to set pg_type.typelem to the base type,
1331 : * and likewise on multiranges to set it to the range type. But having a
1332 : * non-zero typelem is treated elsewhere as a synonym for being an array,
1333 : * and users might have queries with that same assumption.
1334 : */
1335 : ObjectAddress
1336 140 : DefineRange(ParseState *pstate, CreateRangeStmt *stmt)
1337 : {
1338 : char *typeName;
1339 : Oid typeNamespace;
1340 : Oid typoid;
1341 : char *rangeArrayName;
1342 140 : char *multirangeTypeName = NULL;
1343 : char *multirangeArrayName;
1344 140 : Oid multirangeNamespace = InvalidOid;
1345 : Oid rangeArrayOid;
1346 : Oid multirangeOid;
1347 : Oid multirangeArrayOid;
1348 140 : Oid rangeSubtype = InvalidOid;
1349 140 : List *rangeSubOpclassName = NIL;
1350 140 : List *rangeCollationName = NIL;
1351 140 : List *rangeCanonicalName = NIL;
1352 140 : List *rangeSubtypeDiffName = NIL;
1353 : Oid rangeSubOpclass;
1354 : Oid rangeCollation;
1355 : regproc rangeCanonical;
1356 : regproc rangeSubtypeDiff;
1357 : int16 subtyplen;
1358 : bool subtypbyval;
1359 : char subtypalign;
1360 : char alignment;
1361 : AclResult aclresult;
1362 : ListCell *lc;
1363 : ObjectAddress address;
1364 : ObjectAddress mltrngaddress PG_USED_FOR_ASSERTS_ONLY;
1365 : Oid castFuncOid;
1366 :
1367 : /* Convert list of names to a name and namespace */
1368 140 : typeNamespace = QualifiedNameGetCreationNamespace(stmt->typeName,
1369 : &typeName);
1370 :
1371 : /* Check we have creation rights in target namespace */
1372 140 : aclresult = object_aclcheck(NamespaceRelationId, typeNamespace, GetUserId(), ACL_CREATE);
1373 140 : if (aclresult != ACLCHECK_OK)
1374 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
1375 0 : get_namespace_name(typeNamespace));
1376 :
1377 : /*
1378 : * Look to see if type already exists.
1379 : */
1380 140 : typoid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
1381 : CStringGetDatum(typeName),
1382 : ObjectIdGetDatum(typeNamespace));
1383 :
1384 : /*
1385 : * If it's not a shell, see if it's an autogenerated array type, and if so
1386 : * rename it out of the way.
1387 : */
1388 140 : if (OidIsValid(typoid) && get_typisdefined(typoid))
1389 : {
1390 0 : if (moveArrayTypeName(typoid, typeName, typeNamespace))
1391 0 : typoid = InvalidOid;
1392 : else
1393 0 : ereport(ERROR,
1394 : (errcode(ERRCODE_DUPLICATE_OBJECT),
1395 : errmsg("type \"%s\" already exists", typeName)));
1396 : }
1397 :
1398 : /*
1399 : * Unlike DefineType(), we don't insist on a shell type existing first, as
1400 : * it's only needed if the user wants to specify a canonical function.
1401 : */
1402 :
1403 : /* Extract the parameters from the parameter list */
1404 374 : foreach(lc, stmt->params)
1405 : {
1406 234 : DefElem *defel = (DefElem *) lfirst(lc);
1407 :
1408 234 : if (strcmp(defel->defname, "subtype") == 0)
1409 : {
1410 140 : if (OidIsValid(rangeSubtype))
1411 0 : errorConflictingDefElem(defel, pstate);
1412 : /* we can look up the subtype name immediately */
1413 140 : rangeSubtype = typenameTypeId(NULL, defGetTypeName(defel));
1414 : }
1415 94 : else if (strcmp(defel->defname, "subtype_opclass") == 0)
1416 : {
1417 2 : if (rangeSubOpclassName != NIL)
1418 0 : errorConflictingDefElem(defel, pstate);
1419 2 : rangeSubOpclassName = defGetQualifiedName(defel);
1420 : }
1421 92 : else if (strcmp(defel->defname, "collation") == 0)
1422 : {
1423 52 : if (rangeCollationName != NIL)
1424 0 : errorConflictingDefElem(defel, pstate);
1425 52 : rangeCollationName = defGetQualifiedName(defel);
1426 : }
1427 40 : else if (strcmp(defel->defname, "canonical") == 0)
1428 : {
1429 0 : if (rangeCanonicalName != NIL)
1430 0 : errorConflictingDefElem(defel, pstate);
1431 0 : rangeCanonicalName = defGetQualifiedName(defel);
1432 : }
1433 40 : else if (strcmp(defel->defname, "subtype_diff") == 0)
1434 : {
1435 14 : if (rangeSubtypeDiffName != NIL)
1436 0 : errorConflictingDefElem(defel, pstate);
1437 14 : rangeSubtypeDiffName = defGetQualifiedName(defel);
1438 : }
1439 26 : else if (strcmp(defel->defname, "multirange_type_name") == 0)
1440 : {
1441 26 : if (multirangeTypeName != NULL)
1442 0 : errorConflictingDefElem(defel, pstate);
1443 : /* we can look up the subtype name immediately */
1444 26 : multirangeNamespace = QualifiedNameGetCreationNamespace(defGetQualifiedName(defel),
1445 : &multirangeTypeName);
1446 : }
1447 : else
1448 0 : ereport(ERROR,
1449 : (errcode(ERRCODE_SYNTAX_ERROR),
1450 : errmsg("type attribute \"%s\" not recognized",
1451 : defel->defname)));
1452 : }
1453 :
1454 : /* Must have a subtype */
1455 140 : if (!OidIsValid(rangeSubtype))
1456 0 : ereport(ERROR,
1457 : (errcode(ERRCODE_SYNTAX_ERROR),
1458 : errmsg("type attribute \"subtype\" is required")));
1459 : /* disallow ranges of pseudotypes */
1460 140 : if (get_typtype(rangeSubtype) == TYPTYPE_PSEUDO)
1461 0 : ereport(ERROR,
1462 : (errcode(ERRCODE_DATATYPE_MISMATCH),
1463 : errmsg("range subtype cannot be %s",
1464 : format_type_be(rangeSubtype))));
1465 :
1466 : /* Identify subopclass */
1467 140 : rangeSubOpclass = findRangeSubOpclass(rangeSubOpclassName, rangeSubtype);
1468 :
1469 : /* Identify collation to use, if any */
1470 140 : if (type_is_collatable(rangeSubtype))
1471 : {
1472 52 : if (rangeCollationName != NIL)
1473 52 : rangeCollation = get_collation_oid(rangeCollationName, false);
1474 : else
1475 0 : rangeCollation = get_typcollation(rangeSubtype);
1476 : }
1477 : else
1478 : {
1479 88 : if (rangeCollationName != NIL)
1480 0 : ereport(ERROR,
1481 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1482 : errmsg("range collation specified but subtype does not support collation")));
1483 88 : rangeCollation = InvalidOid;
1484 : }
1485 :
1486 : /* Identify support functions, if provided */
1487 140 : if (rangeCanonicalName != NIL)
1488 : {
1489 0 : if (!OidIsValid(typoid))
1490 0 : ereport(ERROR,
1491 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1492 : errmsg("cannot specify a canonical function without a pre-created shell type"),
1493 : errhint("Create the type as a shell type, then create its canonicalization function, then do a full CREATE TYPE.")));
1494 0 : rangeCanonical = findRangeCanonicalFunction(rangeCanonicalName,
1495 : typoid);
1496 : }
1497 : else
1498 140 : rangeCanonical = InvalidOid;
1499 :
1500 140 : if (rangeSubtypeDiffName != NIL)
1501 14 : rangeSubtypeDiff = findRangeSubtypeDiffFunction(rangeSubtypeDiffName,
1502 : rangeSubtype);
1503 : else
1504 126 : rangeSubtypeDiff = InvalidOid;
1505 :
1506 134 : get_typlenbyvalalign(rangeSubtype,
1507 : &subtyplen, &subtypbyval, &subtypalign);
1508 :
1509 : /* alignment must be TYPALIGN_INT or TYPALIGN_DOUBLE for ranges */
1510 134 : alignment = (subtypalign == TYPALIGN_DOUBLE) ? TYPALIGN_DOUBLE : TYPALIGN_INT;
1511 :
1512 : /* Allocate OID for array type, its multirange, and its multirange array */
1513 134 : rangeArrayOid = AssignTypeArrayOid();
1514 134 : multirangeOid = AssignTypeMultirangeOid();
1515 134 : multirangeArrayOid = AssignTypeMultirangeArrayOid();
1516 :
1517 : /* Create the pg_type entry */
1518 : address =
1519 134 : TypeCreate(InvalidOid, /* no predetermined type OID */
1520 : typeName, /* type name */
1521 : typeNamespace, /* namespace */
1522 : InvalidOid, /* relation oid (n/a here) */
1523 : 0, /* relation kind (ditto) */
1524 : GetUserId(), /* owner's ID */
1525 : -1, /* internal size (always varlena) */
1526 : TYPTYPE_RANGE, /* type-type (range type) */
1527 : TYPCATEGORY_RANGE, /* type-category (range type) */
1528 : false, /* range types are never preferred */
1529 : DEFAULT_TYPDELIM, /* array element delimiter */
1530 : F_RANGE_IN, /* input procedure */
1531 : F_RANGE_OUT, /* output procedure */
1532 : F_RANGE_RECV, /* receive procedure */
1533 : F_RANGE_SEND, /* send procedure */
1534 : InvalidOid, /* typmodin procedure - none */
1535 : InvalidOid, /* typmodout procedure - none */
1536 : F_RANGE_TYPANALYZE, /* analyze procedure */
1537 : InvalidOid, /* subscript procedure - none */
1538 : InvalidOid, /* element type ID - none */
1539 : false, /* this is not an array type */
1540 : rangeArrayOid, /* array type we are about to create */
1541 : InvalidOid, /* base type ID (only for domains) */
1542 : NULL, /* never a default type value */
1543 : NULL, /* no binary form available either */
1544 : false, /* never passed by value */
1545 : alignment, /* alignment */
1546 : TYPSTORAGE_EXTENDED, /* TOAST strategy (always extended) */
1547 : -1, /* typMod (Domains only) */
1548 : 0, /* Array dimensions of typbasetype */
1549 : false, /* Type NOT NULL */
1550 : InvalidOid); /* type's collation (ranges never have one) */
1551 : Assert(typoid == InvalidOid || typoid == address.objectId);
1552 134 : typoid = address.objectId;
1553 :
1554 : /* Create the multirange that goes with it */
1555 134 : if (multirangeTypeName)
1556 : {
1557 : Oid old_typoid;
1558 :
1559 : /*
1560 : * Look to see if multirange type already exists.
1561 : */
1562 26 : old_typoid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
1563 : CStringGetDatum(multirangeTypeName),
1564 : ObjectIdGetDatum(multirangeNamespace));
1565 :
1566 : /*
1567 : * If it's not a shell, see if it's an autogenerated array type, and
1568 : * if so rename it out of the way.
1569 : */
1570 26 : if (OidIsValid(old_typoid) && get_typisdefined(old_typoid))
1571 : {
1572 12 : if (!moveArrayTypeName(old_typoid, multirangeTypeName, multirangeNamespace))
1573 6 : ereport(ERROR,
1574 : (errcode(ERRCODE_DUPLICATE_OBJECT),
1575 : errmsg("type \"%s\" already exists", multirangeTypeName)));
1576 : }
1577 : }
1578 : else
1579 : {
1580 : /* Generate multirange name automatically */
1581 108 : multirangeNamespace = typeNamespace;
1582 108 : multirangeTypeName = makeMultirangeTypeName(typeName, multirangeNamespace);
1583 : }
1584 :
1585 : mltrngaddress =
1586 116 : TypeCreate(multirangeOid, /* force assignment of this type OID */
1587 : multirangeTypeName, /* type name */
1588 : multirangeNamespace, /* namespace */
1589 : InvalidOid, /* relation oid (n/a here) */
1590 : 0, /* relation kind (ditto) */
1591 : GetUserId(), /* owner's ID */
1592 : -1, /* internal size (always varlena) */
1593 : TYPTYPE_MULTIRANGE, /* type-type (multirange type) */
1594 : TYPCATEGORY_RANGE, /* type-category (range type) */
1595 : false, /* multirange types are never preferred */
1596 : DEFAULT_TYPDELIM, /* array element delimiter */
1597 : F_MULTIRANGE_IN, /* input procedure */
1598 : F_MULTIRANGE_OUT, /* output procedure */
1599 : F_MULTIRANGE_RECV, /* receive procedure */
1600 : F_MULTIRANGE_SEND, /* send procedure */
1601 : InvalidOid, /* typmodin procedure - none */
1602 : InvalidOid, /* typmodout procedure - none */
1603 : F_MULTIRANGE_TYPANALYZE, /* analyze procedure */
1604 : InvalidOid, /* subscript procedure - none */
1605 : InvalidOid, /* element type ID - none */
1606 : false, /* this is not an array type */
1607 : multirangeArrayOid, /* array type we are about to create */
1608 : InvalidOid, /* base type ID (only for domains) */
1609 : NULL, /* never a default type value */
1610 : NULL, /* no binary form available either */
1611 : false, /* never passed by value */
1612 : alignment, /* alignment */
1613 : 'x', /* TOAST strategy (always extended) */
1614 : -1, /* typMod (Domains only) */
1615 : 0, /* Array dimensions of typbasetype */
1616 : false, /* Type NOT NULL */
1617 : InvalidOid); /* type's collation (ranges never have one) */
1618 : Assert(multirangeOid == mltrngaddress.objectId);
1619 :
1620 : /* Create the entry in pg_range */
1621 116 : RangeCreate(typoid, rangeSubtype, rangeCollation, rangeSubOpclass,
1622 : rangeCanonical, rangeSubtypeDiff, multirangeOid);
1623 :
1624 : /*
1625 : * Create the array type that goes with it.
1626 : */
1627 116 : rangeArrayName = makeArrayTypeName(typeName, typeNamespace);
1628 :
1629 116 : TypeCreate(rangeArrayOid, /* force assignment of this type OID */
1630 : rangeArrayName, /* type name */
1631 : typeNamespace, /* namespace */
1632 : InvalidOid, /* relation oid (n/a here) */
1633 : 0, /* relation kind (ditto) */
1634 : GetUserId(), /* owner's ID */
1635 : -1, /* internal size (always varlena) */
1636 : TYPTYPE_BASE, /* type-type (base type) */
1637 : TYPCATEGORY_ARRAY, /* type-category (array) */
1638 : false, /* array types are never preferred */
1639 : DEFAULT_TYPDELIM, /* array element delimiter */
1640 : F_ARRAY_IN, /* input procedure */
1641 : F_ARRAY_OUT, /* output procedure */
1642 : F_ARRAY_RECV, /* receive procedure */
1643 : F_ARRAY_SEND, /* send procedure */
1644 : InvalidOid, /* typmodin procedure - none */
1645 : InvalidOid, /* typmodout procedure - none */
1646 : F_ARRAY_TYPANALYZE, /* analyze procedure */
1647 : F_ARRAY_SUBSCRIPT_HANDLER, /* array subscript procedure */
1648 : typoid, /* element type ID */
1649 : true, /* yes this is an array type */
1650 : InvalidOid, /* no further array type */
1651 : InvalidOid, /* base type ID */
1652 : NULL, /* never a default type value */
1653 : NULL, /* binary default isn't sent either */
1654 : false, /* never passed by value */
1655 : alignment, /* alignment - same as range's */
1656 : TYPSTORAGE_EXTENDED, /* ARRAY is always toastable */
1657 : -1, /* typMod (Domains only) */
1658 : 0, /* Array dimensions of typbasetype */
1659 : false, /* Type NOT NULL */
1660 : InvalidOid); /* typcollation */
1661 :
1662 116 : pfree(rangeArrayName);
1663 :
1664 : /* Create the multirange's array type */
1665 :
1666 116 : multirangeArrayName = makeArrayTypeName(multirangeTypeName, typeNamespace);
1667 :
1668 116 : TypeCreate(multirangeArrayOid, /* force assignment of this type OID */
1669 : multirangeArrayName, /* type name */
1670 : multirangeNamespace, /* namespace */
1671 : InvalidOid, /* relation oid (n/a here) */
1672 : 0, /* relation kind (ditto) */
1673 : GetUserId(), /* owner's ID */
1674 : -1, /* internal size (always varlena) */
1675 : TYPTYPE_BASE, /* type-type (base type) */
1676 : TYPCATEGORY_ARRAY, /* type-category (array) */
1677 : false, /* array types are never preferred */
1678 : DEFAULT_TYPDELIM, /* array element delimiter */
1679 : F_ARRAY_IN, /* input procedure */
1680 : F_ARRAY_OUT, /* output procedure */
1681 : F_ARRAY_RECV, /* receive procedure */
1682 : F_ARRAY_SEND, /* send procedure */
1683 : InvalidOid, /* typmodin procedure - none */
1684 : InvalidOid, /* typmodout procedure - none */
1685 : F_ARRAY_TYPANALYZE, /* analyze procedure */
1686 : F_ARRAY_SUBSCRIPT_HANDLER, /* array subscript procedure */
1687 : multirangeOid, /* element type ID */
1688 : true, /* yes this is an array type */
1689 : InvalidOid, /* no further array type */
1690 : InvalidOid, /* base type ID */
1691 : NULL, /* never a default type value */
1692 : NULL, /* binary default isn't sent either */
1693 : false, /* never passed by value */
1694 : alignment, /* alignment - same as range's */
1695 : 'x', /* ARRAY is always toastable */
1696 : -1, /* typMod (Domains only) */
1697 : 0, /* Array dimensions of typbasetype */
1698 : false, /* Type NOT NULL */
1699 : InvalidOid); /* typcollation */
1700 :
1701 : /* And create the constructor functions for this range type */
1702 116 : makeRangeConstructors(typeName, typeNamespace, typoid, rangeSubtype);
1703 116 : makeMultirangeConstructors(multirangeTypeName, typeNamespace,
1704 : multirangeOid, typoid, rangeArrayOid,
1705 : &castFuncOid);
1706 :
1707 : /* Create cast from the range type to its multirange type */
1708 116 : CastCreate(typoid, multirangeOid, castFuncOid, InvalidOid, InvalidOid,
1709 : COERCION_CODE_EXPLICIT, COERCION_METHOD_FUNCTION,
1710 : DEPENDENCY_INTERNAL);
1711 :
1712 116 : pfree(multirangeArrayName);
1713 :
1714 116 : return address;
1715 : }
1716 :
1717 : /*
1718 : * Because there may exist several range types over the same subtype, the
1719 : * range type can't be uniquely determined from the subtype. So it's
1720 : * impossible to define a polymorphic constructor; we have to generate new
1721 : * constructor functions explicitly for each range type.
1722 : *
1723 : * We actually define 4 functions, with 0 through 3 arguments. This is just
1724 : * to offer more convenience for the user.
1725 : */
1726 : static void
1727 116 : makeRangeConstructors(const char *name, Oid namespace,
1728 : Oid rangeOid, Oid subtype)
1729 : {
1730 : static const char *const prosrc[2] = {"range_constructor2",
1731 : "range_constructor3"};
1732 : static const int pronargs[2] = {2, 3};
1733 :
1734 : Oid constructorArgTypes[3];
1735 : ObjectAddress myself,
1736 : referenced;
1737 : int i;
1738 :
1739 116 : constructorArgTypes[0] = subtype;
1740 116 : constructorArgTypes[1] = subtype;
1741 116 : constructorArgTypes[2] = TEXTOID;
1742 :
1743 116 : referenced.classId = TypeRelationId;
1744 116 : referenced.objectId = rangeOid;
1745 116 : referenced.objectSubId = 0;
1746 :
1747 348 : for (i = 0; i < lengthof(prosrc); i++)
1748 : {
1749 : oidvector *constructorArgTypesVector;
1750 :
1751 232 : constructorArgTypesVector = buildoidvector(constructorArgTypes,
1752 : pronargs[i]);
1753 :
1754 232 : myself = ProcedureCreate(name, /* name: same as range type */
1755 : namespace, /* namespace */
1756 : false, /* replace */
1757 : false, /* returns set */
1758 : rangeOid, /* return type */
1759 : BOOTSTRAP_SUPERUSERID, /* proowner */
1760 : INTERNALlanguageId, /* language */
1761 : F_FMGR_INTERNAL_VALIDATOR, /* language validator */
1762 : prosrc[i], /* prosrc */
1763 : NULL, /* probin */
1764 : NULL, /* prosqlbody */
1765 : PROKIND_FUNCTION,
1766 : false, /* security_definer */
1767 : false, /* leakproof */
1768 : false, /* isStrict */
1769 : PROVOLATILE_IMMUTABLE, /* volatility */
1770 : PROPARALLEL_SAFE, /* parallel safety */
1771 : constructorArgTypesVector, /* parameterTypes */
1772 : PointerGetDatum(NULL), /* allParameterTypes */
1773 : PointerGetDatum(NULL), /* parameterModes */
1774 : PointerGetDatum(NULL), /* parameterNames */
1775 : NIL, /* parameterDefaults */
1776 : PointerGetDatum(NULL), /* trftypes */
1777 : PointerGetDatum(NULL), /* proconfig */
1778 : InvalidOid, /* prosupport */
1779 : 1.0, /* procost */
1780 : 0.0); /* prorows */
1781 :
1782 : /*
1783 : * Make the constructors internally-dependent on the range type so
1784 : * that they go away silently when the type is dropped. Note that
1785 : * pg_dump depends on this choice to avoid dumping the constructors.
1786 : */
1787 232 : recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
1788 : }
1789 116 : }
1790 :
1791 : /*
1792 : * We make a separate multirange constructor for each range type
1793 : * so its name can include the base type, like range constructors do.
1794 : * If we had an anyrangearray polymorphic type we could use it here,
1795 : * but since each type has its own constructor name there's no need.
1796 : *
1797 : * Sets castFuncOid to the oid of the new constructor that can be used
1798 : * to cast from a range to a multirange.
1799 : */
1800 : static void
1801 116 : makeMultirangeConstructors(const char *name, Oid namespace,
1802 : Oid multirangeOid, Oid rangeOid, Oid rangeArrayOid,
1803 : Oid *castFuncOid)
1804 : {
1805 : ObjectAddress myself,
1806 : referenced;
1807 : oidvector *argtypes;
1808 : Datum allParamTypes;
1809 : ArrayType *allParameterTypes;
1810 : Datum paramModes;
1811 : ArrayType *parameterModes;
1812 :
1813 116 : referenced.classId = TypeRelationId;
1814 116 : referenced.objectId = multirangeOid;
1815 116 : referenced.objectSubId = 0;
1816 :
1817 : /* 0-arg constructor - for empty multiranges */
1818 116 : argtypes = buildoidvector(NULL, 0);
1819 116 : myself = ProcedureCreate(name, /* name: same as multirange type */
1820 : namespace,
1821 : false, /* replace */
1822 : false, /* returns set */
1823 : multirangeOid, /* return type */
1824 : BOOTSTRAP_SUPERUSERID, /* proowner */
1825 : INTERNALlanguageId, /* language */
1826 : F_FMGR_INTERNAL_VALIDATOR,
1827 : "multirange_constructor0", /* prosrc */
1828 : NULL, /* probin */
1829 : NULL, /* prosqlbody */
1830 : PROKIND_FUNCTION,
1831 : false, /* security_definer */
1832 : false, /* leakproof */
1833 : true, /* isStrict */
1834 : PROVOLATILE_IMMUTABLE, /* volatility */
1835 : PROPARALLEL_SAFE, /* parallel safety */
1836 : argtypes, /* parameterTypes */
1837 : PointerGetDatum(NULL), /* allParameterTypes */
1838 : PointerGetDatum(NULL), /* parameterModes */
1839 : PointerGetDatum(NULL), /* parameterNames */
1840 : NIL, /* parameterDefaults */
1841 : PointerGetDatum(NULL), /* trftypes */
1842 : PointerGetDatum(NULL), /* proconfig */
1843 : InvalidOid, /* prosupport */
1844 : 1.0, /* procost */
1845 : 0.0); /* prorows */
1846 :
1847 : /*
1848 : * Make the constructor internally-dependent on the multirange type so
1849 : * that they go away silently when the type is dropped. Note that pg_dump
1850 : * depends on this choice to avoid dumping the constructors.
1851 : */
1852 116 : recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
1853 116 : pfree(argtypes);
1854 :
1855 : /*
1856 : * 1-arg constructor - for casts
1857 : *
1858 : * In theory we shouldn't need both this and the vararg (n-arg)
1859 : * constructor, but having a separate 1-arg function lets us define casts
1860 : * against it.
1861 : */
1862 116 : argtypes = buildoidvector(&rangeOid, 1);
1863 116 : myself = ProcedureCreate(name, /* name: same as multirange type */
1864 : namespace,
1865 : false, /* replace */
1866 : false, /* returns set */
1867 : multirangeOid, /* return type */
1868 : BOOTSTRAP_SUPERUSERID, /* proowner */
1869 : INTERNALlanguageId, /* language */
1870 : F_FMGR_INTERNAL_VALIDATOR,
1871 : "multirange_constructor1", /* prosrc */
1872 : NULL, /* probin */
1873 : NULL, /* prosqlbody */
1874 : PROKIND_FUNCTION,
1875 : false, /* security_definer */
1876 : false, /* leakproof */
1877 : true, /* isStrict */
1878 : PROVOLATILE_IMMUTABLE, /* volatility */
1879 : PROPARALLEL_SAFE, /* parallel safety */
1880 : argtypes, /* parameterTypes */
1881 : PointerGetDatum(NULL), /* allParameterTypes */
1882 : PointerGetDatum(NULL), /* parameterModes */
1883 : PointerGetDatum(NULL), /* parameterNames */
1884 : NIL, /* parameterDefaults */
1885 : PointerGetDatum(NULL), /* trftypes */
1886 : PointerGetDatum(NULL), /* proconfig */
1887 : InvalidOid, /* prosupport */
1888 : 1.0, /* procost */
1889 : 0.0); /* prorows */
1890 : /* ditto */
1891 116 : recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
1892 116 : pfree(argtypes);
1893 116 : *castFuncOid = myself.objectId;
1894 :
1895 : /* n-arg constructor - vararg */
1896 116 : argtypes = buildoidvector(&rangeArrayOid, 1);
1897 116 : allParamTypes = ObjectIdGetDatum(rangeArrayOid);
1898 116 : allParameterTypes = construct_array_builtin(&allParamTypes, 1, OIDOID);
1899 116 : paramModes = CharGetDatum(FUNC_PARAM_VARIADIC);
1900 116 : parameterModes = construct_array_builtin(¶mModes, 1, CHAROID);
1901 116 : myself = ProcedureCreate(name, /* name: same as multirange type */
1902 : namespace,
1903 : false, /* replace */
1904 : false, /* returns set */
1905 : multirangeOid, /* return type */
1906 : BOOTSTRAP_SUPERUSERID, /* proowner */
1907 : INTERNALlanguageId, /* language */
1908 : F_FMGR_INTERNAL_VALIDATOR,
1909 : "multirange_constructor2", /* prosrc */
1910 : NULL, /* probin */
1911 : NULL, /* prosqlbody */
1912 : PROKIND_FUNCTION,
1913 : false, /* security_definer */
1914 : false, /* leakproof */
1915 : true, /* isStrict */
1916 : PROVOLATILE_IMMUTABLE, /* volatility */
1917 : PROPARALLEL_SAFE, /* parallel safety */
1918 : argtypes, /* parameterTypes */
1919 : PointerGetDatum(allParameterTypes), /* allParameterTypes */
1920 : PointerGetDatum(parameterModes), /* parameterModes */
1921 : PointerGetDatum(NULL), /* parameterNames */
1922 : NIL, /* parameterDefaults */
1923 : PointerGetDatum(NULL), /* trftypes */
1924 : PointerGetDatum(NULL), /* proconfig */
1925 : InvalidOid, /* prosupport */
1926 : 1.0, /* procost */
1927 : 0.0); /* prorows */
1928 : /* ditto */
1929 116 : recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
1930 116 : pfree(argtypes);
1931 116 : pfree(allParameterTypes);
1932 116 : pfree(parameterModes);
1933 116 : }
1934 :
1935 : /*
1936 : * Find suitable I/O and other support functions for a type.
1937 : *
1938 : * typeOid is the type's OID (which will already exist, if only as a shell
1939 : * type).
1940 : */
1941 :
1942 : static Oid
1943 196 : findTypeInputFunction(List *procname, Oid typeOid)
1944 : {
1945 : Oid argList[3];
1946 : Oid procOid;
1947 : Oid procOid2;
1948 :
1949 : /*
1950 : * Input functions can take a single argument of type CSTRING, or three
1951 : * arguments (string, typioparam OID, typmod). Whine about ambiguity if
1952 : * both forms exist.
1953 : */
1954 196 : argList[0] = CSTRINGOID;
1955 196 : argList[1] = OIDOID;
1956 196 : argList[2] = INT4OID;
1957 :
1958 196 : procOid = LookupFuncName(procname, 1, argList, true);
1959 196 : procOid2 = LookupFuncName(procname, 3, argList, true);
1960 196 : if (OidIsValid(procOid))
1961 : {
1962 180 : if (OidIsValid(procOid2))
1963 0 : ereport(ERROR,
1964 : (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
1965 : errmsg("type input function %s has multiple matches",
1966 : NameListToString(procname))));
1967 : }
1968 : else
1969 : {
1970 16 : procOid = procOid2;
1971 : /* If not found, reference the 1-argument signature in error msg */
1972 16 : if (!OidIsValid(procOid))
1973 0 : ereport(ERROR,
1974 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
1975 : errmsg("function %s does not exist",
1976 : func_signature_string(procname, 1, NIL, argList))));
1977 : }
1978 :
1979 : /* Input functions must return the target type. */
1980 196 : if (get_func_rettype(procOid) != typeOid)
1981 6 : ereport(ERROR,
1982 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1983 : errmsg("type input function %s must return type %s",
1984 : NameListToString(procname), format_type_be(typeOid))));
1985 :
1986 : /*
1987 : * Print warnings if any of the type's I/O functions are marked volatile.
1988 : * There is a general assumption that I/O functions are stable or
1989 : * immutable; this allows us for example to mark record_in/record_out
1990 : * stable rather than volatile. Ideally we would throw errors not just
1991 : * warnings here; but since this check is new as of 9.5, and since the
1992 : * volatility marking might be just an error-of-omission and not a true
1993 : * indication of how the function behaves, we'll let it pass as a warning
1994 : * for now.
1995 : */
1996 190 : if (func_volatile(procOid) == PROVOLATILE_VOLATILE)
1997 0 : ereport(WARNING,
1998 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1999 : errmsg("type input function %s should not be volatile",
2000 : NameListToString(procname))));
2001 :
2002 190 : return procOid;
2003 : }
2004 :
2005 : static Oid
2006 190 : findTypeOutputFunction(List *procname, Oid typeOid)
2007 : {
2008 : Oid argList[1];
2009 : Oid procOid;
2010 :
2011 : /*
2012 : * Output functions always take a single argument of the type and return
2013 : * cstring.
2014 : */
2015 190 : argList[0] = typeOid;
2016 :
2017 190 : procOid = LookupFuncName(procname, 1, argList, true);
2018 190 : if (!OidIsValid(procOid))
2019 0 : ereport(ERROR,
2020 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2021 : errmsg("function %s does not exist",
2022 : func_signature_string(procname, 1, NIL, argList))));
2023 :
2024 190 : if (get_func_rettype(procOid) != CSTRINGOID)
2025 0 : ereport(ERROR,
2026 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2027 : errmsg("type output function %s must return type %s",
2028 : NameListToString(procname), "cstring")));
2029 :
2030 : /* Just a warning for now, per comments in findTypeInputFunction */
2031 190 : if (func_volatile(procOid) == PROVOLATILE_VOLATILE)
2032 0 : ereport(WARNING,
2033 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2034 : errmsg("type output function %s should not be volatile",
2035 : NameListToString(procname))));
2036 :
2037 190 : return procOid;
2038 : }
2039 :
2040 : static Oid
2041 46 : findTypeReceiveFunction(List *procname, Oid typeOid)
2042 : {
2043 : Oid argList[3];
2044 : Oid procOid;
2045 : Oid procOid2;
2046 :
2047 : /*
2048 : * Receive functions can take a single argument of type INTERNAL, or three
2049 : * arguments (internal, typioparam OID, typmod). Whine about ambiguity if
2050 : * both forms exist.
2051 : */
2052 46 : argList[0] = INTERNALOID;
2053 46 : argList[1] = OIDOID;
2054 46 : argList[2] = INT4OID;
2055 :
2056 46 : procOid = LookupFuncName(procname, 1, argList, true);
2057 46 : procOid2 = LookupFuncName(procname, 3, argList, true);
2058 46 : if (OidIsValid(procOid))
2059 : {
2060 36 : if (OidIsValid(procOid2))
2061 0 : ereport(ERROR,
2062 : (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
2063 : errmsg("type receive function %s has multiple matches",
2064 : NameListToString(procname))));
2065 : }
2066 : else
2067 : {
2068 10 : procOid = procOid2;
2069 : /* If not found, reference the 1-argument signature in error msg */
2070 10 : if (!OidIsValid(procOid))
2071 0 : ereport(ERROR,
2072 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2073 : errmsg("function %s does not exist",
2074 : func_signature_string(procname, 1, NIL, argList))));
2075 : }
2076 :
2077 : /* Receive functions must return the target type. */
2078 46 : if (get_func_rettype(procOid) != typeOid)
2079 0 : ereport(ERROR,
2080 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2081 : errmsg("type receive function %s must return type %s",
2082 : NameListToString(procname), format_type_be(typeOid))));
2083 :
2084 : /* Just a warning for now, per comments in findTypeInputFunction */
2085 46 : if (func_volatile(procOid) == PROVOLATILE_VOLATILE)
2086 0 : ereport(WARNING,
2087 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2088 : errmsg("type receive function %s should not be volatile",
2089 : NameListToString(procname))));
2090 :
2091 46 : return procOid;
2092 : }
2093 :
2094 : static Oid
2095 46 : findTypeSendFunction(List *procname, Oid typeOid)
2096 : {
2097 : Oid argList[1];
2098 : Oid procOid;
2099 :
2100 : /*
2101 : * Send functions always take a single argument of the type and return
2102 : * bytea.
2103 : */
2104 46 : argList[0] = typeOid;
2105 :
2106 46 : procOid = LookupFuncName(procname, 1, argList, true);
2107 46 : if (!OidIsValid(procOid))
2108 0 : ereport(ERROR,
2109 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2110 : errmsg("function %s does not exist",
2111 : func_signature_string(procname, 1, NIL, argList))));
2112 :
2113 46 : if (get_func_rettype(procOid) != BYTEAOID)
2114 0 : ereport(ERROR,
2115 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2116 : errmsg("type send function %s must return type %s",
2117 : NameListToString(procname), "bytea")));
2118 :
2119 : /* Just a warning for now, per comments in findTypeInputFunction */
2120 46 : if (func_volatile(procOid) == PROVOLATILE_VOLATILE)
2121 0 : ereport(WARNING,
2122 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2123 : errmsg("type send function %s should not be volatile",
2124 : NameListToString(procname))));
2125 :
2126 46 : return procOid;
2127 : }
2128 :
2129 : static Oid
2130 14 : findTypeTypmodinFunction(List *procname)
2131 : {
2132 : Oid argList[1];
2133 : Oid procOid;
2134 :
2135 : /*
2136 : * typmodin functions always take one cstring[] argument and return int4.
2137 : */
2138 14 : argList[0] = CSTRINGARRAYOID;
2139 :
2140 14 : procOid = LookupFuncName(procname, 1, argList, true);
2141 14 : if (!OidIsValid(procOid))
2142 0 : ereport(ERROR,
2143 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2144 : errmsg("function %s does not exist",
2145 : func_signature_string(procname, 1, NIL, argList))));
2146 :
2147 14 : if (get_func_rettype(procOid) != INT4OID)
2148 0 : ereport(ERROR,
2149 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2150 : errmsg("typmod_in function %s must return type %s",
2151 : NameListToString(procname), "integer")));
2152 :
2153 : /* Just a warning for now, per comments in findTypeInputFunction */
2154 14 : if (func_volatile(procOid) == PROVOLATILE_VOLATILE)
2155 0 : ereport(WARNING,
2156 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2157 : errmsg("type modifier input function %s should not be volatile",
2158 : NameListToString(procname))));
2159 :
2160 14 : return procOid;
2161 : }
2162 :
2163 : static Oid
2164 14 : findTypeTypmodoutFunction(List *procname)
2165 : {
2166 : Oid argList[1];
2167 : Oid procOid;
2168 :
2169 : /*
2170 : * typmodout functions always take one int4 argument and return cstring.
2171 : */
2172 14 : argList[0] = INT4OID;
2173 :
2174 14 : procOid = LookupFuncName(procname, 1, argList, true);
2175 14 : if (!OidIsValid(procOid))
2176 0 : ereport(ERROR,
2177 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2178 : errmsg("function %s does not exist",
2179 : func_signature_string(procname, 1, NIL, argList))));
2180 :
2181 14 : if (get_func_rettype(procOid) != CSTRINGOID)
2182 0 : ereport(ERROR,
2183 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2184 : errmsg("typmod_out function %s must return type %s",
2185 : NameListToString(procname), "cstring")));
2186 :
2187 : /* Just a warning for now, per comments in findTypeInputFunction */
2188 14 : if (func_volatile(procOid) == PROVOLATILE_VOLATILE)
2189 0 : ereport(WARNING,
2190 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2191 : errmsg("type modifier output function %s should not be volatile",
2192 : NameListToString(procname))));
2193 :
2194 14 : return procOid;
2195 : }
2196 :
2197 : static Oid
2198 6 : findTypeAnalyzeFunction(List *procname, Oid typeOid)
2199 : {
2200 : Oid argList[1];
2201 : Oid procOid;
2202 :
2203 : /*
2204 : * Analyze functions always take one INTERNAL argument and return bool.
2205 : */
2206 6 : argList[0] = INTERNALOID;
2207 :
2208 6 : procOid = LookupFuncName(procname, 1, argList, true);
2209 6 : if (!OidIsValid(procOid))
2210 0 : ereport(ERROR,
2211 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2212 : errmsg("function %s does not exist",
2213 : func_signature_string(procname, 1, NIL, argList))));
2214 :
2215 6 : if (get_func_rettype(procOid) != BOOLOID)
2216 0 : ereport(ERROR,
2217 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2218 : errmsg("type analyze function %s must return type %s",
2219 : NameListToString(procname), "boolean")));
2220 :
2221 6 : return procOid;
2222 : }
2223 :
2224 : static Oid
2225 22 : findTypeSubscriptingFunction(List *procname, Oid typeOid)
2226 : {
2227 : Oid argList[1];
2228 : Oid procOid;
2229 :
2230 : /*
2231 : * Subscripting support functions always take one INTERNAL argument and
2232 : * return INTERNAL. (The argument is not used, but we must have it to
2233 : * maintain type safety.)
2234 : */
2235 22 : argList[0] = INTERNALOID;
2236 :
2237 22 : procOid = LookupFuncName(procname, 1, argList, true);
2238 22 : if (!OidIsValid(procOid))
2239 0 : ereport(ERROR,
2240 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2241 : errmsg("function %s does not exist",
2242 : func_signature_string(procname, 1, NIL, argList))));
2243 :
2244 22 : if (get_func_rettype(procOid) != INTERNALOID)
2245 0 : ereport(ERROR,
2246 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2247 : errmsg("type subscripting function %s must return type %s",
2248 : NameListToString(procname), "internal")));
2249 :
2250 : /*
2251 : * We disallow array_subscript_handler() from being selected explicitly,
2252 : * since that must only be applied to autogenerated array types.
2253 : */
2254 22 : if (procOid == F_ARRAY_SUBSCRIPT_HANDLER)
2255 0 : ereport(ERROR,
2256 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2257 : errmsg("user-defined types cannot use subscripting function %s",
2258 : NameListToString(procname))));
2259 :
2260 22 : return procOid;
2261 : }
2262 :
2263 : /*
2264 : * Find suitable support functions and opclasses for a range type.
2265 : */
2266 :
2267 : /*
2268 : * Find named btree opclass for subtype, or default btree opclass if
2269 : * opcname is NIL.
2270 : */
2271 : static Oid
2272 140 : findRangeSubOpclass(List *opcname, Oid subtype)
2273 : {
2274 : Oid opcid;
2275 : Oid opInputType;
2276 :
2277 140 : if (opcname != NIL)
2278 : {
2279 2 : opcid = get_opclass_oid(BTREE_AM_OID, opcname, false);
2280 :
2281 : /*
2282 : * Verify that the operator class accepts this datatype. Note we will
2283 : * accept binary compatibility.
2284 : */
2285 2 : opInputType = get_opclass_input_type(opcid);
2286 2 : if (!IsBinaryCoercible(subtype, opInputType))
2287 0 : ereport(ERROR,
2288 : (errcode(ERRCODE_DATATYPE_MISMATCH),
2289 : errmsg("operator class \"%s\" does not accept data type %s",
2290 : NameListToString(opcname),
2291 : format_type_be(subtype))));
2292 : }
2293 : else
2294 : {
2295 138 : opcid = GetDefaultOpClass(subtype, BTREE_AM_OID);
2296 138 : if (!OidIsValid(opcid))
2297 : {
2298 : /* We spell the error message identically to ResolveOpClass */
2299 0 : ereport(ERROR,
2300 : (errcode(ERRCODE_UNDEFINED_OBJECT),
2301 : errmsg("data type %s has no default operator class for access method \"%s\"",
2302 : format_type_be(subtype), "btree"),
2303 : errhint("You must specify an operator class for the range type or define a default operator class for the subtype.")));
2304 : }
2305 : }
2306 :
2307 140 : return opcid;
2308 : }
2309 :
2310 : static Oid
2311 0 : findRangeCanonicalFunction(List *procname, Oid typeOid)
2312 : {
2313 : Oid argList[1];
2314 : Oid procOid;
2315 : AclResult aclresult;
2316 :
2317 : /*
2318 : * Range canonical functions must take and return the range type, and must
2319 : * be immutable.
2320 : */
2321 0 : argList[0] = typeOid;
2322 :
2323 0 : procOid = LookupFuncName(procname, 1, argList, true);
2324 :
2325 0 : if (!OidIsValid(procOid))
2326 0 : ereport(ERROR,
2327 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2328 : errmsg("function %s does not exist",
2329 : func_signature_string(procname, 1, NIL, argList))));
2330 :
2331 0 : if (get_func_rettype(procOid) != typeOid)
2332 0 : ereport(ERROR,
2333 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2334 : errmsg("range canonical function %s must return range type",
2335 : func_signature_string(procname, 1, NIL, argList))));
2336 :
2337 0 : if (func_volatile(procOid) != PROVOLATILE_IMMUTABLE)
2338 0 : ereport(ERROR,
2339 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2340 : errmsg("range canonical function %s must be immutable",
2341 : func_signature_string(procname, 1, NIL, argList))));
2342 :
2343 : /* Also, range type's creator must have permission to call function */
2344 0 : aclresult = object_aclcheck(ProcedureRelationId, procOid, GetUserId(), ACL_EXECUTE);
2345 0 : if (aclresult != ACLCHECK_OK)
2346 0 : aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(procOid));
2347 :
2348 0 : return procOid;
2349 : }
2350 :
2351 : static Oid
2352 14 : findRangeSubtypeDiffFunction(List *procname, Oid subtype)
2353 : {
2354 : Oid argList[2];
2355 : Oid procOid;
2356 : AclResult aclresult;
2357 :
2358 : /*
2359 : * Range subtype diff functions must take two arguments of the subtype,
2360 : * must return float8, and must be immutable.
2361 : */
2362 14 : argList[0] = subtype;
2363 14 : argList[1] = subtype;
2364 :
2365 14 : procOid = LookupFuncName(procname, 2, argList, true);
2366 :
2367 14 : if (!OidIsValid(procOid))
2368 6 : ereport(ERROR,
2369 : (errcode(ERRCODE_UNDEFINED_FUNCTION),
2370 : errmsg("function %s does not exist",
2371 : func_signature_string(procname, 2, NIL, argList))));
2372 :
2373 8 : if (get_func_rettype(procOid) != FLOAT8OID)
2374 0 : ereport(ERROR,
2375 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2376 : errmsg("range subtype diff function %s must return type %s",
2377 : func_signature_string(procname, 2, NIL, argList),
2378 : "double precision")));
2379 :
2380 8 : if (func_volatile(procOid) != PROVOLATILE_IMMUTABLE)
2381 0 : ereport(ERROR,
2382 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2383 : errmsg("range subtype diff function %s must be immutable",
2384 : func_signature_string(procname, 2, NIL, argList))));
2385 :
2386 : /* Also, range type's creator must have permission to call function */
2387 8 : aclresult = object_aclcheck(ProcedureRelationId, procOid, GetUserId(), ACL_EXECUTE);
2388 8 : if (aclresult != ACLCHECK_OK)
2389 0 : aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(procOid));
2390 :
2391 8 : return procOid;
2392 : }
2393 :
2394 : /*
2395 : * AssignTypeArrayOid
2396 : *
2397 : * Pre-assign the type's array OID for use in pg_type.typarray
2398 : */
2399 : Oid
2400 165630 : AssignTypeArrayOid(void)
2401 : {
2402 : Oid type_array_oid;
2403 :
2404 : /* Use binary-upgrade override for pg_type.typarray? */
2405 165630 : if (IsBinaryUpgrade)
2406 : {
2407 1418 : if (!OidIsValid(binary_upgrade_next_array_pg_type_oid))
2408 0 : ereport(ERROR,
2409 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2410 : errmsg("pg_type array OID value not set when in binary upgrade mode")));
2411 :
2412 1418 : type_array_oid = binary_upgrade_next_array_pg_type_oid;
2413 1418 : binary_upgrade_next_array_pg_type_oid = InvalidOid;
2414 : }
2415 : else
2416 : {
2417 164212 : Relation pg_type = table_open(TypeRelationId, AccessShareLock);
2418 :
2419 164212 : type_array_oid = GetNewOidWithIndex(pg_type, TypeOidIndexId,
2420 : Anum_pg_type_oid);
2421 164212 : table_close(pg_type, AccessShareLock);
2422 : }
2423 :
2424 165630 : return type_array_oid;
2425 : }
2426 :
2427 : /*
2428 : * AssignTypeMultirangeOid
2429 : *
2430 : * Pre-assign the range type's multirange OID for use in pg_type.oid
2431 : */
2432 : Oid
2433 134 : AssignTypeMultirangeOid(void)
2434 : {
2435 : Oid type_multirange_oid;
2436 :
2437 : /* Use binary-upgrade override for pg_type.oid? */
2438 134 : if (IsBinaryUpgrade)
2439 : {
2440 8 : if (!OidIsValid(binary_upgrade_next_mrng_pg_type_oid))
2441 0 : ereport(ERROR,
2442 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2443 : errmsg("pg_type multirange OID value not set when in binary upgrade mode")));
2444 :
2445 8 : type_multirange_oid = binary_upgrade_next_mrng_pg_type_oid;
2446 8 : binary_upgrade_next_mrng_pg_type_oid = InvalidOid;
2447 : }
2448 : else
2449 : {
2450 126 : Relation pg_type = table_open(TypeRelationId, AccessShareLock);
2451 :
2452 126 : type_multirange_oid = GetNewOidWithIndex(pg_type, TypeOidIndexId,
2453 : Anum_pg_type_oid);
2454 126 : table_close(pg_type, AccessShareLock);
2455 : }
2456 :
2457 134 : return type_multirange_oid;
2458 : }
2459 :
2460 : /*
2461 : * AssignTypeMultirangeArrayOid
2462 : *
2463 : * Pre-assign the range type's multirange array OID for use in pg_type.typarray
2464 : */
2465 : Oid
2466 134 : AssignTypeMultirangeArrayOid(void)
2467 : {
2468 : Oid type_multirange_array_oid;
2469 :
2470 : /* Use binary-upgrade override for pg_type.oid? */
2471 134 : if (IsBinaryUpgrade)
2472 : {
2473 8 : if (!OidIsValid(binary_upgrade_next_mrng_array_pg_type_oid))
2474 0 : ereport(ERROR,
2475 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2476 : errmsg("pg_type multirange array OID value not set when in binary upgrade mode")));
2477 :
2478 8 : type_multirange_array_oid = binary_upgrade_next_mrng_array_pg_type_oid;
2479 8 : binary_upgrade_next_mrng_array_pg_type_oid = InvalidOid;
2480 : }
2481 : else
2482 : {
2483 126 : Relation pg_type = table_open(TypeRelationId, AccessShareLock);
2484 :
2485 126 : type_multirange_array_oid = GetNewOidWithIndex(pg_type, TypeOidIndexId,
2486 : Anum_pg_type_oid);
2487 126 : table_close(pg_type, AccessShareLock);
2488 : }
2489 :
2490 134 : return type_multirange_array_oid;
2491 : }
2492 :
2493 :
2494 : /*-------------------------------------------------------------------
2495 : * DefineCompositeType
2496 : *
2497 : * Create a Composite Type relation.
2498 : * `DefineRelation' does all the work, we just provide the correct
2499 : * arguments!
2500 : *
2501 : * If the relation already exists, then 'DefineRelation' will abort
2502 : * the xact...
2503 : *
2504 : * Return type is the new type's object address.
2505 : *-------------------------------------------------------------------
2506 : */
2507 : ObjectAddress
2508 624 : DefineCompositeType(RangeVar *typevar, List *coldeflist)
2509 : {
2510 624 : CreateStmt *createStmt = makeNode(CreateStmt);
2511 : Oid old_type_oid;
2512 : Oid typeNamespace;
2513 : ObjectAddress address;
2514 :
2515 : /*
2516 : * now set the parameters for keys/inheritance etc. All of these are
2517 : * uninteresting for composite types...
2518 : */
2519 624 : createStmt->relation = typevar;
2520 624 : createStmt->tableElts = coldeflist;
2521 624 : createStmt->inhRelations = NIL;
2522 624 : createStmt->constraints = NIL;
2523 624 : createStmt->options = NIL;
2524 624 : createStmt->oncommit = ONCOMMIT_NOOP;
2525 624 : createStmt->tablespacename = NULL;
2526 624 : createStmt->if_not_exists = false;
2527 :
2528 : /*
2529 : * Check for collision with an existing type name. If there is one and
2530 : * it's an autogenerated array, we can rename it out of the way. This
2531 : * check is here mainly to get a better error message about a "type"
2532 : * instead of below about a "relation".
2533 : */
2534 624 : typeNamespace = RangeVarGetAndCheckCreationNamespace(createStmt->relation,
2535 : NoLock, NULL);
2536 624 : RangeVarAdjustRelationPersistence(createStmt->relation, typeNamespace);
2537 : old_type_oid =
2538 624 : GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
2539 : CStringGetDatum(createStmt->relation->relname),
2540 : ObjectIdGetDatum(typeNamespace));
2541 624 : if (OidIsValid(old_type_oid))
2542 : {
2543 0 : if (!moveArrayTypeName(old_type_oid, createStmt->relation->relname, typeNamespace))
2544 0 : ereport(ERROR,
2545 : (errcode(ERRCODE_DUPLICATE_OBJECT),
2546 : errmsg("type \"%s\" already exists", createStmt->relation->relname)));
2547 : }
2548 :
2549 : /*
2550 : * Finally create the relation. This also creates the type.
2551 : */
2552 624 : DefineRelation(createStmt, RELKIND_COMPOSITE_TYPE, InvalidOid, &address,
2553 : NULL);
2554 :
2555 612 : return address;
2556 : }
2557 :
2558 : /*
2559 : * AlterDomainDefault
2560 : *
2561 : * Routine implementing ALTER DOMAIN SET/DROP DEFAULT statements.
2562 : *
2563 : * Returns ObjectAddress of the modified domain.
2564 : */
2565 : ObjectAddress
2566 14 : AlterDomainDefault(List *names, Node *defaultRaw)
2567 : {
2568 : TypeName *typename;
2569 : Oid domainoid;
2570 : HeapTuple tup;
2571 : ParseState *pstate;
2572 : Relation rel;
2573 : char *defaultValue;
2574 14 : Node *defaultExpr = NULL; /* NULL if no default specified */
2575 14 : Datum new_record[Natts_pg_type] = {0};
2576 14 : bool new_record_nulls[Natts_pg_type] = {0};
2577 14 : bool new_record_repl[Natts_pg_type] = {0};
2578 : HeapTuple newtuple;
2579 : Form_pg_type typTup;
2580 : ObjectAddress address;
2581 :
2582 : /* Make a TypeName so we can use standard type lookup machinery */
2583 14 : typename = makeTypeNameFromNameList(names);
2584 14 : domainoid = typenameTypeId(NULL, typename);
2585 :
2586 : /* Look up the domain in the type table */
2587 14 : rel = table_open(TypeRelationId, RowExclusiveLock);
2588 :
2589 14 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(domainoid));
2590 14 : if (!HeapTupleIsValid(tup))
2591 0 : elog(ERROR, "cache lookup failed for type %u", domainoid);
2592 14 : typTup = (Form_pg_type) GETSTRUCT(tup);
2593 :
2594 : /* Check it's a domain and check user has permission for ALTER DOMAIN */
2595 14 : checkDomainOwner(tup);
2596 :
2597 : /* Setup new tuple */
2598 :
2599 : /* Store the new default into the tuple */
2600 14 : if (defaultRaw)
2601 : {
2602 : /* Create a dummy ParseState for transformExpr */
2603 8 : pstate = make_parsestate(NULL);
2604 :
2605 : /*
2606 : * Cook the colDef->raw_expr into an expression. Note: Name is
2607 : * strictly for error message
2608 : */
2609 8 : defaultExpr = cookDefault(pstate, defaultRaw,
2610 : typTup->typbasetype,
2611 : typTup->typtypmod,
2612 8 : NameStr(typTup->typname),
2613 : 0);
2614 :
2615 : /*
2616 : * If the expression is just a NULL constant, we treat the command
2617 : * like ALTER ... DROP DEFAULT. (But see note for same test in
2618 : * DefineDomain.)
2619 : */
2620 8 : if (defaultExpr == NULL ||
2621 8 : (IsA(defaultExpr, Const) && ((Const *) defaultExpr)->constisnull))
2622 : {
2623 : /* Default is NULL, drop it */
2624 0 : defaultExpr = NULL;
2625 0 : new_record_nulls[Anum_pg_type_typdefaultbin - 1] = true;
2626 0 : new_record_repl[Anum_pg_type_typdefaultbin - 1] = true;
2627 0 : new_record_nulls[Anum_pg_type_typdefault - 1] = true;
2628 0 : new_record_repl[Anum_pg_type_typdefault - 1] = true;
2629 : }
2630 : else
2631 : {
2632 : /*
2633 : * Expression must be stored as a nodeToString result, but we also
2634 : * require a valid textual representation (mainly to make life
2635 : * easier for pg_dump).
2636 : */
2637 8 : defaultValue = deparse_expression(defaultExpr,
2638 : NIL, false, false);
2639 :
2640 : /*
2641 : * Form an updated tuple with the new default and write it back.
2642 : */
2643 8 : new_record[Anum_pg_type_typdefaultbin - 1] = CStringGetTextDatum(nodeToString(defaultExpr));
2644 :
2645 8 : new_record_repl[Anum_pg_type_typdefaultbin - 1] = true;
2646 8 : new_record[Anum_pg_type_typdefault - 1] = CStringGetTextDatum(defaultValue);
2647 8 : new_record_repl[Anum_pg_type_typdefault - 1] = true;
2648 : }
2649 : }
2650 : else
2651 : {
2652 : /* ALTER ... DROP DEFAULT */
2653 6 : new_record_nulls[Anum_pg_type_typdefaultbin - 1] = true;
2654 6 : new_record_repl[Anum_pg_type_typdefaultbin - 1] = true;
2655 6 : new_record_nulls[Anum_pg_type_typdefault - 1] = true;
2656 6 : new_record_repl[Anum_pg_type_typdefault - 1] = true;
2657 : }
2658 :
2659 14 : newtuple = heap_modify_tuple(tup, RelationGetDescr(rel),
2660 : new_record, new_record_nulls,
2661 : new_record_repl);
2662 :
2663 14 : CatalogTupleUpdate(rel, &tup->t_self, newtuple);
2664 :
2665 : /* Rebuild dependencies */
2666 14 : GenerateTypeDependencies(newtuple,
2667 : rel,
2668 : defaultExpr,
2669 : NULL, /* don't have typacl handy */
2670 : 0, /* relation kind is n/a */
2671 : false, /* a domain isn't an implicit array */
2672 : false, /* nor is it any kind of dependent type */
2673 : false, /* don't touch extension membership */
2674 : true); /* We do need to rebuild dependencies */
2675 :
2676 14 : InvokeObjectPostAlterHook(TypeRelationId, domainoid, 0);
2677 :
2678 14 : ObjectAddressSet(address, TypeRelationId, domainoid);
2679 :
2680 : /* Clean up */
2681 14 : table_close(rel, RowExclusiveLock);
2682 14 : heap_freetuple(newtuple);
2683 :
2684 14 : return address;
2685 : }
2686 :
2687 : /*
2688 : * AlterDomainNotNull
2689 : *
2690 : * Routine implementing ALTER DOMAIN SET/DROP NOT NULL statements.
2691 : *
2692 : * Returns ObjectAddress of the modified domain.
2693 : */
2694 : ObjectAddress
2695 36 : AlterDomainNotNull(List *names, bool notNull)
2696 : {
2697 : TypeName *typename;
2698 : Oid domainoid;
2699 : Relation typrel;
2700 : HeapTuple tup;
2701 : Form_pg_type typTup;
2702 36 : ObjectAddress address = InvalidObjectAddress;
2703 :
2704 : /* Make a TypeName so we can use standard type lookup machinery */
2705 36 : typename = makeTypeNameFromNameList(names);
2706 36 : domainoid = typenameTypeId(NULL, typename);
2707 :
2708 : /* Look up the domain in the type table */
2709 36 : typrel = table_open(TypeRelationId, RowExclusiveLock);
2710 :
2711 36 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(domainoid));
2712 36 : if (!HeapTupleIsValid(tup))
2713 0 : elog(ERROR, "cache lookup failed for type %u", domainoid);
2714 36 : typTup = (Form_pg_type) GETSTRUCT(tup);
2715 :
2716 : /* Check it's a domain and check user has permission for ALTER DOMAIN */
2717 36 : checkDomainOwner(tup);
2718 :
2719 : /* Is the domain already set to the desired constraint? */
2720 36 : if (typTup->typnotnull == notNull)
2721 : {
2722 0 : table_close(typrel, RowExclusiveLock);
2723 0 : return address;
2724 : }
2725 :
2726 : /* Adding a NOT NULL constraint requires checking existing columns */
2727 36 : if (notNull)
2728 : {
2729 : List *rels;
2730 : ListCell *rt;
2731 :
2732 : /* Fetch relation list with attributes based on this domain */
2733 : /* ShareLock is sufficient to prevent concurrent data changes */
2734 :
2735 24 : rels = get_rels_with_domain(domainoid, ShareLock);
2736 :
2737 30 : foreach(rt, rels)
2738 : {
2739 18 : RelToCheck *rtc = (RelToCheck *) lfirst(rt);
2740 18 : Relation testrel = rtc->rel;
2741 18 : TupleDesc tupdesc = RelationGetDescr(testrel);
2742 : TupleTableSlot *slot;
2743 : TableScanDesc scan;
2744 : Snapshot snapshot;
2745 :
2746 : /* Scan all tuples in this relation */
2747 18 : snapshot = RegisterSnapshot(GetLatestSnapshot());
2748 18 : scan = table_beginscan(testrel, snapshot, 0, NULL);
2749 18 : slot = table_slot_create(testrel, NULL);
2750 24 : while (table_scan_getnextslot(scan, ForwardScanDirection, slot))
2751 : {
2752 : int i;
2753 :
2754 : /* Test attributes that are of the domain */
2755 36 : for (i = 0; i < rtc->natts; i++)
2756 : {
2757 30 : int attnum = rtc->atts[i];
2758 30 : Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
2759 :
2760 30 : if (slot_attisnull(slot, attnum))
2761 : {
2762 : /*
2763 : * In principle the auxiliary information for this
2764 : * error should be errdatatype(), but errtablecol()
2765 : * seems considerably more useful in practice. Since
2766 : * this code only executes in an ALTER DOMAIN command,
2767 : * the client should already know which domain is in
2768 : * question.
2769 : */
2770 12 : ereport(ERROR,
2771 : (errcode(ERRCODE_NOT_NULL_VIOLATION),
2772 : errmsg("column \"%s\" of table \"%s\" contains null values",
2773 : NameStr(attr->attname),
2774 : RelationGetRelationName(testrel)),
2775 : errtablecol(testrel, attnum)));
2776 : }
2777 : }
2778 : }
2779 6 : ExecDropSingleTupleTableSlot(slot);
2780 6 : table_endscan(scan);
2781 6 : UnregisterSnapshot(snapshot);
2782 :
2783 : /* Close each rel after processing, but keep lock */
2784 6 : table_close(testrel, NoLock);
2785 : }
2786 : }
2787 :
2788 : /*
2789 : * Okay to update pg_type row. We can scribble on typTup because it's a
2790 : * copy.
2791 : */
2792 24 : typTup->typnotnull = notNull;
2793 :
2794 24 : CatalogTupleUpdate(typrel, &tup->t_self, tup);
2795 :
2796 24 : InvokeObjectPostAlterHook(TypeRelationId, domainoid, 0);
2797 :
2798 24 : ObjectAddressSet(address, TypeRelationId, domainoid);
2799 :
2800 : /* Clean up */
2801 24 : heap_freetuple(tup);
2802 24 : table_close(typrel, RowExclusiveLock);
2803 :
2804 24 : return address;
2805 : }
2806 :
2807 : /*
2808 : * AlterDomainDropConstraint
2809 : *
2810 : * Implements the ALTER DOMAIN DROP CONSTRAINT statement
2811 : *
2812 : * Returns ObjectAddress of the modified domain.
2813 : */
2814 : ObjectAddress
2815 48 : AlterDomainDropConstraint(List *names, const char *constrName,
2816 : DropBehavior behavior, bool missing_ok)
2817 : {
2818 : TypeName *typename;
2819 : Oid domainoid;
2820 : HeapTuple tup;
2821 : Relation rel;
2822 : Relation conrel;
2823 : SysScanDesc conscan;
2824 : ScanKeyData skey[3];
2825 : HeapTuple contup;
2826 48 : bool found = false;
2827 : ObjectAddress address;
2828 :
2829 : /* Make a TypeName so we can use standard type lookup machinery */
2830 48 : typename = makeTypeNameFromNameList(names);
2831 48 : domainoid = typenameTypeId(NULL, typename);
2832 :
2833 : /* Look up the domain in the type table */
2834 48 : rel = table_open(TypeRelationId, RowExclusiveLock);
2835 :
2836 48 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(domainoid));
2837 48 : if (!HeapTupleIsValid(tup))
2838 0 : elog(ERROR, "cache lookup failed for type %u", domainoid);
2839 :
2840 : /* Check it's a domain and check user has permission for ALTER DOMAIN */
2841 48 : checkDomainOwner(tup);
2842 :
2843 : /* Grab an appropriate lock on the pg_constraint relation */
2844 48 : conrel = table_open(ConstraintRelationId, RowExclusiveLock);
2845 :
2846 : /* Find and remove the target constraint */
2847 48 : ScanKeyInit(&skey[0],
2848 : Anum_pg_constraint_conrelid,
2849 : BTEqualStrategyNumber, F_OIDEQ,
2850 : ObjectIdGetDatum(InvalidOid));
2851 48 : ScanKeyInit(&skey[1],
2852 : Anum_pg_constraint_contypid,
2853 : BTEqualStrategyNumber, F_OIDEQ,
2854 : ObjectIdGetDatum(domainoid));
2855 48 : ScanKeyInit(&skey[2],
2856 : Anum_pg_constraint_conname,
2857 : BTEqualStrategyNumber, F_NAMEEQ,
2858 : CStringGetDatum(constrName));
2859 :
2860 48 : conscan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
2861 : NULL, 3, skey);
2862 :
2863 : /* There can be at most one matching row */
2864 48 : if ((contup = systable_getnext(conscan)) != NULL)
2865 : {
2866 : ObjectAddress conobj;
2867 :
2868 36 : conobj.classId = ConstraintRelationId;
2869 36 : conobj.objectId = ((Form_pg_constraint) GETSTRUCT(contup))->oid;
2870 36 : conobj.objectSubId = 0;
2871 :
2872 36 : performDeletion(&conobj, behavior, 0);
2873 36 : found = true;
2874 : }
2875 :
2876 : /* Clean up after the scan */
2877 48 : systable_endscan(conscan);
2878 48 : table_close(conrel, RowExclusiveLock);
2879 :
2880 48 : if (!found)
2881 : {
2882 12 : if (!missing_ok)
2883 6 : ereport(ERROR,
2884 : (errcode(ERRCODE_UNDEFINED_OBJECT),
2885 : errmsg("constraint \"%s\" of domain \"%s\" does not exist",
2886 : constrName, TypeNameToString(typename))));
2887 : else
2888 6 : ereport(NOTICE,
2889 : (errmsg("constraint \"%s\" of domain \"%s\" does not exist, skipping",
2890 : constrName, TypeNameToString(typename))));
2891 : }
2892 :
2893 : /*
2894 : * We must send out an sinval message for the domain, to ensure that any
2895 : * dependent plans get rebuilt. Since this command doesn't change the
2896 : * domain's pg_type row, that won't happen automatically; do it manually.
2897 : */
2898 42 : CacheInvalidateHeapTuple(rel, tup, NULL);
2899 :
2900 42 : ObjectAddressSet(address, TypeRelationId, domainoid);
2901 :
2902 : /* Clean up */
2903 42 : table_close(rel, RowExclusiveLock);
2904 :
2905 42 : return address;
2906 : }
2907 :
2908 : /*
2909 : * AlterDomainAddConstraint
2910 : *
2911 : * Implements the ALTER DOMAIN .. ADD CONSTRAINT statement.
2912 : */
2913 : ObjectAddress
2914 144 : AlterDomainAddConstraint(List *names, Node *newConstraint,
2915 : ObjectAddress *constrAddr)
2916 : {
2917 : TypeName *typename;
2918 : Oid domainoid;
2919 : Relation typrel;
2920 : HeapTuple tup;
2921 : Form_pg_type typTup;
2922 : Constraint *constr;
2923 : char *ccbin;
2924 : ObjectAddress address;
2925 :
2926 : /* Make a TypeName so we can use standard type lookup machinery */
2927 144 : typename = makeTypeNameFromNameList(names);
2928 144 : domainoid = typenameTypeId(NULL, typename);
2929 :
2930 : /* Look up the domain in the type table */
2931 144 : typrel = table_open(TypeRelationId, RowExclusiveLock);
2932 :
2933 144 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(domainoid));
2934 144 : if (!HeapTupleIsValid(tup))
2935 0 : elog(ERROR, "cache lookup failed for type %u", domainoid);
2936 144 : typTup = (Form_pg_type) GETSTRUCT(tup);
2937 :
2938 : /* Check it's a domain and check user has permission for ALTER DOMAIN */
2939 144 : checkDomainOwner(tup);
2940 :
2941 144 : if (!IsA(newConstraint, Constraint))
2942 0 : elog(ERROR, "unrecognized node type: %d",
2943 : (int) nodeTag(newConstraint));
2944 :
2945 144 : constr = (Constraint *) newConstraint;
2946 :
2947 144 : switch (constr->contype)
2948 : {
2949 144 : case CONSTR_CHECK:
2950 : /* processed below */
2951 144 : break;
2952 :
2953 0 : case CONSTR_UNIQUE:
2954 0 : ereport(ERROR,
2955 : (errcode(ERRCODE_SYNTAX_ERROR),
2956 : errmsg("unique constraints not possible for domains")));
2957 : break;
2958 :
2959 0 : case CONSTR_PRIMARY:
2960 0 : ereport(ERROR,
2961 : (errcode(ERRCODE_SYNTAX_ERROR),
2962 : errmsg("primary key constraints not possible for domains")));
2963 : break;
2964 :
2965 0 : case CONSTR_EXCLUSION:
2966 0 : ereport(ERROR,
2967 : (errcode(ERRCODE_SYNTAX_ERROR),
2968 : errmsg("exclusion constraints not possible for domains")));
2969 : break;
2970 :
2971 0 : case CONSTR_FOREIGN:
2972 0 : ereport(ERROR,
2973 : (errcode(ERRCODE_SYNTAX_ERROR),
2974 : errmsg("foreign key constraints not possible for domains")));
2975 : break;
2976 :
2977 0 : case CONSTR_ATTR_DEFERRABLE:
2978 : case CONSTR_ATTR_NOT_DEFERRABLE:
2979 : case CONSTR_ATTR_DEFERRED:
2980 : case CONSTR_ATTR_IMMEDIATE:
2981 0 : ereport(ERROR,
2982 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2983 : errmsg("specifying constraint deferrability not supported for domains")));
2984 : break;
2985 :
2986 0 : default:
2987 0 : elog(ERROR, "unrecognized constraint subtype: %d",
2988 : (int) constr->contype);
2989 : break;
2990 : }
2991 :
2992 : /*
2993 : * Since all other constraint types throw errors, this must be a check
2994 : * constraint. First, process the constraint expression and add an entry
2995 : * to pg_constraint.
2996 : */
2997 :
2998 144 : ccbin = domainAddConstraint(domainoid, typTup->typnamespace,
2999 : typTup->typbasetype, typTup->typtypmod,
3000 144 : constr, NameStr(typTup->typname), constrAddr);
3001 :
3002 : /*
3003 : * If requested to validate the constraint, test all values stored in the
3004 : * attributes based on the domain the constraint is being added to.
3005 : */
3006 138 : if (!constr->skip_validation)
3007 132 : validateDomainConstraint(domainoid, ccbin);
3008 :
3009 : /*
3010 : * We must send out an sinval message for the domain, to ensure that any
3011 : * dependent plans get rebuilt. Since this command doesn't change the
3012 : * domain's pg_type row, that won't happen automatically; do it manually.
3013 : */
3014 78 : CacheInvalidateHeapTuple(typrel, tup, NULL);
3015 :
3016 78 : ObjectAddressSet(address, TypeRelationId, domainoid);
3017 :
3018 : /* Clean up */
3019 78 : table_close(typrel, RowExclusiveLock);
3020 :
3021 78 : return address;
3022 : }
3023 :
3024 : /*
3025 : * AlterDomainValidateConstraint
3026 : *
3027 : * Implements the ALTER DOMAIN .. VALIDATE CONSTRAINT statement.
3028 : */
3029 : ObjectAddress
3030 12 : AlterDomainValidateConstraint(List *names, const char *constrName)
3031 : {
3032 : TypeName *typename;
3033 : Oid domainoid;
3034 : Relation typrel;
3035 : Relation conrel;
3036 : HeapTuple tup;
3037 : Form_pg_constraint con;
3038 : Form_pg_constraint copy_con;
3039 : char *conbin;
3040 : SysScanDesc scan;
3041 : Datum val;
3042 : HeapTuple tuple;
3043 : HeapTuple copyTuple;
3044 : ScanKeyData skey[3];
3045 : ObjectAddress address;
3046 :
3047 : /* Make a TypeName so we can use standard type lookup machinery */
3048 12 : typename = makeTypeNameFromNameList(names);
3049 12 : domainoid = typenameTypeId(NULL, typename);
3050 :
3051 : /* Look up the domain in the type table */
3052 12 : typrel = table_open(TypeRelationId, AccessShareLock);
3053 :
3054 12 : tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(domainoid));
3055 12 : if (!HeapTupleIsValid(tup))
3056 0 : elog(ERROR, "cache lookup failed for type %u", domainoid);
3057 :
3058 : /* Check it's a domain and check user has permission for ALTER DOMAIN */
3059 12 : checkDomainOwner(tup);
3060 :
3061 : /*
3062 : * Find and check the target constraint
3063 : */
3064 12 : conrel = table_open(ConstraintRelationId, RowExclusiveLock);
3065 :
3066 12 : ScanKeyInit(&skey[0],
3067 : Anum_pg_constraint_conrelid,
3068 : BTEqualStrategyNumber, F_OIDEQ,
3069 : ObjectIdGetDatum(InvalidOid));
3070 12 : ScanKeyInit(&skey[1],
3071 : Anum_pg_constraint_contypid,
3072 : BTEqualStrategyNumber, F_OIDEQ,
3073 : ObjectIdGetDatum(domainoid));
3074 12 : ScanKeyInit(&skey[2],
3075 : Anum_pg_constraint_conname,
3076 : BTEqualStrategyNumber, F_NAMEEQ,
3077 : CStringGetDatum(constrName));
3078 :
3079 12 : scan = systable_beginscan(conrel, ConstraintRelidTypidNameIndexId, true,
3080 : NULL, 3, skey);
3081 :
3082 : /* There can be at most one matching row */
3083 12 : if (!HeapTupleIsValid(tuple = systable_getnext(scan)))
3084 0 : ereport(ERROR,
3085 : (errcode(ERRCODE_UNDEFINED_OBJECT),
3086 : errmsg("constraint \"%s\" of domain \"%s\" does not exist",
3087 : constrName, TypeNameToString(typename))));
3088 :
3089 12 : con = (Form_pg_constraint) GETSTRUCT(tuple);
3090 12 : if (con->contype != CONSTRAINT_CHECK)
3091 0 : ereport(ERROR,
3092 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3093 : errmsg("constraint \"%s\" of domain \"%s\" is not a check constraint",
3094 : constrName, TypeNameToString(typename))));
3095 :
3096 12 : val = SysCacheGetAttrNotNull(CONSTROID, tuple, Anum_pg_constraint_conbin);
3097 12 : conbin = TextDatumGetCString(val);
3098 :
3099 12 : validateDomainConstraint(domainoid, conbin);
3100 :
3101 : /*
3102 : * Now update the catalog, while we have the door open.
3103 : */
3104 6 : copyTuple = heap_copytuple(tuple);
3105 6 : copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
3106 6 : copy_con->convalidated = true;
3107 6 : CatalogTupleUpdate(conrel, ©Tuple->t_self, copyTuple);
3108 :
3109 6 : InvokeObjectPostAlterHook(ConstraintRelationId, con->oid, 0);
3110 :
3111 6 : ObjectAddressSet(address, TypeRelationId, domainoid);
3112 :
3113 6 : heap_freetuple(copyTuple);
3114 :
3115 6 : systable_endscan(scan);
3116 :
3117 6 : table_close(typrel, AccessShareLock);
3118 6 : table_close(conrel, RowExclusiveLock);
3119 :
3120 6 : ReleaseSysCache(tup);
3121 :
3122 6 : return address;
3123 : }
3124 :
3125 : static void
3126 144 : validateDomainConstraint(Oid domainoid, char *ccbin)
3127 : {
3128 144 : Expr *expr = (Expr *) stringToNode(ccbin);
3129 : List *rels;
3130 : ListCell *rt;
3131 : EState *estate;
3132 : ExprContext *econtext;
3133 : ExprState *exprstate;
3134 :
3135 : /* Need an EState to run ExecEvalExpr */
3136 144 : estate = CreateExecutorState();
3137 144 : econtext = GetPerTupleExprContext(estate);
3138 :
3139 : /* build execution state for expr */
3140 144 : exprstate = ExecPrepareExpr(expr, estate);
3141 :
3142 : /* Fetch relation list with attributes based on this domain */
3143 : /* ShareLock is sufficient to prevent concurrent data changes */
3144 :
3145 144 : rels = get_rels_with_domain(domainoid, ShareLock);
3146 :
3147 150 : foreach(rt, rels)
3148 : {
3149 72 : RelToCheck *rtc = (RelToCheck *) lfirst(rt);
3150 72 : Relation testrel = rtc->rel;
3151 72 : TupleDesc tupdesc = RelationGetDescr(testrel);
3152 : TupleTableSlot *slot;
3153 : TableScanDesc scan;
3154 : Snapshot snapshot;
3155 :
3156 : /* Scan all tuples in this relation */
3157 72 : snapshot = RegisterSnapshot(GetLatestSnapshot());
3158 72 : scan = table_beginscan(testrel, snapshot, 0, NULL);
3159 72 : slot = table_slot_create(testrel, NULL);
3160 168 : while (table_scan_getnextslot(scan, ForwardScanDirection, slot))
3161 : {
3162 : int i;
3163 :
3164 : /* Test attributes that are of the domain */
3165 228 : for (i = 0; i < rtc->natts; i++)
3166 : {
3167 132 : int attnum = rtc->atts[i];
3168 : Datum d;
3169 : bool isNull;
3170 : Datum conResult;
3171 132 : Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
3172 :
3173 132 : d = slot_getattr(slot, attnum, &isNull);
3174 :
3175 132 : econtext->domainValue_datum = d;
3176 132 : econtext->domainValue_isNull = isNull;
3177 :
3178 132 : conResult = ExecEvalExprSwitchContext(exprstate,
3179 : econtext,
3180 : &isNull);
3181 :
3182 132 : if (!isNull && !DatumGetBool(conResult))
3183 : {
3184 : /*
3185 : * In principle the auxiliary information for this error
3186 : * should be errdomainconstraint(), but errtablecol()
3187 : * seems considerably more useful in practice. Since this
3188 : * code only executes in an ALTER DOMAIN command, the
3189 : * client should already know which domain is in question,
3190 : * and which constraint too.
3191 : */
3192 36 : ereport(ERROR,
3193 : (errcode(ERRCODE_CHECK_VIOLATION),
3194 : errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
3195 : NameStr(attr->attname),
3196 : RelationGetRelationName(testrel)),
3197 : errtablecol(testrel, attnum)));
3198 : }
3199 : }
3200 :
3201 96 : ResetExprContext(econtext);
3202 : }
3203 36 : ExecDropSingleTupleTableSlot(slot);
3204 36 : table_endscan(scan);
3205 36 : UnregisterSnapshot(snapshot);
3206 :
3207 : /* Hold relation lock till commit (XXX bad for concurrency) */
3208 36 : table_close(testrel, NoLock);
3209 : }
3210 :
3211 78 : FreeExecutorState(estate);
3212 78 : }
3213 :
3214 : /*
3215 : * get_rels_with_domain
3216 : *
3217 : * Fetch all relations / attributes which are using the domain
3218 : *
3219 : * The result is a list of RelToCheck structs, one for each distinct
3220 : * relation, each containing one or more attribute numbers that are of
3221 : * the domain type. We have opened each rel and acquired the specified lock
3222 : * type on it.
3223 : *
3224 : * We support nested domains by including attributes that are of derived
3225 : * domain types. Current callers do not need to distinguish between attributes
3226 : * that are of exactly the given domain and those that are of derived domains.
3227 : *
3228 : * XXX this is completely broken because there is no way to lock the domain
3229 : * to prevent columns from being added or dropped while our command runs.
3230 : * We can partially protect against column drops by locking relations as we
3231 : * come across them, but there is still a race condition (the window between
3232 : * seeing a pg_depend entry and acquiring lock on the relation it references).
3233 : * Also, holding locks on all these relations simultaneously creates a non-
3234 : * trivial risk of deadlock. We can minimize but not eliminate the deadlock
3235 : * risk by using the weakest suitable lock (ShareLock for most callers).
3236 : *
3237 : * XXX the API for this is not sufficient to support checking domain values
3238 : * that are inside container types, such as composite types, arrays, or
3239 : * ranges. Currently we just error out if a container type containing the
3240 : * target domain is stored anywhere.
3241 : *
3242 : * Generally used for retrieving a list of tests when adding
3243 : * new constraints to a domain.
3244 : */
3245 : static List *
3246 180 : get_rels_with_domain(Oid domainOid, LOCKMODE lockmode)
3247 : {
3248 180 : List *result = NIL;
3249 180 : char *domainTypeName = format_type_be(domainOid);
3250 : Relation depRel;
3251 : ScanKeyData key[2];
3252 : SysScanDesc depScan;
3253 : HeapTuple depTup;
3254 :
3255 : Assert(lockmode != NoLock);
3256 :
3257 : /* since this function recurses, it could be driven to stack overflow */
3258 180 : check_stack_depth();
3259 :
3260 : /*
3261 : * We scan pg_depend to find those things that depend on the domain. (We
3262 : * assume we can ignore refobjsubid for a domain.)
3263 : */
3264 180 : depRel = table_open(DependRelationId, AccessShareLock);
3265 :
3266 180 : ScanKeyInit(&key[0],
3267 : Anum_pg_depend_refclassid,
3268 : BTEqualStrategyNumber, F_OIDEQ,
3269 : ObjectIdGetDatum(TypeRelationId));
3270 180 : ScanKeyInit(&key[1],
3271 : Anum_pg_depend_refobjid,
3272 : BTEqualStrategyNumber, F_OIDEQ,
3273 : ObjectIdGetDatum(domainOid));
3274 :
3275 180 : depScan = systable_beginscan(depRel, DependReferenceIndexId, true,
3276 : NULL, 2, key);
3277 :
3278 596 : while (HeapTupleIsValid(depTup = systable_getnext(depScan)))
3279 : {
3280 446 : Form_pg_depend pg_depend = (Form_pg_depend) GETSTRUCT(depTup);
3281 446 : RelToCheck *rtc = NULL;
3282 : ListCell *rellist;
3283 : Form_pg_attribute pg_att;
3284 : int ptr;
3285 :
3286 : /* Check for directly dependent types */
3287 446 : if (pg_depend->classid == TypeRelationId)
3288 : {
3289 198 : if (get_typtype(pg_depend->objid) == TYPTYPE_DOMAIN)
3290 : {
3291 : /*
3292 : * This is a sub-domain, so recursively add dependent columns
3293 : * to the output list. This is a bit inefficient since we may
3294 : * fail to combine RelToCheck entries when attributes of the
3295 : * same rel have different derived domain types, but it's
3296 : * probably not worth improving.
3297 : */
3298 12 : result = list_concat(result,
3299 12 : get_rels_with_domain(pg_depend->objid,
3300 : lockmode));
3301 : }
3302 : else
3303 : {
3304 : /*
3305 : * Otherwise, it is some container type using the domain, so
3306 : * fail if there are any columns of this type.
3307 : */
3308 186 : find_composite_type_dependencies(pg_depend->objid,
3309 : NULL,
3310 : domainTypeName);
3311 : }
3312 192 : continue;
3313 : }
3314 :
3315 : /* Else, ignore dependees that aren't user columns of relations */
3316 : /* (we assume system columns are never of domain types) */
3317 248 : if (pg_depend->classid != RelationRelationId ||
3318 168 : pg_depend->objsubid <= 0)
3319 80 : continue;
3320 :
3321 : /* See if we already have an entry for this relation */
3322 168 : foreach(rellist, result)
3323 : {
3324 18 : RelToCheck *rt = (RelToCheck *) lfirst(rellist);
3325 :
3326 18 : if (RelationGetRelid(rt->rel) == pg_depend->objid)
3327 : {
3328 18 : rtc = rt;
3329 18 : break;
3330 : }
3331 : }
3332 :
3333 168 : if (rtc == NULL)
3334 : {
3335 : /* First attribute found for this relation */
3336 : Relation rel;
3337 :
3338 : /* Acquire requested lock on relation */
3339 150 : rel = relation_open(pg_depend->objid, lockmode);
3340 :
3341 : /*
3342 : * Check to see if rowtype is stored anyplace as a composite-type
3343 : * column; if so we have to fail, for now anyway.
3344 : */
3345 150 : if (OidIsValid(rel->rd_rel->reltype))
3346 150 : find_composite_type_dependencies(rel->rd_rel->reltype,
3347 : NULL,
3348 : domainTypeName);
3349 :
3350 : /*
3351 : * Otherwise, we can ignore relations except those with both
3352 : * storage and user-chosen column types.
3353 : *
3354 : * XXX If an index-only scan could satisfy "col::some_domain" from
3355 : * a suitable expression index, this should also check expression
3356 : * index columns.
3357 : */
3358 126 : if (rel->rd_rel->relkind != RELKIND_RELATION &&
3359 36 : rel->rd_rel->relkind != RELKIND_MATVIEW)
3360 : {
3361 36 : relation_close(rel, lockmode);
3362 36 : continue;
3363 : }
3364 :
3365 : /* Build the RelToCheck entry with enough space for all atts */
3366 90 : rtc = (RelToCheck *) palloc(sizeof(RelToCheck));
3367 90 : rtc->rel = rel;
3368 90 : rtc->natts = 0;
3369 90 : rtc->atts = (int *) palloc(sizeof(int) * RelationGetNumberOfAttributes(rel));
3370 90 : result = lappend(result, rtc);
3371 : }
3372 :
3373 : /*
3374 : * Confirm column has not been dropped, and is of the expected type.
3375 : * This defends against an ALTER DROP COLUMN occurring just before we
3376 : * acquired lock ... but if the whole table were dropped, we'd still
3377 : * have a problem.
3378 : */
3379 108 : if (pg_depend->objsubid > RelationGetNumberOfAttributes(rtc->rel))
3380 0 : continue;
3381 108 : pg_att = TupleDescAttr(rtc->rel->rd_att, pg_depend->objsubid - 1);
3382 108 : if (pg_att->attisdropped || pg_att->atttypid != domainOid)
3383 0 : continue;
3384 :
3385 : /*
3386 : * Okay, add column to result. We store the columns in column-number
3387 : * order; this is just a hack to improve predictability of regression
3388 : * test output ...
3389 : */
3390 : Assert(rtc->natts < RelationGetNumberOfAttributes(rtc->rel));
3391 :
3392 108 : ptr = rtc->natts++;
3393 108 : while (ptr > 0 && rtc->atts[ptr - 1] > pg_depend->objsubid)
3394 : {
3395 0 : rtc->atts[ptr] = rtc->atts[ptr - 1];
3396 0 : ptr--;
3397 : }
3398 108 : rtc->atts[ptr] = pg_depend->objsubid;
3399 : }
3400 :
3401 150 : systable_endscan(depScan);
3402 :
3403 150 : relation_close(depRel, AccessShareLock);
3404 :
3405 150 : return result;
3406 : }
3407 :
3408 : /*
3409 : * checkDomainOwner
3410 : *
3411 : * Check that the type is actually a domain and that the current user
3412 : * has permission to do ALTER DOMAIN on it. Throw an error if not.
3413 : */
3414 : void
3415 260 : checkDomainOwner(HeapTuple tup)
3416 : {
3417 260 : Form_pg_type typTup = (Form_pg_type) GETSTRUCT(tup);
3418 :
3419 : /* Check that this is actually a domain */
3420 260 : if (typTup->typtype != TYPTYPE_DOMAIN)
3421 0 : ereport(ERROR,
3422 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3423 : errmsg("%s is not a domain",
3424 : format_type_be(typTup->oid))));
3425 :
3426 : /* Permission check: must own type */
3427 260 : if (!object_ownercheck(TypeRelationId, typTup->oid, GetUserId()))
3428 0 : aclcheck_error_type(ACLCHECK_NOT_OWNER, typTup->oid);
3429 260 : }
3430 :
3431 : /*
3432 : * domainAddConstraint - code shared between CREATE and ALTER DOMAIN
3433 : */
3434 : static char *
3435 1606 : domainAddConstraint(Oid domainOid, Oid domainNamespace, Oid baseTypeOid,
3436 : int typMod, Constraint *constr,
3437 : const char *domainName, ObjectAddress *constrAddr)
3438 : {
3439 : Node *expr;
3440 : char *ccbin;
3441 : ParseState *pstate;
3442 : CoerceToDomainValue *domVal;
3443 : Oid ccoid;
3444 :
3445 : /*
3446 : * Assign or validate constraint name
3447 : */
3448 1606 : if (constr->conname)
3449 : {
3450 1390 : if (ConstraintNameIsUsed(CONSTRAINT_DOMAIN,
3451 : domainOid,
3452 1390 : constr->conname))
3453 0 : ereport(ERROR,
3454 : (errcode(ERRCODE_DUPLICATE_OBJECT),
3455 : errmsg("constraint \"%s\" for domain \"%s\" already exists",
3456 : constr->conname, domainName)));
3457 : }
3458 : else
3459 216 : constr->conname = ChooseConstraintName(domainName,
3460 : NULL,
3461 : "check",
3462 : domainNamespace,
3463 : NIL);
3464 :
3465 : /*
3466 : * Convert the A_EXPR in raw_expr into an EXPR
3467 : */
3468 1606 : pstate = make_parsestate(NULL);
3469 :
3470 : /*
3471 : * Set up a CoerceToDomainValue to represent the occurrence of VALUE in
3472 : * the expression. Note that it will appear to have the type of the base
3473 : * type, not the domain. This seems correct since within the check
3474 : * expression, we should not assume the input value can be considered a
3475 : * member of the domain.
3476 : */
3477 1606 : domVal = makeNode(CoerceToDomainValue);
3478 1606 : domVal->typeId = baseTypeOid;
3479 1606 : domVal->typeMod = typMod;
3480 1606 : domVal->collation = get_typcollation(baseTypeOid);
3481 1606 : domVal->location = -1; /* will be set when/if used */
3482 :
3483 1606 : pstate->p_pre_columnref_hook = replace_domain_constraint_value;
3484 1606 : pstate->p_ref_hook_state = (void *) domVal;
3485 :
3486 1606 : expr = transformExpr(pstate, constr->raw_expr, EXPR_KIND_DOMAIN_CHECK);
3487 :
3488 : /*
3489 : * Make sure it yields a boolean result.
3490 : */
3491 1600 : expr = coerce_to_boolean(pstate, expr, "CHECK");
3492 :
3493 : /*
3494 : * Fix up collation information.
3495 : */
3496 1600 : assign_expr_collations(pstate, expr);
3497 :
3498 : /*
3499 : * Domains don't allow variables (this is probably dead code now that
3500 : * add_missing_from is history, but let's be sure).
3501 : */
3502 3200 : if (pstate->p_rtable != NIL ||
3503 1600 : contain_var_clause(expr))
3504 0 : ereport(ERROR,
3505 : (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
3506 : errmsg("cannot use table references in domain check constraint")));
3507 :
3508 : /*
3509 : * Convert to string form for storage.
3510 : */
3511 1600 : ccbin = nodeToString(expr);
3512 :
3513 : /*
3514 : * Store the constraint in pg_constraint
3515 : */
3516 : ccoid =
3517 1600 : CreateConstraintEntry(constr->conname, /* Constraint Name */
3518 : domainNamespace, /* namespace */
3519 : CONSTRAINT_CHECK, /* Constraint Type */
3520 : false, /* Is Deferrable */
3521 : false, /* Is Deferred */
3522 1600 : !constr->skip_validation, /* Is Validated */
3523 : InvalidOid, /* no parent constraint */
3524 : InvalidOid, /* not a relation constraint */
3525 : NULL,
3526 : 0,
3527 : 0,
3528 : domainOid, /* domain constraint */
3529 : InvalidOid, /* no associated index */
3530 : InvalidOid, /* Foreign key fields */
3531 : NULL,
3532 : NULL,
3533 : NULL,
3534 : NULL,
3535 : 0,
3536 : ' ',
3537 : ' ',
3538 : NULL,
3539 : 0,
3540 : ' ',
3541 : NULL, /* not an exclusion constraint */
3542 : expr, /* Tree form of check constraint */
3543 : ccbin, /* Binary form of check constraint */
3544 : true, /* is local */
3545 : 0, /* inhcount */
3546 : false, /* connoinherit */
3547 1600 : false); /* is_internal */
3548 1600 : if (constrAddr)
3549 130 : ObjectAddressSet(*constrAddr, ConstraintRelationId, ccoid);
3550 :
3551 : /*
3552 : * Return the compiled constraint expression so the calling routine can
3553 : * perform any additional required tests.
3554 : */
3555 1600 : return ccbin;
3556 : }
3557 :
3558 : /* Parser pre_columnref_hook for domain CHECK constraint parsing */
3559 : static Node *
3560 1698 : replace_domain_constraint_value(ParseState *pstate, ColumnRef *cref)
3561 : {
3562 : /*
3563 : * Check for a reference to "value", and if that's what it is, replace
3564 : * with a CoerceToDomainValue as prepared for us by domainAddConstraint.
3565 : * (We handle VALUE as a name, not a keyword, to avoid breaking a lot of
3566 : * applications that have used VALUE as a column name in the past.)
3567 : */
3568 1698 : if (list_length(cref->fields) == 1)
3569 : {
3570 1698 : Node *field1 = (Node *) linitial(cref->fields);
3571 : char *colname;
3572 :
3573 1698 : colname = strVal(field1);
3574 1698 : if (strcmp(colname, "value") == 0)
3575 : {
3576 1698 : CoerceToDomainValue *domVal = copyObject(pstate->p_ref_hook_state);
3577 :
3578 : /* Propagate location knowledge, if any */
3579 1698 : domVal->location = cref->location;
3580 1698 : return (Node *) domVal;
3581 : }
3582 : }
3583 0 : return NULL;
3584 : }
3585 :
3586 :
3587 : /*
3588 : * Execute ALTER TYPE RENAME
3589 : */
3590 : ObjectAddress
3591 32 : RenameType(RenameStmt *stmt)
3592 : {
3593 32 : List *names = castNode(List, stmt->object);
3594 32 : const char *newTypeName = stmt->newname;
3595 : TypeName *typename;
3596 : Oid typeOid;
3597 : Relation rel;
3598 : HeapTuple tup;
3599 : Form_pg_type typTup;
3600 : ObjectAddress address;
3601 :
3602 : /* Make a TypeName so we can use standard type lookup machinery */
3603 32 : typename = makeTypeNameFromNameList(names);
3604 32 : typeOid = typenameTypeId(NULL, typename);
3605 :
3606 : /* Look up the type in the type table */
3607 32 : rel = table_open(TypeRelationId, RowExclusiveLock);
3608 :
3609 32 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(typeOid));
3610 32 : if (!HeapTupleIsValid(tup))
3611 0 : elog(ERROR, "cache lookup failed for type %u", typeOid);
3612 32 : typTup = (Form_pg_type) GETSTRUCT(tup);
3613 :
3614 : /* check permissions on type */
3615 32 : if (!object_ownercheck(TypeRelationId, typeOid, GetUserId()))
3616 0 : aclcheck_error_type(ACLCHECK_NOT_OWNER, typeOid);
3617 :
3618 : /* ALTER DOMAIN used on a non-domain? */
3619 32 : if (stmt->renameType == OBJECT_DOMAIN && typTup->typtype != TYPTYPE_DOMAIN)
3620 0 : ereport(ERROR,
3621 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3622 : errmsg("%s is not a domain",
3623 : format_type_be(typeOid))));
3624 :
3625 : /*
3626 : * If it's a composite type, we need to check that it really is a
3627 : * free-standing composite type, and not a table's rowtype. We want people
3628 : * to use ALTER TABLE not ALTER TYPE for that case.
3629 : */
3630 34 : if (typTup->typtype == TYPTYPE_COMPOSITE &&
3631 2 : get_rel_relkind(typTup->typrelid) != RELKIND_COMPOSITE_TYPE)
3632 0 : ereport(ERROR,
3633 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3634 : errmsg("%s is a table's row type",
3635 : format_type_be(typeOid)),
3636 : errhint("Use ALTER TABLE instead.")));
3637 :
3638 : /* don't allow direct alteration of array types, either */
3639 32 : if (IsTrueArrayType(typTup))
3640 0 : ereport(ERROR,
3641 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3642 : errmsg("cannot alter array type %s",
3643 : format_type_be(typeOid)),
3644 : errhint("You can alter type %s, which will alter the array type as well.",
3645 : format_type_be(typTup->typelem))));
3646 :
3647 : /*
3648 : * If type is composite we need to rename associated pg_class entry too.
3649 : * RenameRelationInternal will call RenameTypeInternal automatically.
3650 : */
3651 32 : if (typTup->typtype == TYPTYPE_COMPOSITE)
3652 2 : RenameRelationInternal(typTup->typrelid, newTypeName, false, false);
3653 : else
3654 30 : RenameTypeInternal(typeOid, newTypeName,
3655 : typTup->typnamespace);
3656 :
3657 32 : ObjectAddressSet(address, TypeRelationId, typeOid);
3658 : /* Clean up */
3659 32 : table_close(rel, RowExclusiveLock);
3660 :
3661 32 : return address;
3662 : }
3663 :
3664 : /*
3665 : * Change the owner of a type.
3666 : */
3667 : ObjectAddress
3668 96 : AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype)
3669 : {
3670 : TypeName *typename;
3671 : Oid typeOid;
3672 : Relation rel;
3673 : HeapTuple tup;
3674 : HeapTuple newtup;
3675 : Form_pg_type typTup;
3676 : AclResult aclresult;
3677 : ObjectAddress address;
3678 :
3679 96 : rel = table_open(TypeRelationId, RowExclusiveLock);
3680 :
3681 : /* Make a TypeName so we can use standard type lookup machinery */
3682 96 : typename = makeTypeNameFromNameList(names);
3683 :
3684 : /* Use LookupTypeName here so that shell types can be processed */
3685 96 : tup = LookupTypeName(NULL, typename, NULL, false);
3686 96 : if (tup == NULL)
3687 0 : ereport(ERROR,
3688 : (errcode(ERRCODE_UNDEFINED_OBJECT),
3689 : errmsg("type \"%s\" does not exist",
3690 : TypeNameToString(typename))));
3691 96 : typeOid = typeTypeId(tup);
3692 :
3693 : /* Copy the syscache entry so we can scribble on it below */
3694 96 : newtup = heap_copytuple(tup);
3695 96 : ReleaseSysCache(tup);
3696 96 : tup = newtup;
3697 96 : typTup = (Form_pg_type) GETSTRUCT(tup);
3698 :
3699 : /* Don't allow ALTER DOMAIN on a type */
3700 96 : if (objecttype == OBJECT_DOMAIN && typTup->typtype != TYPTYPE_DOMAIN)
3701 0 : ereport(ERROR,
3702 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3703 : errmsg("%s is not a domain",
3704 : format_type_be(typeOid))));
3705 :
3706 : /*
3707 : * If it's a composite type, we need to check that it really is a
3708 : * free-standing composite type, and not a table's rowtype. We want people
3709 : * to use ALTER TABLE not ALTER TYPE for that case.
3710 : */
3711 124 : if (typTup->typtype == TYPTYPE_COMPOSITE &&
3712 28 : get_rel_relkind(typTup->typrelid) != RELKIND_COMPOSITE_TYPE)
3713 0 : ereport(ERROR,
3714 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3715 : errmsg("%s is a table's row type",
3716 : format_type_be(typeOid)),
3717 : errhint("Use ALTER TABLE instead.")));
3718 :
3719 : /* don't allow direct alteration of array types, either */
3720 96 : if (IsTrueArrayType(typTup))
3721 0 : ereport(ERROR,
3722 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3723 : errmsg("cannot alter array type %s",
3724 : format_type_be(typeOid)),
3725 : errhint("You can alter type %s, which will alter the array type as well.",
3726 : format_type_be(typTup->typelem))));
3727 :
3728 : /*
3729 : * If the new owner is the same as the existing owner, consider the
3730 : * command to have succeeded. This is for dump restoration purposes.
3731 : */
3732 96 : if (typTup->typowner != newOwnerId)
3733 : {
3734 : /* Superusers can always do it */
3735 0 : if (!superuser())
3736 : {
3737 : /* Otherwise, must be owner of the existing object */
3738 0 : if (!object_ownercheck(TypeRelationId, typTup->oid, GetUserId()))
3739 0 : aclcheck_error_type(ACLCHECK_NOT_OWNER, typTup->oid);
3740 :
3741 : /* Must be able to become new owner */
3742 0 : check_can_set_role(GetUserId(), newOwnerId);
3743 :
3744 : /* New owner must have CREATE privilege on namespace */
3745 0 : aclresult = object_aclcheck(NamespaceRelationId, typTup->typnamespace,
3746 : newOwnerId,
3747 : ACL_CREATE);
3748 0 : if (aclresult != ACLCHECK_OK)
3749 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
3750 0 : get_namespace_name(typTup->typnamespace));
3751 : }
3752 :
3753 0 : AlterTypeOwner_oid(typeOid, newOwnerId, true);
3754 : }
3755 :
3756 96 : ObjectAddressSet(address, TypeRelationId, typeOid);
3757 :
3758 : /* Clean up */
3759 96 : table_close(rel, RowExclusiveLock);
3760 :
3761 96 : return address;
3762 : }
3763 :
3764 : /*
3765 : * AlterTypeOwner_oid - change type owner unconditionally
3766 : *
3767 : * This function recurses to handle a pg_class entry, if necessary. It
3768 : * invokes any necessary access object hooks. If hasDependEntry is true, this
3769 : * function modifies the pg_shdepend entry appropriately (this should be
3770 : * passed as false only for table rowtypes and array types).
3771 : *
3772 : * This is used by ALTER TABLE/TYPE OWNER commands, as well as by REASSIGN
3773 : * OWNED BY. It assumes the caller has done all needed check.
3774 : */
3775 : void
3776 24 : AlterTypeOwner_oid(Oid typeOid, Oid newOwnerId, bool hasDependEntry)
3777 : {
3778 : Relation rel;
3779 : HeapTuple tup;
3780 : Form_pg_type typTup;
3781 :
3782 24 : rel = table_open(TypeRelationId, RowExclusiveLock);
3783 :
3784 24 : tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
3785 24 : if (!HeapTupleIsValid(tup))
3786 0 : elog(ERROR, "cache lookup failed for type %u", typeOid);
3787 24 : typTup = (Form_pg_type) GETSTRUCT(tup);
3788 :
3789 : /*
3790 : * If it's a composite type, invoke ATExecChangeOwner so that we fix up
3791 : * the pg_class entry properly. That will call back to
3792 : * AlterTypeOwnerInternal to take care of the pg_type entry(s).
3793 : */
3794 24 : if (typTup->typtype == TYPTYPE_COMPOSITE)
3795 6 : ATExecChangeOwner(typTup->typrelid, newOwnerId, true, AccessExclusiveLock);
3796 : else
3797 18 : AlterTypeOwnerInternal(typeOid, newOwnerId);
3798 :
3799 : /* Update owner dependency reference */
3800 24 : if (hasDependEntry)
3801 24 : changeDependencyOnOwner(TypeRelationId, typeOid, newOwnerId);
3802 :
3803 24 : InvokeObjectPostAlterHook(TypeRelationId, typeOid, 0);
3804 :
3805 24 : ReleaseSysCache(tup);
3806 24 : table_close(rel, RowExclusiveLock);
3807 24 : }
3808 :
3809 : /*
3810 : * AlterTypeOwnerInternal - bare-bones type owner change.
3811 : *
3812 : * This routine simply modifies the owner of a pg_type entry, and recurses
3813 : * to handle a possible array type.
3814 : */
3815 : void
3816 592 : AlterTypeOwnerInternal(Oid typeOid, Oid newOwnerId)
3817 : {
3818 : Relation rel;
3819 : HeapTuple tup;
3820 : Form_pg_type typTup;
3821 : Datum repl_val[Natts_pg_type];
3822 : bool repl_null[Natts_pg_type];
3823 : bool repl_repl[Natts_pg_type];
3824 : Acl *newAcl;
3825 : Datum aclDatum;
3826 : bool isNull;
3827 :
3828 592 : rel = table_open(TypeRelationId, RowExclusiveLock);
3829 :
3830 592 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(typeOid));
3831 592 : if (!HeapTupleIsValid(tup))
3832 0 : elog(ERROR, "cache lookup failed for type %u", typeOid);
3833 592 : typTup = (Form_pg_type) GETSTRUCT(tup);
3834 :
3835 592 : memset(repl_null, false, sizeof(repl_null));
3836 592 : memset(repl_repl, false, sizeof(repl_repl));
3837 :
3838 592 : repl_repl[Anum_pg_type_typowner - 1] = true;
3839 592 : repl_val[Anum_pg_type_typowner - 1] = ObjectIdGetDatum(newOwnerId);
3840 :
3841 592 : aclDatum = heap_getattr(tup,
3842 : Anum_pg_type_typacl,
3843 : RelationGetDescr(rel),
3844 : &isNull);
3845 : /* Null ACLs do not require changes */
3846 592 : if (!isNull)
3847 : {
3848 0 : newAcl = aclnewowner(DatumGetAclP(aclDatum),
3849 : typTup->typowner, newOwnerId);
3850 0 : repl_repl[Anum_pg_type_typacl - 1] = true;
3851 0 : repl_val[Anum_pg_type_typacl - 1] = PointerGetDatum(newAcl);
3852 : }
3853 :
3854 592 : tup = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null,
3855 : repl_repl);
3856 :
3857 592 : CatalogTupleUpdate(rel, &tup->t_self, tup);
3858 :
3859 : /* If it has an array type, update that too */
3860 592 : if (OidIsValid(typTup->typarray))
3861 296 : AlterTypeOwnerInternal(typTup->typarray, newOwnerId);
3862 :
3863 : /* Clean up */
3864 592 : table_close(rel, RowExclusiveLock);
3865 592 : }
3866 :
3867 : /*
3868 : * Execute ALTER TYPE SET SCHEMA
3869 : */
3870 : ObjectAddress
3871 18 : AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype,
3872 : Oid *oldschema)
3873 : {
3874 : TypeName *typename;
3875 : Oid typeOid;
3876 : Oid nspOid;
3877 : Oid oldNspOid;
3878 : ObjectAddresses *objsMoved;
3879 : ObjectAddress myself;
3880 :
3881 : /* Make a TypeName so we can use standard type lookup machinery */
3882 18 : typename = makeTypeNameFromNameList(names);
3883 18 : typeOid = typenameTypeId(NULL, typename);
3884 :
3885 : /* Don't allow ALTER DOMAIN on a type */
3886 18 : if (objecttype == OBJECT_DOMAIN && get_typtype(typeOid) != TYPTYPE_DOMAIN)
3887 0 : ereport(ERROR,
3888 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3889 : errmsg("%s is not a domain",
3890 : format_type_be(typeOid))));
3891 :
3892 : /* get schema OID and check its permissions */
3893 18 : nspOid = LookupCreationNamespace(newschema);
3894 :
3895 18 : objsMoved = new_object_addresses();
3896 18 : oldNspOid = AlterTypeNamespace_oid(typeOid, nspOid, objsMoved);
3897 18 : free_object_addresses(objsMoved);
3898 :
3899 18 : if (oldschema)
3900 18 : *oldschema = oldNspOid;
3901 :
3902 18 : ObjectAddressSet(myself, TypeRelationId, typeOid);
3903 :
3904 18 : return myself;
3905 : }
3906 :
3907 : Oid
3908 18 : AlterTypeNamespace_oid(Oid typeOid, Oid nspOid, ObjectAddresses *objsMoved)
3909 : {
3910 : Oid elemOid;
3911 :
3912 : /* check permissions on type */
3913 18 : if (!object_ownercheck(TypeRelationId, typeOid, GetUserId()))
3914 0 : aclcheck_error_type(ACLCHECK_NOT_OWNER, typeOid);
3915 :
3916 : /* don't allow direct alteration of array types */
3917 18 : elemOid = get_element_type(typeOid);
3918 18 : if (OidIsValid(elemOid) && get_array_type(elemOid) == typeOid)
3919 0 : ereport(ERROR,
3920 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
3921 : errmsg("cannot alter array type %s",
3922 : format_type_be(typeOid)),
3923 : errhint("You can alter type %s, which will alter the array type as well.",
3924 : format_type_be(elemOid))));
3925 :
3926 : /* and do the work */
3927 18 : return AlterTypeNamespaceInternal(typeOid, nspOid, false, true, objsMoved);
3928 : }
3929 :
3930 : /*
3931 : * Move specified type to new namespace.
3932 : *
3933 : * Caller must have already checked privileges.
3934 : *
3935 : * The function automatically recurses to process the type's array type,
3936 : * if any. isImplicitArray should be true only when doing this internal
3937 : * recursion (outside callers must never try to move an array type directly).
3938 : *
3939 : * If errorOnTableType is true, the function errors out if the type is
3940 : * a table type. ALTER TABLE has to be used to move a table to a new
3941 : * namespace.
3942 : *
3943 : * Returns the type's old namespace OID.
3944 : */
3945 : Oid
3946 200 : AlterTypeNamespaceInternal(Oid typeOid, Oid nspOid,
3947 : bool isImplicitArray,
3948 : bool errorOnTableType,
3949 : ObjectAddresses *objsMoved)
3950 : {
3951 : Relation rel;
3952 : HeapTuple tup;
3953 : Form_pg_type typform;
3954 : Oid oldNspOid;
3955 : Oid arrayOid;
3956 : bool isCompositeType;
3957 : ObjectAddress thisobj;
3958 :
3959 : /*
3960 : * Make sure we haven't moved this object previously.
3961 : */
3962 200 : thisobj.classId = TypeRelationId;
3963 200 : thisobj.objectId = typeOid;
3964 200 : thisobj.objectSubId = 0;
3965 :
3966 200 : if (object_address_present(&thisobj, objsMoved))
3967 0 : return InvalidOid;
3968 :
3969 200 : rel = table_open(TypeRelationId, RowExclusiveLock);
3970 :
3971 200 : tup = SearchSysCacheCopy1(TYPEOID, ObjectIdGetDatum(typeOid));
3972 200 : if (!HeapTupleIsValid(tup))
3973 0 : elog(ERROR, "cache lookup failed for type %u", typeOid);
3974 200 : typform = (Form_pg_type) GETSTRUCT(tup);
3975 :
3976 200 : oldNspOid = typform->typnamespace;
3977 200 : arrayOid = typform->typarray;
3978 :
3979 : /* If the type is already there, we scan skip these next few checks. */
3980 200 : if (oldNspOid != nspOid)
3981 : {
3982 : /* common checks on switching namespaces */
3983 164 : CheckSetNamespace(oldNspOid, nspOid);
3984 :
3985 : /* check for duplicate name (more friendly than unique-index failure) */
3986 164 : if (SearchSysCacheExists2(TYPENAMENSP,
3987 : NameGetDatum(&typform->typname),
3988 : ObjectIdGetDatum(nspOid)))
3989 0 : ereport(ERROR,
3990 : (errcode(ERRCODE_DUPLICATE_OBJECT),
3991 : errmsg("type \"%s\" already exists in schema \"%s\"",
3992 : NameStr(typform->typname),
3993 : get_namespace_name(nspOid))));
3994 : }
3995 :
3996 : /* Detect whether type is a composite type (but not a table rowtype) */
3997 200 : isCompositeType =
3998 294 : (typform->typtype == TYPTYPE_COMPOSITE &&
3999 94 : get_rel_relkind(typform->typrelid) == RELKIND_COMPOSITE_TYPE);
4000 :
4001 : /* Enforce not-table-type if requested */
4002 200 : if (typform->typtype == TYPTYPE_COMPOSITE && !isCompositeType &&
4003 : errorOnTableType)
4004 0 : ereport(ERROR,
4005 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
4006 : errmsg("%s is a table's row type",
4007 : format_type_be(typeOid)),
4008 : errhint("Use ALTER TABLE instead.")));
4009 :
4010 200 : if (oldNspOid != nspOid)
4011 : {
4012 : /* OK, modify the pg_type row */
4013 :
4014 : /* tup is a copy, so we can scribble directly on it */
4015 164 : typform->typnamespace = nspOid;
4016 :
4017 164 : CatalogTupleUpdate(rel, &tup->t_self, tup);
4018 : }
4019 :
4020 : /*
4021 : * Composite types have pg_class entries.
4022 : *
4023 : * We need to modify the pg_class tuple as well to reflect the change of
4024 : * schema.
4025 : */
4026 200 : if (isCompositeType)
4027 : {
4028 : Relation classRel;
4029 :
4030 12 : classRel = table_open(RelationRelationId, RowExclusiveLock);
4031 :
4032 12 : AlterRelationNamespaceInternal(classRel, typform->typrelid,
4033 : oldNspOid, nspOid,
4034 : false, objsMoved);
4035 :
4036 12 : table_close(classRel, RowExclusiveLock);
4037 :
4038 : /*
4039 : * Check for constraints associated with the composite type (we don't
4040 : * currently support this, but probably will someday).
4041 : */
4042 12 : AlterConstraintNamespaces(typform->typrelid, oldNspOid,
4043 : nspOid, false, objsMoved);
4044 : }
4045 : else
4046 : {
4047 : /* If it's a domain, it might have constraints */
4048 188 : if (typform->typtype == TYPTYPE_DOMAIN)
4049 6 : AlterConstraintNamespaces(typeOid, oldNspOid, nspOid, true,
4050 : objsMoved);
4051 : }
4052 :
4053 : /*
4054 : * Update dependency on schema, if any --- a table rowtype has not got
4055 : * one, and neither does an implicit array.
4056 : */
4057 200 : if (oldNspOid != nspOid &&
4058 158 : (isCompositeType || typform->typtype != TYPTYPE_COMPOSITE) &&
4059 94 : !isImplicitArray)
4060 12 : if (changeDependencyFor(TypeRelationId, typeOid,
4061 : NamespaceRelationId, oldNspOid, nspOid) != 1)
4062 0 : elog(ERROR, "failed to change schema dependency for type %s",
4063 : format_type_be(typeOid));
4064 :
4065 200 : InvokeObjectPostAlterHook(TypeRelationId, typeOid, 0);
4066 :
4067 200 : heap_freetuple(tup);
4068 :
4069 200 : table_close(rel, RowExclusiveLock);
4070 :
4071 200 : add_exact_object_address(&thisobj, objsMoved);
4072 :
4073 : /* Recursively alter the associated array type, if any */
4074 200 : if (OidIsValid(arrayOid))
4075 100 : AlterTypeNamespaceInternal(arrayOid, nspOid, true, true, objsMoved);
4076 :
4077 200 : return oldNspOid;
4078 : }
4079 :
4080 : /*
4081 : * AlterType
4082 : * ALTER TYPE <type> SET (option = ...)
4083 : *
4084 : * NOTE: the set of changes that can be allowed here is constrained by many
4085 : * non-obvious implementation restrictions. Tread carefully when considering
4086 : * adding new flexibility.
4087 : */
4088 : ObjectAddress
4089 60 : AlterType(AlterTypeStmt *stmt)
4090 : {
4091 : ObjectAddress address;
4092 : Relation catalog;
4093 : TypeName *typename;
4094 : HeapTuple tup;
4095 : Oid typeOid;
4096 : Form_pg_type typForm;
4097 60 : bool requireSuper = false;
4098 : AlterTypeRecurseParams atparams;
4099 : ListCell *pl;
4100 :
4101 60 : catalog = table_open(TypeRelationId, RowExclusiveLock);
4102 :
4103 : /* Make a TypeName so we can use standard type lookup machinery */
4104 60 : typename = makeTypeNameFromNameList(stmt->typeName);
4105 60 : tup = typenameType(NULL, typename, NULL);
4106 :
4107 54 : typeOid = typeTypeId(tup);
4108 54 : typForm = (Form_pg_type) GETSTRUCT(tup);
4109 :
4110 : /* Process options */
4111 54 : memset(&atparams, 0, sizeof(atparams));
4112 154 : foreach(pl, stmt->options)
4113 : {
4114 106 : DefElem *defel = (DefElem *) lfirst(pl);
4115 :
4116 106 : if (strcmp(defel->defname, "storage") == 0)
4117 : {
4118 12 : char *a = defGetString(defel);
4119 :
4120 12 : if (pg_strcasecmp(a, "plain") == 0)
4121 6 : atparams.storage = TYPSTORAGE_PLAIN;
4122 6 : else if (pg_strcasecmp(a, "external") == 0)
4123 0 : atparams.storage = TYPSTORAGE_EXTERNAL;
4124 6 : else if (pg_strcasecmp(a, "extended") == 0)
4125 6 : atparams.storage = TYPSTORAGE_EXTENDED;
4126 0 : else if (pg_strcasecmp(a, "main") == 0)
4127 0 : atparams.storage = TYPSTORAGE_MAIN;
4128 : else
4129 0 : ereport(ERROR,
4130 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4131 : errmsg("storage \"%s\" not recognized", a)));
4132 :
4133 : /*
4134 : * Validate the storage request. If the type isn't varlena, it
4135 : * certainly doesn't support non-PLAIN storage.
4136 : */
4137 12 : if (atparams.storage != TYPSTORAGE_PLAIN && typForm->typlen != -1)
4138 0 : ereport(ERROR,
4139 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
4140 : errmsg("fixed-size types must have storage PLAIN")));
4141 :
4142 : /*
4143 : * Switching from PLAIN to non-PLAIN is allowed, but it requires
4144 : * superuser, since we can't validate that the type's C functions
4145 : * will support it. Switching from non-PLAIN to PLAIN is
4146 : * disallowed outright, because it's not practical to ensure that
4147 : * no tables have toasted values of the type. Switching among
4148 : * different non-PLAIN settings is OK, since it just constitutes a
4149 : * change in the strategy requested for columns created in the
4150 : * future.
4151 : */
4152 12 : if (atparams.storage != TYPSTORAGE_PLAIN &&
4153 6 : typForm->typstorage == TYPSTORAGE_PLAIN)
4154 0 : requireSuper = true;
4155 12 : else if (atparams.storage == TYPSTORAGE_PLAIN &&
4156 6 : typForm->typstorage != TYPSTORAGE_PLAIN)
4157 6 : ereport(ERROR,
4158 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
4159 : errmsg("cannot change type's storage to PLAIN")));
4160 :
4161 6 : atparams.updateStorage = true;
4162 : }
4163 94 : else if (strcmp(defel->defname, "receive") == 0)
4164 : {
4165 28 : if (defel->arg != NULL)
4166 28 : atparams.receiveOid =
4167 28 : findTypeReceiveFunction(defGetQualifiedName(defel),
4168 : typeOid);
4169 : else
4170 0 : atparams.receiveOid = InvalidOid; /* NONE, remove function */
4171 28 : atparams.updateReceive = true;
4172 : /* Replacing an I/O function requires superuser. */
4173 28 : requireSuper = true;
4174 : }
4175 66 : else if (strcmp(defel->defname, "send") == 0)
4176 : {
4177 28 : if (defel->arg != NULL)
4178 28 : atparams.sendOid =
4179 28 : findTypeSendFunction(defGetQualifiedName(defel),
4180 : typeOid);
4181 : else
4182 0 : atparams.sendOid = InvalidOid; /* NONE, remove function */
4183 28 : atparams.updateSend = true;
4184 : /* Replacing an I/O function requires superuser. */
4185 28 : requireSuper = true;
4186 : }
4187 38 : else if (strcmp(defel->defname, "typmod_in") == 0)
4188 : {
4189 6 : if (defel->arg != NULL)
4190 6 : atparams.typmodinOid =
4191 6 : findTypeTypmodinFunction(defGetQualifiedName(defel));
4192 : else
4193 0 : atparams.typmodinOid = InvalidOid; /* NONE, remove function */
4194 6 : atparams.updateTypmodin = true;
4195 : /* Replacing an I/O function requires superuser. */
4196 6 : requireSuper = true;
4197 : }
4198 32 : else if (strcmp(defel->defname, "typmod_out") == 0)
4199 : {
4200 6 : if (defel->arg != NULL)
4201 6 : atparams.typmodoutOid =
4202 6 : findTypeTypmodoutFunction(defGetQualifiedName(defel));
4203 : else
4204 0 : atparams.typmodoutOid = InvalidOid; /* NONE, remove function */
4205 6 : atparams.updateTypmodout = true;
4206 : /* Replacing an I/O function requires superuser. */
4207 6 : requireSuper = true;
4208 : }
4209 26 : else if (strcmp(defel->defname, "analyze") == 0)
4210 : {
4211 6 : if (defel->arg != NULL)
4212 6 : atparams.analyzeOid =
4213 6 : findTypeAnalyzeFunction(defGetQualifiedName(defel),
4214 : typeOid);
4215 : else
4216 0 : atparams.analyzeOid = InvalidOid; /* NONE, remove function */
4217 6 : atparams.updateAnalyze = true;
4218 : /* Replacing an analyze function requires superuser. */
4219 6 : requireSuper = true;
4220 : }
4221 20 : else if (strcmp(defel->defname, "subscript") == 0)
4222 : {
4223 20 : if (defel->arg != NULL)
4224 20 : atparams.subscriptOid =
4225 20 : findTypeSubscriptingFunction(defGetQualifiedName(defel),
4226 : typeOid);
4227 : else
4228 0 : atparams.subscriptOid = InvalidOid; /* NONE, remove function */
4229 20 : atparams.updateSubscript = true;
4230 : /* Replacing a subscript function requires superuser. */
4231 20 : requireSuper = true;
4232 : }
4233 :
4234 : /*
4235 : * The rest of the options that CREATE accepts cannot be changed.
4236 : * Check for them so that we can give a meaningful error message.
4237 : */
4238 0 : else if (strcmp(defel->defname, "input") == 0 ||
4239 0 : strcmp(defel->defname, "output") == 0 ||
4240 0 : strcmp(defel->defname, "internallength") == 0 ||
4241 0 : strcmp(defel->defname, "passedbyvalue") == 0 ||
4242 0 : strcmp(defel->defname, "alignment") == 0 ||
4243 0 : strcmp(defel->defname, "like") == 0 ||
4244 0 : strcmp(defel->defname, "category") == 0 ||
4245 0 : strcmp(defel->defname, "preferred") == 0 ||
4246 0 : strcmp(defel->defname, "default") == 0 ||
4247 0 : strcmp(defel->defname, "element") == 0 ||
4248 0 : strcmp(defel->defname, "delimiter") == 0 ||
4249 0 : strcmp(defel->defname, "collatable") == 0)
4250 0 : ereport(ERROR,
4251 : (errcode(ERRCODE_SYNTAX_ERROR),
4252 : errmsg("type attribute \"%s\" cannot be changed",
4253 : defel->defname)));
4254 : else
4255 0 : ereport(ERROR,
4256 : (errcode(ERRCODE_SYNTAX_ERROR),
4257 : errmsg("type attribute \"%s\" not recognized",
4258 : defel->defname)));
4259 : }
4260 :
4261 : /*
4262 : * Permissions check. Require superuser if we decided the command
4263 : * requires that, else must own the type.
4264 : */
4265 48 : if (requireSuper)
4266 : {
4267 42 : if (!superuser())
4268 0 : ereport(ERROR,
4269 : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4270 : errmsg("must be superuser to alter a type")));
4271 : }
4272 : else
4273 : {
4274 6 : if (!object_ownercheck(TypeRelationId, typeOid, GetUserId()))
4275 0 : aclcheck_error_type(ACLCHECK_NOT_OWNER, typeOid);
4276 : }
4277 :
4278 : /*
4279 : * We disallow all forms of ALTER TYPE SET on types that aren't plain base
4280 : * types. It would for example be highly unsafe, not to mention
4281 : * pointless, to change the send/receive functions for a composite type.
4282 : * Moreover, pg_dump has no support for changing these properties on
4283 : * non-base types. We might weaken this someday, but not now.
4284 : *
4285 : * Note: if you weaken this enough to allow composite types, be sure to
4286 : * adjust the GenerateTypeDependencies call in AlterTypeRecurse.
4287 : */
4288 48 : if (typForm->typtype != TYPTYPE_BASE)
4289 0 : ereport(ERROR,
4290 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
4291 : errmsg("%s is not a base type",
4292 : format_type_be(typeOid))));
4293 :
4294 : /*
4295 : * For the same reasons, don't allow direct alteration of array types.
4296 : */
4297 48 : if (IsTrueArrayType(typForm))
4298 0 : ereport(ERROR,
4299 : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
4300 : errmsg("%s is not a base type",
4301 : format_type_be(typeOid))));
4302 :
4303 : /* OK, recursively update this type and any arrays/domains over it */
4304 48 : AlterTypeRecurse(typeOid, false, tup, catalog, &atparams);
4305 :
4306 : /* Clean up */
4307 48 : ReleaseSysCache(tup);
4308 :
4309 48 : table_close(catalog, RowExclusiveLock);
4310 :
4311 48 : ObjectAddressSet(address, TypeRelationId, typeOid);
4312 :
4313 48 : return address;
4314 : }
4315 :
4316 : /*
4317 : * AlterTypeRecurse: one recursion step for AlterType()
4318 : *
4319 : * Apply the changes specified by "atparams" to the type identified by
4320 : * "typeOid", whose existing pg_type tuple is "tup". If necessary,
4321 : * recursively update its array type as well. Then search for any domains
4322 : * over this type, and recursively apply (most of) the same changes to those
4323 : * domains.
4324 : *
4325 : * We need this because the system generally assumes that a domain inherits
4326 : * many properties from its base type. See DefineDomain() above for details
4327 : * of what is inherited. Arrays inherit a smaller number of properties,
4328 : * but not none.
4329 : *
4330 : * There's a race condition here, in that some other transaction could
4331 : * concurrently add another domain atop this base type; we'd miss updating
4332 : * that one. Hence, be wary of allowing ALTER TYPE to change properties for
4333 : * which it'd be really fatal for a domain to be out of sync with its base
4334 : * type (typlen, for example). In practice, races seem unlikely to be an
4335 : * issue for plausible use-cases for ALTER TYPE. If one does happen, it could
4336 : * be fixed by re-doing the same ALTER TYPE once all prior transactions have
4337 : * committed.
4338 : */
4339 : static void
4340 66 : AlterTypeRecurse(Oid typeOid, bool isImplicitArray,
4341 : HeapTuple tup, Relation catalog,
4342 : AlterTypeRecurseParams *atparams)
4343 : {
4344 : Datum values[Natts_pg_type];
4345 : bool nulls[Natts_pg_type];
4346 : bool replaces[Natts_pg_type];
4347 : HeapTuple newtup;
4348 : SysScanDesc scan;
4349 : ScanKeyData key[1];
4350 : HeapTuple domainTup;
4351 :
4352 : /* Since this function recurses, it could be driven to stack overflow */
4353 66 : check_stack_depth();
4354 :
4355 : /* Update the current type's tuple */
4356 66 : memset(values, 0, sizeof(values));
4357 66 : memset(nulls, 0, sizeof(nulls));
4358 66 : memset(replaces, 0, sizeof(replaces));
4359 :
4360 66 : if (atparams->updateStorage)
4361 : {
4362 12 : replaces[Anum_pg_type_typstorage - 1] = true;
4363 12 : values[Anum_pg_type_typstorage - 1] = CharGetDatum(atparams->storage);
4364 : }
4365 66 : if (atparams->updateReceive)
4366 : {
4367 28 : replaces[Anum_pg_type_typreceive - 1] = true;
4368 28 : values[Anum_pg_type_typreceive - 1] = ObjectIdGetDatum(atparams->receiveOid);
4369 : }
4370 66 : if (atparams->updateSend)
4371 : {
4372 34 : replaces[Anum_pg_type_typsend - 1] = true;
4373 34 : values[Anum_pg_type_typsend - 1] = ObjectIdGetDatum(atparams->sendOid);
4374 : }
4375 66 : if (atparams->updateTypmodin)
4376 : {
4377 12 : replaces[Anum_pg_type_typmodin - 1] = true;
4378 12 : values[Anum_pg_type_typmodin - 1] = ObjectIdGetDatum(atparams->typmodinOid);
4379 : }
4380 66 : if (atparams->updateTypmodout)
4381 : {
4382 12 : replaces[Anum_pg_type_typmodout - 1] = true;
4383 12 : values[Anum_pg_type_typmodout - 1] = ObjectIdGetDatum(atparams->typmodoutOid);
4384 : }
4385 66 : if (atparams->updateAnalyze)
4386 : {
4387 12 : replaces[Anum_pg_type_typanalyze - 1] = true;
4388 12 : values[Anum_pg_type_typanalyze - 1] = ObjectIdGetDatum(atparams->analyzeOid);
4389 : }
4390 66 : if (atparams->updateSubscript)
4391 : {
4392 20 : replaces[Anum_pg_type_typsubscript - 1] = true;
4393 20 : values[Anum_pg_type_typsubscript - 1] = ObjectIdGetDatum(atparams->subscriptOid);
4394 : }
4395 :
4396 66 : newtup = heap_modify_tuple(tup, RelationGetDescr(catalog),
4397 : values, nulls, replaces);
4398 :
4399 66 : CatalogTupleUpdate(catalog, &newtup->t_self, newtup);
4400 :
4401 : /* Rebuild dependencies for this type */
4402 66 : GenerateTypeDependencies(newtup,
4403 : catalog,
4404 : NULL, /* don't have defaultExpr handy */
4405 : NULL, /* don't have typacl handy */
4406 : 0, /* we rejected composite types above */
4407 : isImplicitArray, /* it might be an array */
4408 : isImplicitArray, /* dependent iff it's array */
4409 : false, /* don't touch extension membership */
4410 : true);
4411 :
4412 66 : InvokeObjectPostAlterHook(TypeRelationId, typeOid, 0);
4413 :
4414 : /*
4415 : * Arrays inherit their base type's typmodin and typmodout, but none of
4416 : * the other properties we're concerned with here. Recurse to the array
4417 : * type if needed.
4418 : */
4419 66 : if (!isImplicitArray &&
4420 60 : (atparams->updateTypmodin || atparams->updateTypmodout))
4421 : {
4422 6 : Oid arrtypoid = ((Form_pg_type) GETSTRUCT(newtup))->typarray;
4423 :
4424 6 : if (OidIsValid(arrtypoid))
4425 : {
4426 : HeapTuple arrtup;
4427 : AlterTypeRecurseParams arrparams;
4428 :
4429 6 : arrtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(arrtypoid));
4430 6 : if (!HeapTupleIsValid(arrtup))
4431 0 : elog(ERROR, "cache lookup failed for type %u", arrtypoid);
4432 :
4433 6 : memset(&arrparams, 0, sizeof(arrparams));
4434 6 : arrparams.updateTypmodin = atparams->updateTypmodin;
4435 6 : arrparams.updateTypmodout = atparams->updateTypmodout;
4436 6 : arrparams.typmodinOid = atparams->typmodinOid;
4437 6 : arrparams.typmodoutOid = atparams->typmodoutOid;
4438 :
4439 6 : AlterTypeRecurse(arrtypoid, true, arrtup, catalog, &arrparams);
4440 :
4441 6 : ReleaseSysCache(arrtup);
4442 : }
4443 : }
4444 :
4445 : /*
4446 : * Now we need to recurse to domains. However, some properties are not
4447 : * inherited by domains, so clear the update flags for those.
4448 : */
4449 66 : atparams->updateReceive = false; /* domains use F_DOMAIN_RECV */
4450 66 : atparams->updateTypmodin = false; /* domains don't have typmods */
4451 66 : atparams->updateTypmodout = false;
4452 66 : atparams->updateSubscript = false; /* domains don't have subscriptors */
4453 :
4454 : /* Skip the scan if nothing remains to be done */
4455 66 : if (!(atparams->updateStorage ||
4456 54 : atparams->updateSend ||
4457 20 : atparams->updateAnalyze))
4458 20 : return;
4459 :
4460 : /* Search pg_type for possible domains over this type */
4461 46 : ScanKeyInit(&key[0],
4462 : Anum_pg_type_typbasetype,
4463 : BTEqualStrategyNumber, F_OIDEQ,
4464 : ObjectIdGetDatum(typeOid));
4465 :
4466 46 : scan = systable_beginscan(catalog, InvalidOid, false,
4467 : NULL, 1, key);
4468 :
4469 58 : while ((domainTup = systable_getnext(scan)) != NULL)
4470 : {
4471 12 : Form_pg_type domainForm = (Form_pg_type) GETSTRUCT(domainTup);
4472 :
4473 : /*
4474 : * Shouldn't have a nonzero typbasetype in a non-domain, but let's
4475 : * check
4476 : */
4477 12 : if (domainForm->typtype != TYPTYPE_DOMAIN)
4478 0 : continue;
4479 :
4480 12 : AlterTypeRecurse(domainForm->oid, false, domainTup, catalog, atparams);
4481 : }
4482 :
4483 46 : systable_endscan(scan);
4484 : }
|
