src/backend/commands/conversioncmds.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * conversioncmds.c
   4  *        conversion creation command support code
   5  *
   6  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL$
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include "access/heapam.h"
  18 #include "catalog/dependency.h"
  19 #include "catalog/indexing.h"
  20 #include "catalog/pg_conversion.h"
  21 #include "catalog/pg_conversion_fn.h"
  22 #include "catalog/pg_type.h"
  23 #include "commands/conversioncmds.h"
  24 #include "mb/pg_wchar.h"
  25 #include "miscadmin.h"
  26 #include "parser/parse_func.h"
  27 #include "utils/acl.h"
  28 #include "utils/builtins.h"
  29 #include "utils/lsyscache.h"
  30 #include "utils/rel.h"
  31 #include "utils/syscache.h"
  32
  33 static void AlterConversionOwner_internal(Relation rel, Oid conversionOid,
  34                                                           Oid newOwnerId);
  35
  36 /*
  37  * CREATE CONVERSION
  38  */
  39 void
  40 CreateConversionCommand(CreateConversionStmt *stmt)
  41 {
  42         Oid                     namespaceId;
  43         char       *conversion_name;
  44         AclResult       aclresult;
  45         int                     from_encoding;
  46         int                     to_encoding;
  47         Oid                     funcoid;
  48         const char *from_encoding_name = stmt->for_encoding_name;
  49         const char *to_encoding_name = stmt->to_encoding_name;
  50         List       *func_name = stmt->func_name;
  51         static Oid      funcargs[] = {INT4OID, INT4OID, CSTRINGOID, INTERNALOID, INT4OID};
  52
  53         /* Convert list of names to a name and namespace */
  54         namespaceId = QualifiedNameGetCreationNamespace(stmt->conversion_name,
  55                                                                                                         &conversion_name);
  56
  57         /* Check we have creation rights in target namespace */
  58         aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_CREATE);
  59         if (aclresult != ACLCHECK_OK)
  60                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
  61                                            get_namespace_name(namespaceId));
  62
  63         /* Check the encoding names */
  64         from_encoding = pg_char_to_encoding(from_encoding_name);
  65         if (from_encoding < 0)
  66                 ereport(ERROR,
  67                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
  68                                  errmsg("source encoding \"%s\" does not exist",
  69                                                 from_encoding_name)));
  70
  71         to_encoding = pg_char_to_encoding(to_encoding_name);
  72         if (to_encoding < 0)
  73                 ereport(ERROR,
  74                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
  75                                  errmsg("destination encoding \"%s\" does not exist",
  76                                                 to_encoding_name)));
  77
  78         /*
  79          * Check the existence of the conversion function. Function name could be
  80          * a qualified name.
  81          */
  82         funcoid = LookupFuncName(func_name, sizeof(funcargs) / sizeof(Oid),
  83                                                          funcargs, false);
  84
  85         /* Check we have EXECUTE rights for the function */
  86         aclresult = pg_proc_aclcheck(funcoid, GetUserId(), ACL_EXECUTE);
  87         if (aclresult != ACLCHECK_OK)
  88                 aclcheck_error(aclresult, ACL_KIND_PROC,
  89                                            NameListToString(func_name));
  90
  91         /*
  92          * All seem ok, go ahead (possible failure would be a duplicate conversion
  93          * name)
  94          */
  95         ConversionCreate(conversion_name, namespaceId, GetUserId(),
  96                                          from_encoding, to_encoding, funcoid, stmt->def);
  97 }
  98
  99 /*
 100  * DROP CONVERSION
 101  */
 102 void
 103 DropConversionsCommand(DropStmt *drop)
 104 {
 105         ObjectAddresses *objects;
 106         ListCell *cell;
 107
 108         /*
 109          * First we identify all the conversions, then we delete them in a single
 110          * performMultipleDeletions() call.  This is to avoid unwanted
 111          * DROP RESTRICT errors if one of the conversions depends on another.
 112          * (Not that that is very likely, but we may as well do this consistently.)
 113          */
 114         objects = new_object_addresses();
 115
 116         foreach(cell, drop->objects)
 117         {
 118                 List            *name = (List *) lfirst(cell);
 119                 Oid                     conversionOid;
 120                 HeapTuple       tuple;
 121                 Form_pg_conversion con;
 122                 ObjectAddress object;
 123
 124                 conversionOid = FindConversionByName(name);
 125
 126                 if (!OidIsValid(conversionOid))
 127                 {
 128                         if (!drop->missing_ok)
 129                         {
 130                                 ereport(ERROR,
 131                                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 132                                                  errmsg("conversion \"%s\" does not exist",
 133                                                                 NameListToString(name))));
 134                         }
 135                         else
 136                         {
 137                                 ereport(NOTICE,
 138                                                 (errmsg("conversion \"%s\" does not exist, skipping",
 139                                                                 NameListToString(name))));
 140                         }
 141                         continue;
 142                 }
 143
 144                 tuple = SearchSysCache(CONVOID,
 145                                                            ObjectIdGetDatum(conversionOid),
 146                                                            0, 0, 0);
 147                 if (!HeapTupleIsValid(tuple))
 148                         elog(ERROR, "cache lookup failed for conversion %u",
 149                                  conversionOid);
 150                 con = (Form_pg_conversion) GETSTRUCT(tuple);
 151
 152                 /* Permission check: must own conversion or its namespace */
 153                 if (!pg_conversion_ownercheck(conversionOid, GetUserId()) &&
 154                         !pg_namespace_ownercheck(con->connamespace, GetUserId()))
 155                         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
 156                                                    NameStr(con->conname));
 157
 158                 object.classId = ConversionRelationId;
 159                 object.objectId = conversionOid;
 160                 object.objectSubId = 0;
 161
 162                 add_exact_object_address(&object, objects);
 163
 164                 ReleaseSysCache(tuple);
 165         }
 166
 167         performMultipleDeletions(objects, drop->behavior);
 168
 169         free_object_addresses(objects);
 170 }
 171
 172 /*
 173  * Rename conversion
 174  */
 175 void
 176 RenameConversion(List *name, const char *newname)
 177 {
 178         Oid                     conversionOid;
 179         Oid                     namespaceOid;
 180         HeapTuple       tup;
 181         Relation        rel;
 182         AclResult       aclresult;
 183
 184         rel = heap_open(ConversionRelationId, RowExclusiveLock);
 185
 186         conversionOid = FindConversionByName(name);
 187         if (!OidIsValid(conversionOid))
 188                 ereport(ERROR,
 189                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 190                                  errmsg("conversion \"%s\" does not exist",
 191                                                 NameListToString(name))));
 192
 193         tup = SearchSysCacheCopy(CONVOID,
 194                                                          ObjectIdGetDatum(conversionOid),
 195                                                          0, 0, 0);
 196         if (!HeapTupleIsValid(tup)) /* should not happen */
 197                 elog(ERROR, "cache lookup failed for conversion %u", conversionOid);
 198
 199         namespaceOid = ((Form_pg_conversion) GETSTRUCT(tup))->connamespace;
 200
 201         /* make sure the new name doesn't exist */
 202         if (SearchSysCacheExists(CONNAMENSP,
 203                                                          CStringGetDatum(newname),
 204                                                          ObjectIdGetDatum(namespaceOid),
 205                                                          0, 0))
 206                 ereport(ERROR,
 207                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
 208                                  errmsg("conversion \"%s\" already exists in schema \"%s\"",
 209                                                 newname, get_namespace_name(namespaceOid))));
 210
 211         /* must be owner */
 212         if (!pg_conversion_ownercheck(conversionOid, GetUserId()))
 213                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
 214                                            NameListToString(name));
 215
 216         /* must have CREATE privilege on namespace */
 217         aclresult = pg_namespace_aclcheck(namespaceOid, GetUserId(), ACL_CREATE);
 218         if (aclresult != ACLCHECK_OK)
 219                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 220                                            get_namespace_name(namespaceOid));
 221
 222         /* rename */
 223         namestrcpy(&(((Form_pg_conversion) GETSTRUCT(tup))->conname), newname);
 224         simple_heap_update(rel, &tup->t_self, tup);
 225         CatalogUpdateIndexes(rel, tup);
 226
 227         heap_close(rel, NoLock);
 228         heap_freetuple(tup);
 229 }
 230
 231 /*
 232  * Change conversion owner, by name
 233  */
 234 void
 235 AlterConversionOwner(List *name, Oid newOwnerId)
 236 {
 237         Oid                     conversionOid;
 238         Relation        rel;
 239
 240         rel = heap_open(ConversionRelationId, RowExclusiveLock);
 241
 242         conversionOid = FindConversionByName(name);
 243         if (!OidIsValid(conversionOid))
 244                 ereport(ERROR,
 245                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 246                                  errmsg("conversion \"%s\" does not exist",
 247                                                 NameListToString(name))));
 248
 249         AlterConversionOwner_internal(rel, conversionOid, newOwnerId);
 250
 251         heap_close(rel, NoLock);
 252 }
 253
 254 /*
 255  * Change conversion owner, by oid
 256  */
 257 void
 258 AlterConversionOwner_oid(Oid conversionOid, Oid newOwnerId)
 259 {
 260         Relation        rel;
 261
 262         rel = heap_open(ConversionRelationId, RowExclusiveLock);
 263
 264         AlterConversionOwner_internal(rel, conversionOid, newOwnerId);
 265
 266         heap_close(rel, NoLock);
 267 }
 268
 269 /*
 270  * AlterConversionOwner_internal
 271  *
 272  * Internal routine for changing the owner.  rel must be pg_conversion, already
 273  * open and suitably locked; it will not be closed.
 274  */
 275 static void
 276 AlterConversionOwner_internal(Relation rel, Oid conversionOid, Oid newOwnerId)
 277 {
 278         Form_pg_conversion convForm;
 279         HeapTuple       tup;
 280
 281         Assert(RelationGetRelid(rel) == ConversionRelationId);
 282
 283         tup = SearchSysCacheCopy(CONVOID,
 284                                                          ObjectIdGetDatum(conversionOid),
 285                                                          0, 0, 0);
 286         if (!HeapTupleIsValid(tup)) /* should not happen */
 287                 elog(ERROR, "cache lookup failed for conversion %u", conversionOid);
 288
 289         convForm = (Form_pg_conversion) GETSTRUCT(tup);
 290
 291         /*
 292          * If the new owner is the same as the existing owner, consider the
 293          * command to have succeeded.  This is for dump restoration purposes.
 294          */
 295         if (convForm->conowner != newOwnerId)
 296         {
 297                 AclResult       aclresult;
 298
 299                 /* Superusers can always do it */
 300                 if (!superuser())
 301                 {
 302                         /* Otherwise, must be owner of the existing object */
 303                         if (!pg_conversion_ownercheck(HeapTupleGetOid(tup), GetUserId()))
 304                                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
 305                                                            NameStr(convForm->conname));
 306
 307                         /* Must be able to become new owner */
 308                         check_is_member_of_role(GetUserId(), newOwnerId);
 309
 310                         /* New owner must have CREATE privilege on namespace */
 311                         aclresult = pg_namespace_aclcheck(convForm->connamespace,
 312                                                                                           newOwnerId,
 313                                                                                           ACL_CREATE);
 314                         if (aclresult != ACLCHECK_OK)
 315                                 aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 316                                                            get_namespace_name(convForm->connamespace));
 317                 }
 318
 319                 /*
 320                  * Modify the owner --- okay to scribble on tup because it's a copy
 321                  */
 322                 convForm->conowner = newOwnerId;
 323
 324                 simple_heap_update(rel, &tup->t_self, tup);
 325
 326                 CatalogUpdateIndexes(rel, tup);
 327
 328                 /* Update owner dependency reference */
 329                 changeDependencyOnOwner(ConversionRelationId, conversionOid,
 330                                                                 newOwnerId);
 331         }
 332
 333         heap_freetuple(tup);
 334 }