/*-------------------------------------------------------------------------

 *

 * foreigncmds.c

 *    foreign-data wrapper/server creation/manipulation commands

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 *

 *

 * IDENTIFICATION

 *    src/backend/commands/foreigncmds.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/htup_details.h"

#include "access/reloptions.h"

#include "access/table.h"

#include "access/xact.h"

#include "catalog/catalog.h"

#include "catalog/dependency.h"

#include "catalog/indexing.h"

#include "catalog/objectaccess.h"

#include "catalog/pg_foreign_data_wrapper.h"

#include "catalog/pg_foreign_server.h"

#include "catalog/pg_foreign_table.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_type.h"

#include "catalog/pg_user_mapping.h"

#include "commands/defrem.h"

#include "foreign/fdwapi.h"

#include "foreign/foreign.h"

#include "miscadmin.h"

#include "parser/parse_func.h"

#include "tcop/utility.h"

#include "utils/acl.h"

#include "utils/builtins.h"

#include "utils/lsyscache.h"

#include "utils/rel.h"

#include "utils/syscache.h"

typedef struct

{

  char     *tablename;

  char     *cmd;

} import_error_callback_arg;

/* Internal functions */

static void import_error_callback(void *arg);

/*

 * Convert a DefElem list to the text array format that is used in

 * pg_foreign_data_wrapper, pg_foreign_server, pg_user_mapping, and

 * pg_foreign_table.

 *

 * Returns the array in the form of a Datum, or PointerGetDatum(NULL)

 * if the list is empty.

 *

 * Note: The array is usually stored to database without further

 * processing, hence any validation should be done before this

 * conversion.

 */

static Datum

optionListToArray(List *options)

{

  ArrayBuildState *astate = NULL;

  ListCell   *cell;

  foreach(cell, options)

  {

    DefElem    *def = lfirst(cell);

    const char *name;

    const char *value;

    Size    len;

    text     *t;

    name = def->defname;

    value = defGetString(def);

    /* Insist that name not contain "=", else "a=b=c" is ambiguous */

    if (strchr(name, '=') != NULL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

           errmsg("invalid option name \"%s\": must not contain \"=\"",

              name)));

    len = VARHDRSZ + strlen(name) + 1 + strlen(value);

    /* +1 leaves room for sprintf's trailing null */

    t = palloc(len + 1);

    SET_VARSIZE(t, len);

    sprintf(VARDATA(t), "%s=%s", name, value);

    astate = accumArrayResult(astate, PointerGetDatum(t),

                  false, TEXTOID,

                  CurrentMemoryContext);

  }

  if (astate)

    return makeArrayResult(astate, CurrentMemoryContext);

  return PointerGetDatum(NULL);

}

/*

 * Transform a list of DefElem into text array format.  This is substantially

 * the same thing as optionListToArray(), except we recognize SET/ADD/DROP

 * actions for modifying an existing list of options, which is passed in

 * Datum form as oldOptions.  Also, if fdwvalidator isn't InvalidOid

 * it specifies a validator function to call on the result.

 *

 * Returns the array in the form of a Datum, or PointerGetDatum(NULL)

 * if the list is empty.

 *

 * This is used by CREATE/ALTER of FOREIGN DATA WRAPPER/SERVER/USER MAPPING/

 * FOREIGN TABLE.

 */

Datum

transformGenericOptions(Oid catalogId,

            Datum oldOptions,

            List *options,

            Oid fdwvalidator)

