LCOV - differential code coverage report
Current view: top level - src/backend/commands - typecmds.c (source / functions) Coverage Total Hit UNC LBC UBC GBC GIC GNC CBC DUB DCB
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 83.2 % 1366 1136 4 226 3 80 1053 1 28
Current Date: 2024-04-14 14:21:10 Functions: 97.8 % 45 44 1 13 31 2
Baseline: 16@8cea358b128 Branches: 53.1 % 1074 570 18 2 484 3 1 38 528
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed [..60] days: 96.4 % 83 80 3 80
(240..) days: 82.3 % 1283 1056 1 226 3 1053
Function coverage date bins:
[..60] days: 100.0 % 4 4 4
(240..) days: 97.6 % 41 40 1 9 31
Branch coverage date bins:
[..60] days: 70.4 % 54 38 16 38
(240..) days: 52.2 % 1020 532 2 2 484 3 1 528

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

Generated by: LCOV version 2.1-beta2-3-g6141622