src/backend/commands/foreigncmds.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * foreigncmds.c
   4  *        foreign-data wrapper/server creation/manipulation commands
   5  *
   6  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   7  *
   8  *
   9  * IDENTIFICATION
  10  *        $PostgreSQL$
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #include "postgres.h"
  15
  16 #include "access/heapam.h"
  17 #include "access/reloptions.h"
  18 #include "catalog/catalog.h"
  19 #include "catalog/dependency.h"
  20 #include "catalog/indexing.h"
  21 #include "catalog/pg_foreign_data_wrapper.h"
  22 #include "catalog/pg_foreign_server.h"
  23 #include "catalog/pg_proc.h"
  24 #include "catalog/pg_type.h"
  25 #include "catalog/pg_user_mapping.h"
  26 #include "commands/defrem.h"
  27 #include "foreign/foreign.h"
  28 #include "miscadmin.h"
  29 #include "parser/parse_func.h"
  30 #include "utils/acl.h"
  31 #include "utils/builtins.h"
  32 #include "utils/lsyscache.h"
  33 #include "utils/rel.h"
  34 #include "utils/syscache.h"
  35
  36
  37 /*
  38  * Convert a DefElem list to the text array format that is used in
  39  * pg_foreign_data_wrapper, pg_foreign_server, and pg_user_mapping.
  40  * Returns the array in the form of a Datum, or PointerGetDatum(NULL)
  41  * if the list is empty.
  42  *
  43  * Note: The array is usually stored to database without further
  44  * processing, hence any validation should be done before this
  45  * conversion.
  46  */
  47 static Datum
  48 optionListToArray(List *options)
  49 {
  50         ArrayBuildState *astate = NULL;
  51         ListCell   *cell;
  52
  53         foreach(cell, options)
  54         {
  55                 DefElem    *def = lfirst(cell);
  56                 const char *value;
  57                 Size            len;
  58                 text       *t;
  59
  60                 value = defGetString(def);
  61                 len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
  62                 t = palloc(len + 1);
  63                 SET_VARSIZE(t, len);
  64                 sprintf(VARDATA(t), "%s=%s", def->defname, value);
  65
  66                 astate = accumArrayResult(astate, PointerGetDatum(t),
  67                                                                   false, TEXTOID,
  68                                                                   CurrentMemoryContext);
  69         }
  70
  71         if (astate)
  72                 return makeArrayResult(astate, CurrentMemoryContext);
  73
  74         return PointerGetDatum(NULL);
  75 }
  76
  77
  78 /*
  79  * Transform a list of DefElem into text array format.  This is substantially
  80  * the same thing as optionListToArray(), except we recognize SET/ADD/DROP
  81  * actions for modifying an existing list of options, which is passed in
  82  * Datum form as oldOptions.  Also, if fdwvalidator isn't InvalidOid
  83  * it specifies a validator function to call on the result.
  84  *
  85  * Returns the array in the form of a Datum, or PointerGetDatum(NULL)
  86  * if the list is empty.
  87  *
  88  * This is used by CREATE/ALTER of FOREIGN DATA WRAPPER/SERVER/USER MAPPING.
  89  */
  90 static Datum
  91 transformGenericOptions(Datum oldOptions,
  92                                                 List *options,
  93                                                 Oid fdwvalidator)
  94 {
  95         List       *resultOptions = untransformRelOptions(oldOptions);
  96         ListCell   *optcell;
  97         Datum           result;
  98
  99         foreach(optcell, options)
 100         {
 101                 DefElem    *od = lfirst(optcell);
 102                 ListCell   *cell;
 103                 ListCell   *prev = NULL;
 104
 105                 /*
 106                  * Find the element in resultOptions.  We need this for validation in
 107                  * all cases.  Also identify the previous element.
 108                  */
 109                 foreach(cell, resultOptions)
 110                 {
 111                         DefElem    *def = lfirst(cell);
 112
 113                         if (strcmp(def->defname, od->defname) == 0)
 114                                 break;
 115                         else
 116                                 prev = cell;
 117                 }
 118
 119                 /*
 120                  * It is possible to perform multiple SET/DROP actions on the same
 121                  * option.      The standard permits this, as long as the options to be
 122                  * added are unique.  Note that an unspecified action is taken to be
 123                  * ADD.
 124                  */
 125                 switch (od->defaction)
 126                 {
 127                         case DEFELEM_DROP:
 128                                 if (!cell)
 129                                         ereport(ERROR,
 130                                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
 131                                                          errmsg("option \"%s\" not found",
 132                                                                         od->defname)));
 133                                 resultOptions = list_delete_cell(resultOptions, cell, prev);
 134                                 break;
 135
 136                         case DEFELEM_SET:
 137                                 if (!cell)
 138                                         ereport(ERROR,
 139                                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
 140                                                          errmsg("option \"%s\" not found",
 141                                                                         od->defname)));
 142                                 lfirst(cell) = od;
 143                                 break;
 144
 145                         case DEFELEM_ADD:
 146                         case DEFELEM_UNSPEC:
 147                                 if (cell)
 148                                         ereport(ERROR,
 149                                                         (errcode(ERRCODE_DUPLICATE_OBJECT),
 150                                                          errmsg("option \"%s\" provided more than once",
 151                                                                         od->defname)));
 152                                 resultOptions = lappend(resultOptions, od);
 153                                 break;
 154
 155                         default:
 156                                 elog(ERROR, "unrecognized action %d on option \"%s\"",
 157                                          (int) od->defaction, od->defname);
 158                                 break;
 159                 }
 160         }
 161
 162         result = optionListToArray(resultOptions);
 163
 164         if (fdwvalidator)
 165                 OidFunctionCall2(fdwvalidator, result, (Datum) 0);
 166
 167         return result;
 168 }
 169
 170
 171 /*
 172  * Convert the user mapping user name to OID
 173  */
 174 static Oid
 175 GetUserOidFromMapping(const char *username, bool missing_ok)
 176 {
 177         if (!username)
 178                 /* PUBLIC user mapping */
 179                 return InvalidOid;
 180
 181         if (strcmp(username, "current_user") == 0)
 182                 /* map to the owner */
 183                 return GetUserId();
 184
 185         /* map to provided user */
 186         return missing_ok ? get_roleid(username) : get_roleid_checked(username);
 187 }
 188
 189
 190 /*
 191  * Change foreign-data wrapper owner.
 192  *
 193  * Allow this only for superusers; also the new owner must be a
 194  * superuser.
 195  */
 196 void
 197 AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId)
 198 {
 199         HeapTuple       tup;
 200         Relation        rel;
 201         Oid                     fdwId;
 202         Form_pg_foreign_data_wrapper form;
 203
 204         /* Must be a superuser to change a FDW owner */
 205         if (!superuser())
 206                 ereport(ERROR,
 207                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 208                                  errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",
 209                                                 name),
 210                                  errhint("Must be superuser to change owner of a foreign-data wrapper.")));
 211
 212         /* New owner must also be a superuser */
 213         if (!superuser_arg(newOwnerId))
 214                 ereport(ERROR,
 215                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 216                                  errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",
 217                                                 name),
 218                 errhint("The owner of a foreign-data wrapper must be a superuser.")));
 219
 220         rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 221
 222         tup = SearchSysCacheCopy(FOREIGNDATAWRAPPERNAME,
 223                                                          CStringGetDatum(name),
 224                                                          0, 0, 0);
 225
 226         if (!HeapTupleIsValid(tup))
 227                 ereport(ERROR,
 228                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 229                                  errmsg("foreign-data wrapper \"%s\" does not exist", name)));
 230
 231         fdwId = HeapTupleGetOid(tup);
 232         form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);
 233
 234         if (form->fdwowner != newOwnerId)
 235         {
 236                 form->fdwowner = newOwnerId;
 237
 238                 simple_heap_update(rel, &tup->t_self, tup);
 239                 CatalogUpdateIndexes(rel, tup);
 240
 241                 /* Update owner dependency reference */
 242                 changeDependencyOnOwner(ForeignDataWrapperRelationId,
 243                                                                 fdwId,
 244                                                                 newOwnerId);
 245         }
 246
 247         heap_close(rel, NoLock);
 248         heap_freetuple(tup);
 249 }
 250
 251
 252 /*
 253  * Change foreign server owner
 254  */
 255 void
 256 AlterForeignServerOwner(const char *name, Oid newOwnerId)
 257 {
 258         HeapTuple       tup;
 259         Relation        rel;
 260         Oid                     srvId;
 261         AclResult       aclresult;
 262         Form_pg_foreign_server form;
 263
 264         rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 265
 266         tup = SearchSysCacheCopy(FOREIGNSERVERNAME,
 267                                                          CStringGetDatum(name),
 268                                                          0, 0, 0);
 269
 270         if (!HeapTupleIsValid(tup))
 271                 ereport(ERROR,
 272                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 273                                  errmsg("server \"%s\" does not exist", name)));
 274
 275         srvId = HeapTupleGetOid(tup);
 276         form = (Form_pg_foreign_server) GETSTRUCT(tup);
 277
 278         if (form->srvowner != newOwnerId)
 279         {
 280                 /* Superusers can always do it */
 281                 if (!superuser())
 282                 {
 283                         /* Must be owner */
 284                         if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
 285                                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
 286                                                            name);
 287
 288                         /* Must be able to become new owner */
 289                         check_is_member_of_role(GetUserId(), newOwnerId);
 290
 291                         /* New owner must have USAGE privilege on foreign-data wrapper */
 292                         aclresult = pg_foreign_data_wrapper_aclcheck(form->srvfdw, newOwnerId, ACL_USAGE);
 293                         if (aclresult != ACLCHECK_OK)
 294                         {
 295                                 ForeignDataWrapper *fdw = GetForeignDataWrapper(form->srvfdw);
 296
 297                                 aclcheck_error(aclresult, ACL_KIND_FDW, fdw->fdwname);
 298                         }
 299                 }
 300
 301                 form->srvowner = newOwnerId;
 302
 303                 simple_heap_update(rel, &tup->t_self, tup);
 304                 CatalogUpdateIndexes(rel, tup);
 305
 306                 /* Update owner dependency reference */
 307                 changeDependencyOnOwner(ForeignServerRelationId, HeapTupleGetOid(tup),
 308                                                                 newOwnerId);
 309         }
 310
 311         heap_close(rel, NoLock);
 312         heap_freetuple(tup);
 313 }
 314
 315
 316 /*
 317  * Convert a validator function name passed from the parser to an Oid.
 318  */
 319 static Oid
 320 lookup_fdw_validator_func(List *validator)
 321 {
 322         Oid                     funcargtypes[2];
 323
 324         funcargtypes[0] = TEXTARRAYOID;
 325         funcargtypes[1] = OIDOID;
 326         return LookupFuncName(validator, 2, funcargtypes, false);
 327         /* return value is ignored, so we don't check the type */
 328 }
 329
 330
 331 /*
 332  * Create a foreign-data wrapper
 333  */
 334 void
 335 CreateForeignDataWrapper(CreateFdwStmt *stmt)
 336 {
 337         Relation        rel;
 338         Datum           values[Natts_pg_foreign_data_wrapper];
 339         bool            nulls[Natts_pg_foreign_data_wrapper];
 340         HeapTuple       tuple;
 341         Oid                     fdwId;
 342         Oid                     fdwvalidator;
 343         Datum           fdwoptions;
 344         Oid                     ownerId;
 345
 346         /* Must be super user */
 347         if (!superuser())
 348                 ereport(ERROR,
 349                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 350                         errmsg("permission denied to create foreign-data wrapper \"%s\"",
 351                                    stmt->fdwname),
 352                         errhint("Must be superuser to create a foreign-data wrapper.")));
 353
 354         /* For now the owner cannot be specified on create. Use effective user ID. */
 355         ownerId = GetUserId();
 356
 357         /*
 358          * Check that there is no other foreign-data wrapper by this name.
 359          */
 360         if (GetForeignDataWrapperByName(stmt->fdwname, true) != NULL)
 361                 ereport(ERROR,
 362                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
 363                                  errmsg("foreign-data wrapper \"%s\" already exists",
 364                                                 stmt->fdwname)));
 365
 366         /*
 367          * Insert tuple into pg_foreign_data_wrapper.
 368          */
 369         rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 370
 371         memset(values, 0, sizeof(values));
 372         memset(nulls, false, sizeof(nulls));
 373
 374         values[Anum_pg_foreign_data_wrapper_fdwname - 1] =
 375                 DirectFunctionCall1(namein, CStringGetDatum(stmt->fdwname));
 376         values[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(ownerId);
 377
 378         if (stmt->validator)
 379                 fdwvalidator = lookup_fdw_validator_func(stmt->validator);
 380         else
 381                 fdwvalidator = InvalidOid;
 382
 383         values[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = fdwvalidator;
 384
 385         nulls[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;
 386
 387         fdwoptions = transformGenericOptions(PointerGetDatum(NULL), stmt->options,
 388                                                                                  fdwvalidator);
 389
 390         if (PointerIsValid(DatumGetPointer(fdwoptions)))
 391                 values[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = fdwoptions;
 392         else
 393                 nulls[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
 394
 395         tuple = heap_form_tuple(rel->rd_att, values, nulls);
 396
 397         fdwId = simple_heap_insert(rel, tuple);
 398         CatalogUpdateIndexes(rel, tuple);
 399
 400         heap_freetuple(tuple);
 401
 402         if (fdwvalidator)
 403         {
 404                 ObjectAddress myself;
 405                 ObjectAddress referenced;
 406
 407                 myself.classId = ForeignDataWrapperRelationId;
 408                 myself.objectId = fdwId;
 409                 myself.objectSubId = 0;
 410
 411                 referenced.classId = ProcedureRelationId;
 412                 referenced.objectId = fdwvalidator;
 413                 referenced.objectSubId = 0;
 414                 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 415         }
 416
 417         recordDependencyOnOwner(ForeignDataWrapperRelationId, fdwId, ownerId);
 418
 419         heap_close(rel, NoLock);
 420 }
 421
 422
 423 /*
 424  * Alter foreign-data wrapper
 425  */
 426 void
 427 AlterForeignDataWrapper(AlterFdwStmt *stmt)
 428 {
 429         Relation        rel;
 430         HeapTuple       tp;
 431         Datum           repl_val[Natts_pg_foreign_data_wrapper];
 432         bool            repl_null[Natts_pg_foreign_data_wrapper];
 433         bool            repl_repl[Natts_pg_foreign_data_wrapper];
 434         Oid                     fdwId;
 435         bool            isnull;
 436         Datum           datum;
 437         Oid                     fdwvalidator;
 438
 439         /* Must be super user */
 440         if (!superuser())
 441                 ereport(ERROR,
 442                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 443                          errmsg("permission denied to alter foreign-data wrapper \"%s\"",
 444                                         stmt->fdwname),
 445                          errhint("Must be superuser to alter a foreign-data wrapper.")));
 446
 447         tp = SearchSysCacheCopy(FOREIGNDATAWRAPPERNAME,
 448                                                         CStringGetDatum(stmt->fdwname),
 449                                                         0, 0, 0);
 450
 451         if (!HeapTupleIsValid(tp))
 452                 ereport(ERROR,
 453                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 454                 errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));
 455
 456         fdwId = HeapTupleGetOid(tp);
 457
 458         memset(repl_val, 0, sizeof(repl_val));
 459         memset(repl_null, false, sizeof(repl_null));
 460         memset(repl_repl, false, sizeof(repl_repl));
 461
 462         if (stmt->change_validator)
 463         {
 464                 fdwvalidator = stmt->validator ? lookup_fdw_validator_func(stmt->validator) : InvalidOid;
 465                 repl_val[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);
 466                 repl_repl[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = true;
 467
 468                 /*
 469                  * It could be that the options for the FDW, SERVER and USER MAPPING
 470                  * are no longer valid with the new validator.  Warn about this.
 471                  */
 472                 if (stmt->validator)
 473                         ereport(WARNING,
 474                          (errmsg("changing the foreign-data wrapper validator can cause "
 475                                          "the options for dependent objects to become invalid")));
 476         }
 477         else
 478         {
 479                 /*
 480                  * Validator is not changed, but we need it for validating options.
 481                  */
 482                 datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
 483                                                                 tp,
 484                                                                 Anum_pg_foreign_data_wrapper_fdwvalidator,
 485                                                                 &isnull);
 486                 Assert(!isnull);
 487                 fdwvalidator = DatumGetObjectId(datum);
 488         }
 489
 490         /*
 491          * Options specified, validate and update.
 492          */
 493         if (stmt->options)
 494         {
 495                 /* Extract the current options */
 496                 datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
 497                                                                 tp,
 498                                                                 Anum_pg_foreign_data_wrapper_fdwoptions,
 499                                                                 &isnull);
 500                 if (isnull)
 501                         datum = PointerGetDatum(NULL);
 502
 503                 /* Transform the options */
 504                 datum = transformGenericOptions(datum, stmt->options, fdwvalidator);
 505
 506                 if (PointerIsValid(DatumGetPointer(datum)))
 507                         repl_val[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = datum;
 508                 else
 509                         repl_null[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
 510
 511                 repl_repl[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
 512         }
 513
 514         /* Everything looks good - update the tuple */
 515
 516         rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 517
 518         tp = heap_modify_tuple(tp, RelationGetDescr(rel),
 519                                                    repl_val, repl_null, repl_repl);
 520
 521         simple_heap_update(rel, &tp->t_self, tp);
 522         CatalogUpdateIndexes(rel, tp);
 523
 524         heap_close(rel, RowExclusiveLock);
 525         heap_freetuple(tp);
 526 }
 527
 528
 529 /*
 530  * Drop foreign-data wrapper
 531  */
 532 void
 533 RemoveForeignDataWrapper(DropFdwStmt *stmt)
 534 {
 535         Oid                     fdwId;
 536         ObjectAddress object;
 537
 538         fdwId = GetForeignDataWrapperOidByName(stmt->fdwname, true);
 539
 540         if (!superuser())
 541                 ereport(ERROR,
 542                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 543                           errmsg("permission denied to drop foreign-data wrapper \"%s\"",
 544                                          stmt->fdwname),
 545                           errhint("Must be superuser to drop a foreign-data wrapper.")));
 546
 547         if (!OidIsValid(fdwId))
 548         {
 549                 if (!stmt->missing_ok)
 550                         ereport(ERROR,
 551                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
 552                                          errmsg("foreign-data wrapper \"%s\" does not exist",
 553                                                         stmt->fdwname)));
 554
 555                 /* IF EXISTS specified, just note it */
 556                 ereport(NOTICE,
 557                           (errmsg("foreign-data wrapper \"%s\" does not exist, skipping",
 558                                           stmt->fdwname)));
 559                 return;
 560         }
 561
 562         /*
 563          * Do the deletion
 564          */
 565         object.classId = ForeignDataWrapperRelationId;
 566         object.objectId = fdwId;
 567         object.objectSubId = 0;
 568
 569         performDeletion(&object, stmt->behavior);
 570 }
 571
 572
 573 /*
 574  * Drop foreign-data wrapper by OID
 575  */
 576 void
 577 RemoveForeignDataWrapperById(Oid fdwId)
 578 {
 579         HeapTuple       tp;
 580         Relation        rel;
 581
 582         rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 583
 584         tp = SearchSysCache(FOREIGNDATAWRAPPEROID,
 585                                                 ObjectIdGetDatum(fdwId),
 586                                                 0, 0, 0);
 587
 588         if (!HeapTupleIsValid(tp))
 589                 elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwId);
 590
 591         simple_heap_delete(rel, &tp->t_self);
 592
 593         ReleaseSysCache(tp);
 594
 595         heap_close(rel, RowExclusiveLock);
 596 }
 597
 598
 599 /*
 600  * Create a foreign server
 601  */
 602 void
 603 CreateForeignServer(CreateForeignServerStmt *stmt)
 604 {
 605         Relation        rel;
 606         Datum           srvoptions;
 607         Datum           values[Natts_pg_foreign_server];
 608         bool            nulls[Natts_pg_foreign_server];
 609         HeapTuple       tuple;
 610         Oid                     srvId;
 611         Oid                     ownerId;
 612         AclResult       aclresult;
 613         ObjectAddress myself;
 614         ObjectAddress referenced;
 615         ForeignDataWrapper *fdw;
 616
 617         /* For now the owner cannot be specified on create. Use effective user ID. */
 618         ownerId = GetUserId();
 619
 620         /*
 621          * Check that there is no other foreign server by this name.
 622          */
 623         if (GetForeignServerByName(stmt->servername, true) != NULL)
 624                 ereport(ERROR,
 625                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
 626                                  errmsg("server \"%s\" already exists",
 627                                                 stmt->servername)));
 628
 629         /*
 630          * Check that the FDW exists and that we have USAGE on it. Also get the
 631          * actual FDW for option validation etc.
 632          */
 633         fdw = GetForeignDataWrapperByName(stmt->fdwname, false);
 634
 635         aclresult = pg_foreign_data_wrapper_aclcheck(fdw->fdwid, ownerId, ACL_USAGE);
 636         if (aclresult != ACLCHECK_OK)
 637                 aclcheck_error(aclresult, ACL_KIND_FDW, fdw->fdwname);
 638
 639         /*
 640          * Insert tuple into pg_foreign_server.
 641          */
 642         rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 643
 644         memset(values, 0, sizeof(values));
 645         memset(nulls, false, sizeof(nulls));
 646
 647         values[Anum_pg_foreign_server_srvname - 1] =
 648                 DirectFunctionCall1(namein, CStringGetDatum(stmt->servername));
 649         values[Anum_pg_foreign_server_srvowner - 1] = ObjectIdGetDatum(ownerId);
 650         values[Anum_pg_foreign_server_srvfdw - 1] = ObjectIdGetDatum(fdw->fdwid);
 651
 652         /* Add server type if supplied */
 653         if (stmt->servertype)
 654                 values[Anum_pg_foreign_server_srvtype - 1] =
 655                         CStringGetTextDatum(stmt->servertype);
 656         else
 657                 nulls[Anum_pg_foreign_server_srvtype - 1] = true;
 658
 659         /* Add server version if supplied */
 660         if (stmt->version)
 661                 values[Anum_pg_foreign_server_srvversion - 1] =
 662                         CStringGetTextDatum(stmt->version);
 663         else
 664                 nulls[Anum_pg_foreign_server_srvversion - 1] = true;
 665
 666         /* Start with a blank acl */
 667         nulls[Anum_pg_foreign_server_srvacl - 1] = true;
 668
 669         /* Add server options */
 670         srvoptions = transformGenericOptions(PointerGetDatum(NULL), stmt->options,
 671                                                                                  fdw->fdwvalidator);
 672
 673         if (PointerIsValid(DatumGetPointer(srvoptions)))
 674                 values[Anum_pg_foreign_server_srvoptions - 1] = srvoptions;
 675         else
 676                 nulls[Anum_pg_foreign_server_srvoptions - 1] = true;
 677
 678         tuple = heap_form_tuple(rel->rd_att, values, nulls);
 679
 680         srvId = simple_heap_insert(rel, tuple);
 681
 682         CatalogUpdateIndexes(rel, tuple);
 683
 684         heap_freetuple(tuple);
 685
 686         /* Add dependency on FDW and owner */
 687         myself.classId = ForeignServerRelationId;
 688         myself.objectId = srvId;
 689         myself.objectSubId = 0;
 690
 691         referenced.classId = ForeignDataWrapperRelationId;
 692         referenced.objectId = fdw->fdwid;
 693         referenced.objectSubId = 0;
 694         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 695
 696         recordDependencyOnOwner(ForeignServerRelationId, srvId, ownerId);
 697
 698         heap_close(rel, NoLock);
 699 }
 700
 701
 702 /*
 703  * Alter foreign server
 704  */
 705 void
 706 AlterForeignServer(AlterForeignServerStmt *stmt)
 707 {
 708         Relation        rel;
 709         HeapTuple       tp;
 710         Datum           repl_val[Natts_pg_foreign_server];
 711         bool            repl_null[Natts_pg_foreign_server];
 712         bool            repl_repl[Natts_pg_foreign_server];
 713         Oid                     srvId;
 714         Form_pg_foreign_server srvForm;
 715
 716         tp = SearchSysCacheCopy(FOREIGNSERVERNAME,
 717                                                         CStringGetDatum(stmt->servername),
 718                                                         0, 0, 0);
 719
 720         if (!HeapTupleIsValid(tp))
 721                 ereport(ERROR,
 722                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 723                                  errmsg("server \"%s\" does not exist", stmt->servername)));
 724
 725         srvId = HeapTupleGetOid(tp);
 726         srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);
 727
 728         /*
 729          * Only owner or a superuser can ALTER a SERVER.
 730          */
 731         if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
 732                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
 733                                            stmt->servername);
 734
 735         memset(repl_val, 0, sizeof(repl_val));
 736         memset(repl_null, false, sizeof(repl_null));
 737         memset(repl_repl, false, sizeof(repl_repl));
 738
 739         if (stmt->has_version)
 740         {
 741                 /*
 742                  * Change the server VERSION string.
 743                  */
 744                 if (stmt->version)
 745                         repl_val[Anum_pg_foreign_server_srvversion - 1] =
 746                                 CStringGetTextDatum(stmt->version);
 747                 else
 748                         repl_null[Anum_pg_foreign_server_srvversion - 1] = true;
 749
 750                 repl_repl[Anum_pg_foreign_server_srvversion - 1] = true;
 751         }
 752
 753         if (stmt->options)
 754         {
 755                 ForeignDataWrapper *fdw = GetForeignDataWrapper(srvForm->srvfdw);
 756                 Datum           datum;
 757                 bool            isnull;
 758
 759                 /* Extract the current srvoptions */
 760                 datum = SysCacheGetAttr(FOREIGNSERVEROID,
 761                                                                 tp,
 762                                                                 Anum_pg_foreign_server_srvoptions,
 763                                                                 &isnull);
 764                 if (isnull)
 765                         datum = PointerGetDatum(NULL);
 766
 767                 /* Prepare the options array */
 768                 datum = transformGenericOptions(datum, stmt->options,
 769                                                                                 fdw->fdwvalidator);
 770
 771                 if (PointerIsValid(DatumGetPointer(datum)))
 772                         repl_val[Anum_pg_foreign_server_srvoptions - 1] = datum;
 773                 else
 774                         repl_null[Anum_pg_foreign_server_srvoptions - 1] = true;
 775
 776                 repl_repl[Anum_pg_foreign_server_srvoptions - 1] = true;
 777         }
 778
 779         /* Everything looks good - update the tuple */
 780
 781         rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 782
 783         tp = heap_modify_tuple(tp, RelationGetDescr(rel),
 784                                                    repl_val, repl_null, repl_repl);
 785
 786         simple_heap_update(rel, &tp->t_self, tp);
 787         CatalogUpdateIndexes(rel, tp);
 788
 789         heap_close(rel, RowExclusiveLock);
 790         heap_freetuple(tp);
 791 }
 792
 793
 794 /*
 795  * Drop foreign server
 796  */
 797 void
 798 RemoveForeignServer(DropForeignServerStmt *stmt)
 799 {
 800         Oid                     srvId;
 801         ObjectAddress object;
 802
 803         srvId = GetForeignServerOidByName(stmt->servername, true);
 804
 805         if (!OidIsValid(srvId))
 806         {
 807                 /* Server not found, complain or notice */
 808                 if (!stmt->missing_ok)
 809                         ereport(ERROR,
 810                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
 811                                   errmsg("server \"%s\" does not exist", stmt->servername)));
 812
 813                 /* IF EXISTS specified, just note it */
 814                 ereport(NOTICE,
 815                                 (errmsg("server \"%s\" does not exist, skipping",
 816                                                 stmt->servername)));
 817                 return;
 818         }
 819
 820         /* Only allow DROP if the server is owned by the user. */
 821         if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
 822                 aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
 823                                            stmt->servername);
 824
 825         object.classId = ForeignServerRelationId;
 826         object.objectId = srvId;
 827         object.objectSubId = 0;
 828
 829         performDeletion(&object, stmt->behavior);
 830 }
 831
 832
 833 /*
 834  * Drop foreign server by OID
 835  */
 836 void
 837 RemoveForeignServerById(Oid srvId)
 838 {
 839         HeapTuple       tp;
 840         Relation        rel;
 841
 842         rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 843
 844         tp = SearchSysCache(FOREIGNSERVEROID,
 845                                                 ObjectIdGetDatum(srvId),
 846                                                 0, 0, 0);
 847
 848         if (!HeapTupleIsValid(tp))
 849                 elog(ERROR, "cache lookup failed for foreign server %u", srvId);
 850
 851         simple_heap_delete(rel, &tp->t_self);
 852
 853         ReleaseSysCache(tp);
 854
 855         heap_close(rel, RowExclusiveLock);
 856 }
 857
 858
 859 /*
 860  * Common routine to check permission for user-mapping-related DDL
 861  * commands.  We allow server owners to operate on any mapping, and
 862  * users to operate on their own mapping.
 863  */
 864 static void
 865 user_mapping_ddl_aclcheck(Oid umuserid, Oid serverid, const char *servername)
 866 {
 867         Oid                     curuserid = GetUserId();
 868
 869         if (!pg_foreign_server_ownercheck(serverid, curuserid))
 870         {
 871                 if (umuserid == curuserid)
 872                 {
 873                         AclResult       aclresult;
 874
 875                         aclresult = pg_foreign_server_aclcheck(serverid, curuserid, ACL_USAGE);
 876                         if (aclresult != ACLCHECK_OK)
 877                                 aclcheck_error(aclresult, ACL_KIND_FOREIGN_SERVER, servername);
 878                 }
 879                 else
 880                         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
 881                                                    servername);
 882         }
 883 }
 884
 885
 886 /*
 887  * Create user mapping
 888  */
 889 void
 890 CreateUserMapping(CreateUserMappingStmt *stmt)
 891 {
 892         Relation        rel;
 893         Datum           useoptions;
 894         Datum           values[Natts_pg_user_mapping];
 895         bool            nulls[Natts_pg_user_mapping];
 896         HeapTuple       tuple;
 897         Oid                     useId;
 898         Oid                     umId;
 899         ObjectAddress myself;
 900         ObjectAddress referenced;
 901         ForeignServer *srv;
 902         ForeignDataWrapper *fdw;
 903
 904         useId = GetUserOidFromMapping(stmt->username, false);
 905
 906         /* Check that the server exists. */
 907         srv = GetForeignServerByName(stmt->servername, false);
 908
 909         user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);
 910
 911         /*
 912          * Check that the user mapping is unique within server.
 913          */
 914         umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
 915                                                   ObjectIdGetDatum(useId),
 916                                                   ObjectIdGetDatum(srv->serverid),
 917                                                   0, 0);
 918         if (OidIsValid(umId))
 919                 ereport(ERROR,
 920                                 (errcode(ERRCODE_DUPLICATE_OBJECT),
 921                                  errmsg("user mapping \"%s\" already exists for server %s",
 922                                                 MappingUserName(useId),
 923                                                 stmt->servername)));
 924
 925         fdw = GetForeignDataWrapper(srv->fdwid);
 926
 927         /*
 928          * Insert tuple into pg_user_mapping.
 929          */
 930         rel = heap_open(UserMappingRelationId, RowExclusiveLock);
 931
 932         memset(values, 0, sizeof(values));
 933         memset(nulls, false, sizeof(nulls));
 934
 935         values[Anum_pg_user_mapping_umuser - 1] = ObjectIdGetDatum(useId);
 936         values[Anum_pg_user_mapping_umserver - 1] = ObjectIdGetDatum(srv->serverid);
 937
 938         /* Add user options */
 939         useoptions = transformGenericOptions(PointerGetDatum(NULL), stmt->options,
 940                                                                                  fdw->fdwvalidator);
 941
 942         if (PointerIsValid(DatumGetPointer(useoptions)))
 943                 values[Anum_pg_user_mapping_umoptions - 1] = useoptions;
 944         else
 945                 nulls[Anum_pg_user_mapping_umoptions - 1] = true;
 946
 947         tuple = heap_form_tuple(rel->rd_att, values, nulls);
 948
 949         umId = simple_heap_insert(rel, tuple);
 950
 951         CatalogUpdateIndexes(rel, tuple);
 952
 953         heap_freetuple(tuple);
 954
 955         /* Add dependency on the server */
 956         myself.classId = UserMappingRelationId;
 957         myself.objectId = umId;
 958         myself.objectSubId = 0;
 959
 960         referenced.classId = ForeignServerRelationId;
 961         referenced.objectId = srv->serverid;
 962         referenced.objectSubId = 0;
 963         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 964
 965         if (OidIsValid(useId))
 966                 /* Record the mapped user dependency */
 967                 recordDependencyOnOwner(UserMappingRelationId, umId, useId);
 968
 969         heap_close(rel, NoLock);
 970 }
 971
 972
 973 /*
 974  * Alter user mapping
 975  */
 976 void
 977 AlterUserMapping(AlterUserMappingStmt *stmt)
 978 {
 979         Relation        rel;
 980         HeapTuple       tp;
 981         Datum           repl_val[Natts_pg_user_mapping];
 982         bool            repl_null[Natts_pg_user_mapping];
 983         bool            repl_repl[Natts_pg_user_mapping];
 984         Oid                     useId;
 985         Oid                     umId;
 986         ForeignServer *srv;
 987
 988         useId = GetUserOidFromMapping(stmt->username, false);
 989         srv = GetForeignServerByName(stmt->servername, false);
 990
 991         umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
 992                                                   ObjectIdGetDatum(useId),
 993                                                   ObjectIdGetDatum(srv->serverid),
 994                                                   0, 0);
 995         if (!OidIsValid(umId))
 996                 ereport(ERROR,
 997                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
 998                                  errmsg("user mapping \"%s\" does not exist for the server",
 999                                                 MappingUserName(useId))));