{

  List     *resultOptions = untransformRelOptions(oldOptions);

  ListCell   *optcell;

  Datum   result;

  foreach(optcell, options)

  {

    DefElem    *od = lfirst(optcell);

    ListCell   *cell;

    /*

     * Find the element in resultOptions.  We need this for validation in

     * all cases.

     */

    foreach(cell, resultOptions)

    {

      DefElem    *def = lfirst(cell);

      if (strcmp(def->defname, od->defname) == 0)

        break;

    }

    /*

     * It is possible to perform multiple SET/DROP actions on the same

     * option.  The standard permits this, as long as the options to be

     * added are unique.  Note that an unspecified action is taken to be

     * ADD.

     */

    switch (od->defaction)

    {

      case DEFELEM_DROP:

        if (!cell)

          ereport(ERROR,

              (errcode(ERRCODE_UNDEFINED_OBJECT),

               errmsg("option \"%s\" not found",

                  od->defname)));

        resultOptions = list_delete_cell(resultOptions, cell);

        break;

      case DEFELEM_SET:

        if (!cell)

          ereport(ERROR,

              (errcode(ERRCODE_UNDEFINED_OBJECT),

               errmsg("option \"%s\" not found",

                  od->defname)));

        lfirst(cell) = od;

        break;

      case DEFELEM_ADD:

      case DEFELEM_UNSPEC:

        if (cell)

          ereport(ERROR,

              (errcode(ERRCODE_DUPLICATE_OBJECT),

               errmsg("option \"%s\" provided more than once",

                  od->defname)));

        resultOptions = lappend(resultOptions, od);

        break;

      default:

        elog(ERROR, "unrecognized action %d on option \"%s\"",

           (int) od->defaction, od->defname);

        break;

    }

  }

  result = optionListToArray(resultOptions);

  if (OidIsValid(fdwvalidator))

  {

    Datum   valarg = result;

    /*

     * Pass a null options list as an empty array, so that validators

     * don't have to be declared non-strict to handle the case.

     */

    if (DatumGetPointer(valarg) == NULL)

      valarg = PointerGetDatum(construct_empty_array(TEXTOID));

    OidFunctionCall2(fdwvalidator, valarg, ObjectIdGetDatum(catalogId));

  }

  return result;

}

/*

 * Internal workhorse for changing a data wrapper's owner.

 *

 * Allow this only for superusers; also the new owner must be a

 * superuser.

 */

static void

AlterForeignDataWrapperOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)

{

  Form_pg_foreign_data_wrapper form;

  Datum   repl_val[Natts_pg_foreign_data_wrapper];

  bool    repl_null[Natts_pg_foreign_data_wrapper];

  bool    repl_repl[Natts_pg_foreign_data_wrapper];

  Acl      *newAcl;

  Datum   aclDatum;

  bool    isNull;

  form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);

  /* Must be a superuser to change a FDW owner */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",

            NameStr(form->fdwname)),

         errhint("Must be superuser to change owner of a foreign-data wrapper.")));

  /* New owner must also be a superuser */

  if (!superuser_arg(newOwnerId))

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",

            NameStr(form->fdwname)),

         errhint("The owner of a foreign-data wrapper must be a superuser.")));

  if (form->fdwowner != newOwnerId)

  {

    memset(repl_null, false, sizeof(repl_null));

    memset(repl_repl, false, sizeof(repl_repl));

    repl_repl[Anum_pg_foreign_data_wrapper_fdwowner - 1] = true;

    repl_val[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(newOwnerId);

    aclDatum = heap_getattr(tup,

                Anum_pg_foreign_data_wrapper_fdwacl,

                RelationGetDescr(rel),

                &isNull);

    /* Null ACLs do not require changes */

    if (!isNull)

    {

      newAcl = aclnewowner(DatumGetAclP(aclDatum),

                 form->fdwowner, newOwnerId);

      repl_repl[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;

      repl_val[Anum_pg_foreign_data_wrapper_fdwacl - 1] = PointerGetDatum(newAcl);

    }

    tup = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null,

                repl_repl);

    CatalogTupleUpdate(rel, &tup->t_self, tup);

    /* Update owner dependency reference */

    changeDependencyOnOwner(ForeignDataWrapperRelationId,

                form->oid,

                newOwnerId);

  }

  InvokeObjectPostAlterHook(ForeignDataWrapperRelationId,

                form->oid, 0);

}

/*

 * Change foreign-data wrapper owner -- by name

 *

 * Note restrictions in the "_internal" function, above.

 */

ObjectAddress

AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId)

{

  Oid     fdwId;

  HeapTuple tup;

  Relation  rel;

  ObjectAddress address;

  Form_pg_foreign_data_wrapper form;

  rel = table_open(ForeignDataWrapperRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(FOREIGNDATAWRAPPERNAME, CStringGetDatum(name));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("foreign-data wrapper \"%s\" does not exist", name)));

  form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);

  fdwId = form->oid;

  AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);

  ObjectAddressSet(address, ForeignDataWrapperRelationId, fdwId);

  heap_freetuple(tup);

  table_close(rel, RowExclusiveLock);

  return address;

}

