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