1000
1001         user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);
1002
1003         tp = SearchSysCacheCopy(USERMAPPINGOID,
1004                                                         ObjectIdGetDatum(umId),
1005                                                         0, 0, 0);
1006
1007         if (!HeapTupleIsValid(tp))
1008                 elog(ERROR, "cache lookup failed for user mapping %u", umId);
1009
1010         memset(repl_val, 0, sizeof(repl_val));
1011         memset(repl_null, false, sizeof(repl_null));
1012         memset(repl_repl, false, sizeof(repl_repl));
1013
1014         if (stmt->options)
1015         {
1016                 ForeignDataWrapper *fdw;
1017                 Datum           datum;
1018                 bool            isnull;
1019
1020                 /*
1021                  * Process the options.
1022                  */
1023
1024                 fdw = GetForeignDataWrapper(srv->fdwid);
1025
1026                 datum = SysCacheGetAttr(USERMAPPINGUSERSERVER,
1027                                                                 tp,
1028                                                                 Anum_pg_user_mapping_umoptions,
1029                                                                 &isnull);
1030                 if (isnull)
1031                         datum = PointerGetDatum(NULL);
1032
1033                 /* Prepare the options array */
1034                 datum = transformGenericOptions(datum, stmt->options,
1035                                                                                 fdw->fdwvalidator);
1036
1037                 if (PointerIsValid(DatumGetPointer(datum)))
1038                         repl_val[Anum_pg_user_mapping_umoptions - 1] = datum;
1039                 else
1040                         repl_null[Anum_pg_user_mapping_umoptions - 1] = true;
1041
1042                 repl_repl[Anum_pg_user_mapping_umoptions - 1] = true;
1043         }
1044
1045         /* Everything looks good - update the tuple */
1046
1047         rel = heap_open(UserMappingRelationId, RowExclusiveLock);
1048
1049         tp = heap_modify_tuple(tp, RelationGetDescr(rel),
1050                                                    repl_val, repl_null, repl_repl);
1051
1052         simple_heap_update(rel, &tp->t_self, tp);
1053         CatalogUpdateIndexes(rel, tp);
1054
1055         heap_close(rel, RowExclusiveLock);
1056         heap_freetuple(tp);
1057 }
1058
1059
1060 /*
1061  * Drop user mapping
1062  */
1063 void
1064 RemoveUserMapping(DropUserMappingStmt *stmt)
1065 {
1066         ObjectAddress object;
1067         Oid                     useId;
1068         Oid                     umId;
1069         ForeignServer *srv;
1070
1071         useId = GetUserOidFromMapping(stmt->username, stmt->missing_ok);
1072         srv = GetForeignServerByName(stmt->servername, true);
1073
1074         if (stmt->username && !OidIsValid(useId))
1075         {
1076                 /*
1077                  * IF EXISTS specified, role not found and not public. Notice this and
1078                  * leave.
1079                  */
1080                 elog(NOTICE, "role \"%s\" does not exist, skipping", stmt->username);
1081                 return;
1082         }
1083
1084         if (!srv)
1085         {
1086                 if (!stmt->missing_ok)
1087                         ereport(ERROR,
1088                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
1089                                          errmsg("server \"%s\" does not exist",
1090                                                         stmt->servername)));
1091                 /* IF EXISTS, just note it */
1092                 ereport(NOTICE, (errmsg("server does not exist, skipping")));
1093                 return;
1094         }
1095
1096         umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
1097                                                   ObjectIdGetDatum(useId),
1098                                                   ObjectIdGetDatum(srv->serverid),
1099                                                   0, 0);
1100
1101         if (!OidIsValid(umId))
1102         {
1103                 if (!stmt->missing_ok)
1104                         ereport(ERROR,
1105                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
1106                                   errmsg("user mapping \"%s\" does not exist for the server",
1107                                                  MappingUserName(useId))));
1108
1109                 /* IF EXISTS specified, just note it */
1110                 ereport(NOTICE,
1111                 (errmsg("user mapping \"%s\" does not exist for the server, skipping",
1112                                 MappingUserName(useId))));
1113                 return;
1114         }
1115
1116         user_mapping_ddl_aclcheck(useId, srv->serverid, srv->servername);
1117
1118         /*
1119          * Do the deletion
1120          */
1121         object.classId = UserMappingRelationId;
1122         object.objectId = umId;
1123         object.objectSubId = 0;
1124
1125         performDeletion(&object, DROP_CASCADE);
1126 }
1127
1128
1129 /*
1130  * Drop user mapping by OID.  This is called to clean up dependencies.
1131  */
1132 void
1133 RemoveUserMappingById(Oid umId)
1134 {
1135         HeapTuple       tp;
1136         Relation        rel;
1137
1138         rel = heap_open(UserMappingRelationId, RowExclusiveLock);
1139
1140         tp = SearchSysCache(USERMAPPINGOID,
1141                                                 ObjectIdGetDatum(umId),
1142                                                 0, 0, 0);
1143
1144         if (!HeapTupleIsValid(tp))
1145                 elog(ERROR, "cache lookup failed for user mapping %u", umId);
1146
1147         simple_heap_delete(rel, &tp->t_self);
1148
1149         ReleaseSysCache(tp);
1150
1151         heap_close(rel, RowExclusiveLock);
1152 }