/*

 * Change foreign-data wrapper owner -- by OID

 *

 * Note restrictions in the "_internal" function, above.

 */

void

AlterForeignDataWrapperOwner_oid(Oid fwdId, Oid newOwnerId)

{

  HeapTuple tup;

  Relation  rel;

  rel = table_open(ForeignDataWrapperRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(FOREIGNDATAWRAPPEROID, ObjectIdGetDatum(fwdId));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("foreign-data wrapper with OID %u does not exist", fwdId)));

  AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);

  heap_freetuple(tup);

  table_close(rel, RowExclusiveLock);

}

/*

 * Internal workhorse for changing a foreign server's owner

 */

static void

AlterForeignServerOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)

{

  Form_pg_foreign_server form;

  Datum   repl_val[Natts_pg_foreign_server];

  bool    repl_null[Natts_pg_foreign_server];

  bool    repl_repl[Natts_pg_foreign_server];

  Acl      *newAcl;

  Datum   aclDatum;

  bool    isNull;

  form = (Form_pg_foreign_server) GETSTRUCT(tup);

  if (form->srvowner != newOwnerId)

  {

    /* Superusers can always do it */

    if (!superuser())

    {

      Oid     srvId;

      AclResult aclresult;

      srvId = form->oid;

      /* Must be owner */

      if (!object_ownercheck(ForeignServerRelationId, srvId, GetUserId()))

        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FOREIGN_SERVER,

                 NameStr(form->srvname));

      /* Must be able to become new owner */

      check_can_set_role(GetUserId(), newOwnerId);

      /* New owner must have USAGE privilege on foreign-data wrapper */

      aclresult = object_aclcheck(ForeignDataWrapperRelationId, form->srvfdw, newOwnerId, ACL_USAGE);

      if (aclresult != ACLCHECK_OK)

      {

        ForeignDataWrapper *fdw = GetForeignDataWrapper(form->srvfdw);

        aclcheck_error(aclresult, OBJECT_FDW, fdw->fdwname);

      }

    }

    memset(repl_null, false, sizeof(repl_null));

    memset(repl_repl, false, sizeof(repl_repl));

    repl_repl[Anum_pg_foreign_server_srvowner - 1] = true;

    repl_val[Anum_pg_foreign_server_srvowner - 1] = ObjectIdGetDatum(newOwnerId);

    aclDatum = heap_getattr(tup,

                Anum_pg_foreign_server_srvacl,

                RelationGetDescr(rel),

                &isNull);

    /* Null ACLs do not require changes */

    if (!isNull)

    {

      newAcl = aclnewowner(DatumGetAclP(aclDatum),

                 form->srvowner, newOwnerId);

      repl_repl[Anum_pg_foreign_server_srvacl - 1] = true;

      repl_val[Anum_pg_foreign_server_srvacl - 1] = PointerGetDatum(newAcl);

    }

    tup = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null,

                repl_repl);

    CatalogTupleUpdate(rel, &tup->t_self, tup);

    /* Update owner dependency reference */

    changeDependencyOnOwner(ForeignServerRelationId, form->oid,

                newOwnerId);

  }

  InvokeObjectPostAlterHook(ForeignServerRelationId,

                form->oid, 0);

}

/*

 * Change foreign server owner -- by name

 */

ObjectAddress

AlterForeignServerOwner(const char *name, Oid newOwnerId)

{

  Oid     servOid;

  HeapTuple tup;

  Relation  rel;

  ObjectAddress address;

  Form_pg_foreign_server form;

  rel = table_open(ForeignServerRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(FOREIGNSERVERNAME, CStringGetDatum(name));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("server \"%s\" does not exist", name)));

  form = (Form_pg_foreign_server) GETSTRUCT(tup);

  servOid = form->oid;

  AlterForeignServerOwner_internal(rel, tup, newOwnerId);

  ObjectAddressSet(address, ForeignServerRelationId, servOid);

  heap_freetuple(tup);

  table_close(rel, RowExclusiveLock);

  return address;

}

/*

 * Change foreign server owner -- by OID

 */

void

AlterForeignServerOwner_oid(Oid srvId, Oid newOwnerId)

{

  HeapTuple tup;

  Relation  rel;

  rel = table_open(ForeignServerRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(FOREIGNSERVEROID, ObjectIdGetDatum(srvId));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("foreign server with OID %u does not exist", srvId)));

  AlterForeignServerOwner_internal(rel, tup, newOwnerId);

  heap_freetuple(tup);

  table_close(rel, RowExclusiveLock);

}

/*

 * Convert a handler function name passed from the parser to an Oid.

 */

static Oid

lookup_fdw_handler_func(DefElem *handler)

{

  Oid     handlerOid;

  if (handler == NULL || handler->arg == NULL)

    return InvalidOid;

  /* handlers have no arguments */

  handlerOid = LookupFuncName((List *) handler->arg, 0, NULL, false);

  /* check that handler has correct return type */

  if (get_func_rettype(handlerOid) != FDW_HANDLEROID)

    ereport(ERROR,

        (errcode(ERRCODE_WRONG_OBJECT_TYPE),

         errmsg("function %s must return type %s",

            NameListToString((List *) handler->arg), "fdw_handler")));

  return handlerOid;

}

/*

 * Convert a validator function name passed from the parser to an Oid.

 */

static Oid

lookup_fdw_validator_func(DefElem *validator)

{

  Oid     funcargtypes[2];

  if (validator == NULL || validator->arg == NULL)

    return InvalidOid;

  /* validators take text[], oid */

  funcargtypes[0] = TEXTARRAYOID;

  funcargtypes[1] = OIDOID;

  return LookupFuncName((List *) validator->arg, 2, funcargtypes, false);

  /* validator's return value is ignored, so we don't check the type */

}

/*

 * Process function options of CREATE/ALTER FDW

 */

static void

parse_func_options(ParseState *pstate, List *func_options,

           bool *handler_given, Oid *fdwhandler,

           bool *validator_given, Oid *fdwvalidator)

{

  ListCell   *cell;

  *handler_given = false;

  *validator_given = false;

  /* return InvalidOid if not given */

  *fdwhandler = InvalidOid;

  *fdwvalidator = InvalidOid;

  foreach(cell, func_options)

  {

    DefElem    *def = (DefElem *) lfirst(cell);

    if (strcmp(def->defname, "handler") == 0)

    {

      if (*handler_given)

        errorConflictingDefElem(def, pstate);

      *handler_given = true;

      *fdwhandler = lookup_fdw_handler_func(def);

    }

    else if (strcmp(def->defname, "validator") == 0)

    {

      if (*validator_given)

        errorConflictingDefElem(def, pstate);

      *validator_given = true;

      *fdwvalidator = lookup_fdw_validator_func(def);

    }

    else

      elog(ERROR, "option \"%s\" not recognized",

         def->defname);

  }

}

/*

 * Create a foreign-data wrapper

 */

ObjectAddress

CreateForeignDataWrapper(ParseState *pstate, CreateFdwStmt *stmt)

{

  Relation  rel;

  Datum   values[Natts_pg_foreign_data_wrapper];

  bool    nulls[Natts_pg_foreign_data_wrapper];

  HeapTuple tuple;

  Oid     fdwId;

  bool    handler_given;

  bool    validator_given;

  Oid     fdwhandler;

  Oid     fdwvalidator;

  Datum   fdwoptions;

  Oid     ownerId;

  ObjectAddress myself;

  ObjectAddress referenced;

  rel = table_open(ForeignDataWrapperRelationId, RowExclusiveLock);

  /* Must be superuser */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to create foreign-data wrapper \"%s\"",

            stmt->fdwname),

         errhint("Must be superuser to create a foreign-data wrapper.")));

  /* For now the owner cannot be specified on create. Use effective user ID. */

  ownerId = GetUserId();

  /*

   * Check that there is no other foreign-data wrapper by this name.

   */

  if (GetForeignDataWrapperByName(stmt->fdwname, true) != NULL)

    ereport(ERROR,

        (errcode(ERRCODE_DUPLICATE_OBJECT),

         errmsg("foreign-data wrapper \"%s\" already exists",

            stmt->fdwname)));

  /*

   * Insert tuple into pg_foreign_data_wrapper.

   */

  memset(values, 0, sizeof(values));

  memset(nulls, false, sizeof(nulls));

  fdwId = GetNewOidWithIndex(rel, ForeignDataWrapperOidIndexId,

                 Anum_pg_foreign_data_wrapper_oid);

  values[Anum_pg_foreign_data_wrapper_oid - 1] = ObjectIdGetDatum(fdwId);

  values[Anum_pg_foreign_data_wrapper_fdwname - 1] =

    DirectFunctionCall1(namein, CStringGetDatum(stmt->fdwname));

  values[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(ownerId);

  /* Lookup handler and validator functions, if given */

  parse_func_options(pstate, stmt->func_options,

             &handler_given, &fdwhandler,

             &validator_given, &fdwvalidator);

  values[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = ObjectIdGetDatum(fdwhandler);

  values[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);

  nulls[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;

  fdwoptions = transformGenericOptions(ForeignDataWrapperRelationId,

                     PointerGetDatum(NULL),

                     stmt->options,

                     fdwvalidator);

  if (DatumGetPointer(fdwoptions) != NULL)

    values[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = fdwoptions;

  else

    nulls[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;

  tuple = heap_form_tuple(rel->rd_att, values, nulls);

  CatalogTupleInsert(rel, tuple);

  heap_freetuple(tuple);

  /* record dependencies */

  myself.classId = ForeignDataWrapperRelationId;

  myself.objectId = fdwId;

  myself.objectSubId = 0;

  if (OidIsValid(fdwhandler))

  {

    referenced.classId = ProcedureRelationId;

    referenced.objectId = fdwhandler;

    referenced.objectSubId = 0;

    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  }

  if (OidIsValid(fdwvalidator))

  {

    referenced.classId = ProcedureRelationId;

    referenced.objectId = fdwvalidator;

    referenced.objectSubId = 0;

    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  }

  recordDependencyOnOwner(ForeignDataWrapperRelationId, fdwId, ownerId);

  /* dependency on extension */

  recordDependencyOnCurrentExtension(&myself, false);

  /* Post creation hook for new foreign data wrapper */

  InvokeObjectPostCreateHook(ForeignDataWrapperRelationId, fdwId, 0);

  table_close(rel, RowExclusiveLock);

  return myself;

}

/*

 * Alter foreign-data wrapper

 */

ObjectAddress

AlterForeignDataWrapper(ParseState *pstate, AlterFdwStmt *stmt)

{

  Relation  rel;

  HeapTuple tp;

  Form_pg_foreign_data_wrapper fdwForm;

  Datum   repl_val[Natts_pg_foreign_data_wrapper];

  bool    repl_null[Natts_pg_foreign_data_wrapper];

  bool    repl_repl[Natts_pg_foreign_data_wrapper];

  Oid     fdwId;

  bool    isnull;

  Datum   datum;

  bool    handler_given;

  bool    validator_given;

  Oid     fdwhandler;

  Oid     fdwvalidator;

  ObjectAddress myself;

  rel = table_open(ForeignDataWrapperRelationId, RowExclusiveLock);

  /* Must be superuser */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to alter foreign-data wrapper \"%s\"",

            stmt->fdwname),

         errhint("Must be superuser to alter a foreign-data wrapper.")));

  tp = SearchSysCacheCopy1(FOREIGNDATAWRAPPERNAME,

               CStringGetDatum(stmt->fdwname));

  if (!HeapTupleIsValid(tp))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));

  fdwForm = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);

  fdwId = fdwForm->oid;

  memset(repl_val, 0, sizeof(repl_val));

  memset(repl_null, false, sizeof(repl_null));

  memset(repl_repl, false, sizeof(repl_repl));

  parse_func_options(pstate, stmt->func_options,

             &handler_given, &fdwhandler,

             &validator_given, &fdwvalidator);

  if (handler_given)

  {

    repl_val[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = ObjectIdGetDatum(fdwhandler);

    repl_repl[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = true;

    /*

     * It could be that the behavior of accessing foreign table changes

     * with the new handler.  Warn about this.

     */

    ereport(WARNING,

        (errmsg("changing the foreign-data wrapper handler can change behavior of existing foreign tables")));

  }

  if (validator_given)

  {

    repl_val[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);

    repl_repl[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = true;

    /*

     * It could be that existing options for the FDW or dependent SERVER,

     * USER MAPPING or FOREIGN TABLE objects are no longer valid according

     * to the new validator.  Warn about this.

     */

    if (OidIsValid(fdwvalidator))

      ereport(WARNING,

          (errmsg("changing the foreign-data wrapper validator can cause "

              "the options for dependent objects to become invalid")));

  }

  else

  {

    /*

     * Validator is not changed, but we need it for validating options.

     */

    fdwvalidator = fdwForm->fdwvalidator;

  }

  /*

   * If options specified, validate and update.

   */

  if (stmt->options)

  {

    /* Extract the current options */

    datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,

                tp,

                Anum_pg_foreign_data_wrapper_fdwoptions,

                &isnull);

    if (isnull)

      datum = PointerGetDatum(NULL);

    /* Transform the options */

    datum = transformGenericOptions(ForeignDataWrapperRelationId,

                    datum,

                    stmt->options,

                    fdwvalidator);

    if (DatumGetPointer(datum) != NULL)

      repl_val[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = datum;

    else

      repl_null[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;

    repl_repl[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;

  }

  /* Everything looks good - update the tuple */

  tp = heap_modify_tuple(tp, RelationGetDescr(rel),

               repl_val, repl_null, repl_repl);

  CatalogTupleUpdate(rel, &tp->t_self, tp);

  heap_freetuple(tp);

  ObjectAddressSet(myself, ForeignDataWrapperRelationId, fdwId);

  /* Update function dependencies if we changed them */

  if (handler_given || validator_given)

  {

    ObjectAddress referenced;

    /*

     * Flush all existing dependency records of this FDW on functions; we

     * assume there can be none other than the ones we are fixing.

     */

    deleteDependencyRecordsForClass(ForeignDataWrapperRelationId,

                    fdwId,

                    ProcedureRelationId,

                    DEPENDENCY_NORMAL);

    /* And build new ones. */

    if (OidIsValid(fdwhandler))

    {

      referenced.classId = ProcedureRelationId;

      referenced.objectId = fdwhandler;

      referenced.objectSubId = 0;

      recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    }

    if (OidIsValid(fdwvalidator))

    {

      referenced.classId = ProcedureRelationId;

      referenced.objectId = fdwvalidator;

      referenced.objectSubId = 0;

      recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    }

  }

  InvokeObjectPostAlterHook(ForeignDataWrapperRelationId, fdwId, 0);

  table_close(rel, RowExclusiveLock);

  return myself;

}

/*

 * Create a foreign server

 */

ObjectAddress

CreateForeignServer(CreateForeignServerStmt *stmt)

{

  Relation  rel;

  Datum   srvoptions;

  Datum   values[Natts_pg_foreign_server];

  bool    nulls[Natts_pg_foreign_server];

  HeapTuple tuple;

  Oid     srvId;

  Oid     ownerId;

  AclResult aclresult;

  ObjectAddress myself;

  ObjectAddress referenced;

  ForeignDataWrapper *fdw;

  rel = table_open(ForeignServerRelationId, RowExclusiveLock);

  /* For now the owner cannot be specified on create. Use effective user ID. */

  ownerId = GetUserId();

  /*

   * Check that there is no other foreign server by this name.  If there is

   * one, do nothing if IF NOT EXISTS was specified.

   */

  srvId = get_foreign_server_oid(stmt->servername, true);

  if (OidIsValid(srvId))

  {

    if (stmt->if_not_exists)

    {

      /*

       * If we are in an extension script, insist that the pre-existing

       * object be a member of the extension, to avoid security risks.

       */

      ObjectAddressSet(myself, ForeignServerRelationId, srvId);

      checkMembershipInCurrentExtension(&myself);

      /* OK to skip */

      ereport(NOTICE,

          (errcode(ERRCODE_DUPLICATE_OBJECT),

           errmsg("server \"%s\" already exists, skipping",

              stmt->servername)));

      table_close(rel, RowExclusiveLock);

      return InvalidObjectAddress;

    }

    else

      ereport(ERROR,

          (errcode(ERRCODE_DUPLICATE_OBJECT),

           errmsg("server \"%s\" already exists",

              stmt->servername)));

  }

  /*

   * Check that the FDW exists and that we have USAGE on it. Also get the

   * actual FDW for option validation etc.

   */

  fdw = GetForeignDataWrapperByName(stmt->fdwname, false);

  aclresult = object_aclcheck(ForeignDataWrapperRelationId, fdw->fdwid, ownerId, ACL_USAGE);

  if (aclresult != ACLCHECK_OK)