#include "postgres.h"
#include "access/htup_details.h"
#include "access/reloptions.h"
#include "catalog/pg_foreign_data_wrapper.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_foreign_table.h"
#include "catalog/pg_user_mapping.h"
#include "foreign/fdwapi.h"
#include "foreign/foreign.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for foreign.c:

Data Structures
struct	ConnectionOption

Functions
ForeignDataWrapper *	GetForeignDataWrapper (Oid fdwid)

ForeignDataWrapper *	GetForeignDataWrapperByName (const char *fdwname, bool missing_ok)

ForeignServer *	GetForeignServer (Oid serverid)

ForeignServer *	GetForeignServerByName (const char *srvname, bool missing_ok)

UserMapping *	GetUserMapping (Oid userid, Oid serverid)

ForeignTable *	GetForeignTable (Oid relid)

List *	GetForeignColumnOptions (Oid relid, AttrNumber attnum)

FdwRoutine *	GetFdwRoutine (Oid fdwhandler)

Oid	GetForeignServerIdByRelId (Oid relid)

FdwRoutine *	GetFdwRoutineByServerId (Oid serverid)

FdwRoutine *	GetFdwRoutineByRelId (Oid relid)

FdwRoutine *	GetFdwRoutineForRelation (Relation relation, bool makecopy)

bool	IsImportableForeignTable (const char tablename, ImportForeignSchemaStmt stmt)

static void	deflist_to_tuplestore (ReturnSetInfo rsinfo, List options)

Datum	pg_options_to_table (PG_FUNCTION_ARGS)

static bool	is_conninfo_option (const char *option, Oid context)

Datum	postgresql_fdw_validator (PG_FUNCTION_ARGS)

Oid	get_foreign_data_wrapper_oid (const char *fdwname, bool missing_ok)

Oid	get_foreign_server_oid (const char *servername, bool missing_ok)

Path *	GetExistingLocalJoinPath (RelOptInfo *joinrel)

Variables
static struct ConnectionOption	libpq_conninfo_options []

Function Documentation

static void deflist_to_tuplestore	(	ReturnSetInfo *	rsinfo,
		List *	options
	)

static

Definition at line 474 of file foreign.c.

References ReturnSetInfo::allowedModes, DefElem::arg, CreateTupleDescCopy(), CStringGetTextDatum, DefElem::defname, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ereport, errcode(), errmsg(), ERROR, ReturnSetInfo::expectedDesc, IsA, lfirst, MemoryContextSwitchTo(), NULL, ReturnSetInfo::returnMode, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, tuplestore_begin_heap(), tuplestore_donestoring, tuplestore_putvalues(), values, and work_mem.

Referenced by pg_options_to_table().

 {
     ListCell   *cell;
     TupleDesc   tupdesc;
     Tuplestorestate *tupstore;
     Datum       values[2];
     bool        nulls[2];
     MemoryContext per_query_ctx;
     MemoryContext oldcontext;
 
     /* check to see if caller supports us returning a tuplestore */
     if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("set-valued function called in context that cannot accept a set")));
     if (!(rsinfo->allowedModes & SFRM_Materialize) ||
         rsinfo->expectedDesc == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("materialize mode required, but it is not allowed in this context")));
 
     per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
     oldcontext = MemoryContextSwitchTo(per_query_ctx);
 
     /*
      * Now prepare the result set.
      */
     tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
     tupstore = tuplestore_begin_heap(true, false, work_mem);
     rsinfo->returnMode = SFRM_Materialize;
     rsinfo->setResult = tupstore;
     rsinfo->setDesc = tupdesc;
 
     foreach(cell, options)
     {
         DefElem    *def = lfirst(cell);
 
         values[0] = CStringGetTextDatum(def->defname);
         nulls[0] = false;
         if (def->arg)
         {
             values[1] = CStringGetTextDatum(((Value *) (def->arg))->val.str);
             nulls[1] = false;
         }
         else
         {
             values[1] = (Datum) 0;
             nulls[1] = true;
         }
         tuplestore_putvalues(tupstore, tupdesc, values, nulls);
     }
 
     /* clean up and return the tuplestore */
     tuplestore_donestoring(tupstore);
 
     MemoryContextSwitchTo(oldcontext);
 }

Oid get_foreign_data_wrapper_oid	(	const char *	fdwname,
		bool	missing_ok
	)

Definition at line 659 of file foreign.c.

References CStringGetDatum, ereport, errcode(), errmsg(), ERROR, FOREIGNDATAWRAPPERNAME, GetSysCacheOid1, and OidIsValid.

Referenced by convert_foreign_data_wrapper_name(), get_object_address_unqualified(), GetForeignDataWrapperByName(), and objectNamesToOids().

 {
     Oid         oid;
 
     oid = GetSysCacheOid1(FOREIGNDATAWRAPPERNAME, CStringGetDatum(fdwname));
     if (!OidIsValid(oid) && !missing_ok)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("foreign-data wrapper \"%s\" does not exist",
                         fdwname)));
     return oid;
 }

Oid get_foreign_server_oid	(	const char *	servername,
		bool	missing_ok
	)

Definition at line 680 of file foreign.c.

References CStringGetDatum, ereport, errcode(), errmsg(), ERROR, FOREIGNSERVERNAME, GetSysCacheOid1, and OidIsValid.

Referenced by convert_server_name(), get_object_address_unqualified(), GetForeignServerByName(), and objectNamesToOids().

 {
     Oid         oid;
 
     oid = GetSysCacheOid1(FOREIGNSERVERNAME, CStringGetDatum(servername));
     if (!OidIsValid(oid) && !missing_ok)
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("server \"%s\" does not exist", servername)));
     return oid;
 }

Path* GetExistingLocalJoinPath ( RelOptInfo * joinrel )

Definition at line 716 of file foreign.c.

References Assert, ForeignPath::fdw_outerpath, JoinPath::innerjoinpath, IS_JOIN_REL, IsA, lfirst, makeNode, NULL, JoinPath::outerjoinpath, Path::param_info, Path::parent, ForeignPath::path, RelOptInfo::pathlist, Path::pathtype, T_HashJoin, T_MergeJoin, and T_NestLoop.

Referenced by postgresGetForeignJoinPaths().

 {
     ListCell   *lc;
 
     Assert(IS_JOIN_REL(joinrel));
 
     foreach(lc, joinrel->pathlist)
     {
         Path       *path = (Path *) lfirst(lc);
         JoinPath   *joinpath = NULL;
 
         /* Skip parameterized paths. */
         if (path->param_info != NULL)
             continue;
 
         switch (path->pathtype)
         {
             case T_HashJoin:
                 {
                     HashPath   *hash_path = makeNode(HashPath);
 
                     memcpy(hash_path, path, sizeof(HashPath));
                     joinpath = (JoinPath *) hash_path;
                 }
                 break;
 
             case T_NestLoop:
                 {
                     NestPath   *nest_path = makeNode(NestPath);
 
                     memcpy(nest_path, path, sizeof(NestPath));
                     joinpath = (JoinPath *) nest_path;
                 }
                 break;
 
             case T_MergeJoin:
                 {
                     MergePath  *merge_path = makeNode(MergePath);
 
                     memcpy(merge_path, path, sizeof(MergePath));
                     joinpath = (JoinPath *) merge_path;
                 }
                 break;
 
             default:
 
                 /*
                  * Just skip anything else. We don't know if corresponding
                  * plan would build the output row from whole-row references
                  * of base relations and execute the EPQ checks.
                  */
                 break;
         }
 
         /* This path isn't good for us, check next. */
         if (!joinpath)
             continue;
 
         /*
          * If either inner or outer path is a ForeignPath corresponding to a
          * pushed down join, replace it with the fdw_outerpath, so that we
          * maintain path for EPQ checks built entirely of local join
          * strategies.
          */
         if (IsA(joinpath->outerjoinpath, ForeignPath))
         {
             ForeignPath *foreign_path;
 
             foreign_path = (ForeignPath *) joinpath->outerjoinpath;
             if (IS_JOIN_REL(foreign_path->path.parent))
                 joinpath->outerjoinpath = foreign_path->fdw_outerpath;
         }
 
         if (IsA(joinpath->innerjoinpath, ForeignPath))
         {
             ForeignPath *foreign_path;
 
             foreign_path = (ForeignPath *) joinpath->innerjoinpath;
             if (IS_JOIN_REL(foreign_path->path.parent))
                 joinpath->innerjoinpath = foreign_path->fdw_outerpath;
         }
 
         return (Path *) joinpath;
     }
     return NULL;
 }

FdwRoutine* GetFdwRoutine ( Oid fdwhandler )

Definition at line 287 of file foreign.c.

References DatumGetPointer, elog, ERROR, IsA, NULL, and OidFunctionCall0.

Referenced by GetFdwRoutineByServerId(), and ImportForeignSchema().

 {
     Datum       datum;
     FdwRoutine *routine;
 
     datum = OidFunctionCall0(fdwhandler);
     routine = (FdwRoutine *) DatumGetPointer(datum);
 
     if (routine == NULL || !IsA(routine, FdwRoutine))
         elog(ERROR, "foreign-data wrapper handler function %u did not return an FdwRoutine struct",
              fdwhandler);
 
     return routine;
 }

FdwRoutine* GetFdwRoutineByRelId ( Oid relid )

Definition at line 372 of file foreign.c.

References GetFdwRoutineByServerId(), and GetForeignServerIdByRelId().

Referenced by GetFdwRoutineForRelation(), make_modifytable(), and select_rowmark_type().

 {
     Oid         serverid;
 
     /* Get server OID for the foreign table. */
     serverid = GetForeignServerIdByRelId(relid);
 
     /* Now retrieve server's FdwRoutine struct. */
     return GetFdwRoutineByServerId(serverid);
 }

FdwRoutine* GetFdwRoutineByServerId ( Oid serverid )

Definition at line 330 of file foreign.c.

References elog, ereport, errcode(), errmsg(), ERROR, FOREIGNDATAWRAPPEROID, FOREIGNSERVEROID, GetFdwRoutine(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum, OidIsValid, ReleaseSysCache(), and SearchSysCache1.

Referenced by ExecInitForeignScan(), and GetFdwRoutineByRelId().

 {
     HeapTuple   tp;
     Form_pg_foreign_data_wrapper fdwform;
     Form_pg_foreign_server serverform;
     Oid         fdwid;
     Oid         fdwhandler;
 
     /* Get foreign-data wrapper OID for the server. */
     tp = SearchSysCache1(FOREIGNSERVEROID, ObjectIdGetDatum(serverid));
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for foreign server %u", serverid);
     serverform = (Form_pg_foreign_server) GETSTRUCT(tp);
     fdwid = serverform->srvfdw;
     ReleaseSysCache(tp);
 
     /* Get handler function OID for the FDW. */
     tp = SearchSysCache1(FOREIGNDATAWRAPPEROID, ObjectIdGetDatum(fdwid));
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwid);
     fdwform = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
     fdwhandler = fdwform->fdwhandler;
 
     /* Complain if FDW has been set to NO HANDLER. */
     if (!OidIsValid(fdwhandler))
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("foreign-data wrapper \"%s\" has no handler",
                         NameStr(fdwform->fdwname))));
 
     ReleaseSysCache(tp);
 
     /* And finally, call the handler function. */
     return GetFdwRoutine(fdwhandler);
 }

FdwRoutine* GetFdwRoutineForRelation	(	Relation	relation,
		bool	makecopy
	)

Definition at line 395 of file foreign.c.

References CacheMemoryContext, GetFdwRoutineByRelId(), MemoryContextAlloc(), NULL, palloc(), RelationData::rd_fdwroutine, and RelationGetRelid.

Referenced by acquire_inherited_sample_rows(), analyze_rel(), CheckValidResultRel(), CheckValidRowMarkRel(), EvalPlanQualFetchRowMarks(), ExecInitForeignScan(), ExecLockRows(), get_relation_info(), InitResultRelInfo(), relation_is_updatable(), and rewriteTargetListUD().

 {
     FdwRoutine *fdwroutine;
     FdwRoutine *cfdwroutine;
 
     if (relation->rd_fdwroutine == NULL)
     {
         /* Get the info by consulting the catalogs and the FDW code */
         fdwroutine = GetFdwRoutineByRelId(RelationGetRelid(relation));
 
         /* Save the data for later reuse in CacheMemoryContext */
         cfdwroutine = (FdwRoutine *) MemoryContextAlloc(CacheMemoryContext,
                                                         sizeof(FdwRoutine));
         memcpy(cfdwroutine, fdwroutine, sizeof(FdwRoutine));
         relation->rd_fdwroutine = cfdwroutine;
 
         /* Give back the locally palloc'd copy regardless of makecopy */
         return fdwroutine;
     }
 
     /* We have valid cached data --- does the caller want a copy? */
     if (makecopy)
     {
         fdwroutine = (FdwRoutine *) palloc(sizeof(FdwRoutine));
         memcpy(fdwroutine, relation->rd_fdwroutine, sizeof(FdwRoutine));
         return fdwroutine;
     }
 
     /* Only a short-lived reference is needed, so just hand back cached copy */
     return relation->rd_fdwroutine;
 }

List* GetForeignColumnOptions	(	Oid	relid,
		AttrNumber	attnum
	)

Definition at line 254 of file foreign.c.

References Anum_pg_attribute_attfdwoptions, ATTNUM, elog, ERROR, HeapTupleIsValid, Int16GetDatum, NIL, ObjectIdGetDatum, options, ReleaseSysCache(), SearchSysCache2, SysCacheGetAttr(), and untransformRelOptions().

Referenced by deparseAnalyzeSql(), deparseColumnRef(), and get_file_fdw_attribute_options().

 {
     List       *options;
     HeapTuple   tp;
     Datum       datum;
     bool        isnull;
 
     tp = SearchSysCache2(ATTNUM,
                          ObjectIdGetDatum(relid),
                          Int16GetDatum(attnum));
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for attribute %d of relation %u",
              attnum, relid);
     datum = SysCacheGetAttr(ATTNUM,
                             tp,
                             Anum_pg_attribute_attfdwoptions,
                             &isnull);
     if (isnull)
         options = NIL;
     else
         options = untransformRelOptions(datum);
 
     ReleaseSysCache(tp);
 
     return options;
 }

ForeignDataWrapper* GetForeignDataWrapper ( Oid fdwid )

Definition at line 35 of file foreign.c.

References Anum_pg_foreign_data_wrapper_fdwoptions, elog, ERROR, ForeignDataWrapper::fdwhandler, ForeignDataWrapper::fdwid, ForeignDataWrapper::fdwname, ForeignDataWrapper::fdwvalidator, FOREIGNDATAWRAPPEROID, GETSTRUCT, HeapTupleIsValid, NameStr, NIL, ObjectIdGetDatum, ForeignDataWrapper::options, ForeignDataWrapper::owner, palloc(), pstrdup(), ReleaseSysCache(), SearchSysCache1, SysCacheGetAttr(), and untransformRelOptions().

Referenced by AlterForeignServer(), AlterForeignServerOwner_internal(), AlterUserMapping(), ATExecAlterColumnGenericOptions(), ATExecGenericOptions(), CreateForeignTable(), CreateUserMapping(), fileGetOptions(), get_connect_string(), GetForeignDataWrapperByName(), getObjectDescription(), getObjectIdentityParts(), and ImportForeignSchema().

 {
     Form_pg_foreign_data_wrapper fdwform;
     ForeignDataWrapper *fdw;
     Datum       datum;
     HeapTuple   tp;
     bool        isnull;
 
     tp = SearchSysCache1(FOREIGNDATAWRAPPEROID, ObjectIdGetDatum(fdwid));
 
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwid);
 
     fdwform = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
 
     fdw = (ForeignDataWrapper *) palloc(sizeof(ForeignDataWrapper));
     fdw->fdwid = fdwid;
     fdw->owner = fdwform->fdwowner;
     fdw->fdwname = pstrdup(NameStr(fdwform->fdwname));
     fdw->fdwhandler = fdwform->fdwhandler;
     fdw->fdwvalidator = fdwform->fdwvalidator;
 
     /* Extract the fdwoptions */
     datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
                             tp,
                             Anum_pg_foreign_data_wrapper_fdwoptions,
                             &isnull);
     if (isnull)
         fdw->options = NIL;
     else
         fdw->options = untransformRelOptions(datum);
 
     ReleaseSysCache(tp);
 
     return fdw;
 }

ForeignDataWrapper* GetForeignDataWrapperByName	(	const char *	fdwname,
		bool	missing_ok
	)

Definition at line 78 of file foreign.c.

References get_foreign_data_wrapper_oid(), GetForeignDataWrapper(), NULL, and OidIsValid.

Referenced by CreateForeignDataWrapper(), and CreateForeignServer().

 {
     Oid         fdwId = get_foreign_data_wrapper_oid(fdwname, missing_ok);
 
     if (!OidIsValid(fdwId))
         return NULL;
 
     return GetForeignDataWrapper(fdwId);
 }

ForeignServer* GetForeignServer ( Oid serverid )

Definition at line 93 of file foreign.c.

References Anum_pg_foreign_server_srvoptions, Anum_pg_foreign_server_srvtype, Anum_pg_foreign_server_srvversion, elog, ERROR, ForeignServer::fdwid, FOREIGNSERVEROID, GETSTRUCT, HeapTupleIsValid, NameStr, NIL, NULL, ObjectIdGetDatum, ForeignServer::options, ForeignServer::owner, palloc(), pstrdup(), ReleaseSysCache(), SearchSysCache1, ForeignServer::serverid, ForeignServer::servername, ForeignServer::servertype, ForeignServer::serverversion, SysCacheGetAttr(), TextDatumGetCString, and untransformRelOptions().

Referenced by ATExecAlterColumnGenericOptions(), ATExecGenericOptions(), fileGetOptions(), GetConnection(), GetForeignServerByName(), getObjectDescription(), getObjectIdentityParts(), pgfdw_reject_incomplete_xact_state_change(), postgresAcquireSampleRowsFunc(), postgresGetForeignRelSize(), postgresImportForeignSchema(), and postgresIsForeignRelUpdatable().

 {
     Form_pg_foreign_server serverform;
     ForeignServer *server;
     HeapTuple   tp;
     Datum       datum;
     bool        isnull;
 
     tp = SearchSysCache1(FOREIGNSERVEROID, ObjectIdGetDatum(serverid));
 
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for foreign server %u", serverid);
 
     serverform = (Form_pg_foreign_server) GETSTRUCT(tp);
 
     server = (ForeignServer *) palloc(sizeof(ForeignServer));
     server->serverid = serverid;
     server->servername = pstrdup(NameStr(serverform->srvname));
     server->owner = serverform->srvowner;
     server->fdwid = serverform->srvfdw;
 
     /* Extract server type */
     datum = SysCacheGetAttr(FOREIGNSERVEROID,
                             tp,
                             Anum_pg_foreign_server_srvtype,
                             &isnull);
     server->servertype = isnull ? NULL : TextDatumGetCString(datum);
 
     /* Extract server version */
     datum = SysCacheGetAttr(FOREIGNSERVEROID,
                             tp,
                             Anum_pg_foreign_server_srvversion,
                             &isnull);
     server->serverversion = isnull ? NULL : TextDatumGetCString(datum);
 
     /* Extract the srvoptions */
     datum = SysCacheGetAttr(FOREIGNSERVEROID,
                             tp,
                             Anum_pg_foreign_server_srvoptions,
                             &isnull);
     if (isnull)
         server->options = NIL;
     else
         server->options = untransformRelOptions(datum);
 
     ReleaseSysCache(tp);
 
     return server;
 }

ForeignServer* GetForeignServerByName	(	const char *	srvname,
		bool	missing_ok
	)

Definition at line 148 of file foreign.c.

References get_foreign_server_oid(), GetForeignServer(), NULL, and OidIsValid.

Referenced by AlterUserMapping(), CreateForeignServer(), CreateForeignTable(), CreateUserMapping(), get_connect_string(), get_object_address_usermapping(), ImportForeignSchema(), and RemoveUserMapping().

 {
     Oid         serverid = get_foreign_server_oid(srvname, missing_ok);
 
     if (!OidIsValid(serverid))
         return NULL;
 
     return GetForeignServer(serverid);
 }

Oid GetForeignServerIdByRelId ( Oid relid )

Definition at line 308 of file foreign.c.

References elog, ERROR, FOREIGNTABLEREL, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum, ReleaseSysCache(), and SearchSysCache1.

Referenced by get_relation_info(), and GetFdwRoutineByRelId().

 {
     HeapTuple   tp;
     Form_pg_foreign_table tableform;
     Oid         serverid;
 
     tp = SearchSysCache1(FOREIGNTABLEREL, ObjectIdGetDatum(relid));
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for foreign table %u", relid);
     tableform = (Form_pg_foreign_table) GETSTRUCT(tp);
     serverid = tableform->ftserver;
     ReleaseSysCache(tp);
 
     return serverid;
 }

ForeignTable* GetForeignTable ( Oid relid )

Definition at line 216 of file foreign.c.

References Anum_pg_foreign_table_ftoptions, elog, ERROR, FOREIGNTABLEREL, GETSTRUCT, HeapTupleIsValid, NIL, ObjectIdGetDatum, ForeignTable::options, palloc(), ReleaseSysCache(), ForeignTable::relid, SearchSysCache1, ForeignTable::serverid, SysCacheGetAttr(), and untransformRelOptions().

Referenced by check_selective_binary_conversion(), deparseRelation(), fileGetOptions(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignModify(), postgresBeginForeignScan(), postgresGetForeignRelSize(), and postgresIsForeignRelUpdatable().

 {
     Form_pg_foreign_table tableform;
     ForeignTable *ft;
     HeapTuple   tp;
     Datum       datum;
     bool        isnull;
 
     tp = SearchSysCache1(FOREIGNTABLEREL, ObjectIdGetDatum(relid));
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for foreign table %u", relid);
     tableform = (Form_pg_foreign_table) GETSTRUCT(tp);
 
     ft = (ForeignTable *) palloc(sizeof(ForeignTable));
     ft->relid = relid;
     ft->serverid = tableform->ftserver;
 
     /* Extract the ftoptions */
     datum = SysCacheGetAttr(FOREIGNTABLEREL,
                             tp,
                             Anum_pg_foreign_table_ftoptions,
                             &isnull);
     if (isnull)
         ft->options = NIL;
     else
         ft->options = untransformRelOptions(datum);
 
     ReleaseSysCache(tp);
 
     return ft;
 }

UserMapping* GetUserMapping	(	Oid	userid,
		Oid	serverid
	)

Definition at line 166 of file foreign.c.

References Anum_pg_user_mapping_umoptions, ereport, errcode(), errmsg(), ERROR, HeapTupleGetOid, HeapTupleIsValid, InvalidOid, MappingUserName, NIL, ObjectIdGetDatum, UserMapping::options, palloc(), ReleaseSysCache(), SearchSysCache2, UserMapping::serverid, SysCacheGetAttr(), UserMapping::umid, untransformRelOptions(), and UserMapping::userid.

Referenced by get_connect_string(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignModify(), postgresBeginForeignScan(), postgresGetForeignRelSize(), and postgresImportForeignSchema().

 {
     Datum       datum;
     HeapTuple   tp;
     bool        isnull;
     UserMapping *um;
 
     tp = SearchSysCache2(USERMAPPINGUSERSERVER,
                          ObjectIdGetDatum(userid),
                          ObjectIdGetDatum(serverid));
 
     if (!HeapTupleIsValid(tp))
     {
         /* Not found for the specific user -- try PUBLIC */
         tp = SearchSysCache2(USERMAPPINGUSERSERVER,
                              ObjectIdGetDatum(InvalidOid),
                              ObjectIdGetDatum(serverid));
     }
 
     if (!HeapTupleIsValid(tp))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("user mapping not found for \"%s\"",
                         MappingUserName(userid))));
 
     um = (UserMapping *) palloc(sizeof(UserMapping));
     um->umid = HeapTupleGetOid(tp);
     um->userid = userid;
     um->serverid = serverid;
 
     /* Extract the umoptions */
     datum = SysCacheGetAttr(USERMAPPINGUSERSERVER,
                             tp,
                             Anum_pg_user_mapping_umoptions,
                             &isnull);
     if (isnull)
         um->options = NIL;
     else
         um->options = untransformRelOptions(datum);
 
     ReleaseSysCache(tp);
 
     return um;
 }

static bool is_conninfo_option	(	const char *	option,
		Oid	context
	)

static

Definition at line 588 of file foreign.c.

References ConnectionOption::optcontext, and ConnectionOption::optname.

Referenced by postgresql_fdw_validator().

 {
     struct ConnectionOption *opt;
 
     for (opt = libpq_conninfo_options; opt->optname; opt++)
         if (context == opt->optcontext && strcmp(opt->optname, option) == 0)
             return true;
     return false;
 }

bool IsImportableForeignTable	(	const char *	tablename,
		ImportForeignSchemaStmt *	stmt
	)

Definition at line 435 of file foreign.c.

References FDW_IMPORT_SCHEMA_ALL, FDW_IMPORT_SCHEMA_EXCEPT, FDW_IMPORT_SCHEMA_LIMIT_TO, lfirst, ImportForeignSchemaStmt::list_type, RangeVar::relname, and ImportForeignSchemaStmt::table_list.

Referenced by ImportForeignSchema().

 {
     ListCell   *lc;
 
     switch (stmt->list_type)
     {
         case FDW_IMPORT_SCHEMA_ALL:
             return true;
 
         case FDW_IMPORT_SCHEMA_LIMIT_TO:
             foreach(lc, stmt->table_list)
             {
                 RangeVar   *rv = (RangeVar *) lfirst(lc);
 
                 if (strcmp(tablename, rv->relname) == 0)
                     return true;
             }
             return false;
 
         case FDW_IMPORT_SCHEMA_EXCEPT:
             foreach(lc, stmt->table_list)
             {
                 RangeVar   *rv = (RangeVar *) lfirst(lc);
 
                 if (strcmp(tablename, rv->relname) == 0)
                     return false;
             }
             return true;
     }
     return false;               /* shouldn't get here */
 }

Datum pg_options_to_table ( PG_FUNCTION_ARGS )

Definition at line 538 of file foreign.c.

References deflist_to_tuplestore(), PG_GETARG_DATUM, and untransformRelOptions().

 {
     Datum       array = PG_GETARG_DATUM(0);
 
     deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo,
                           untransformRelOptions(array));
 
     return (Datum) 0;
 }

Datum postgresql_fdw_validator ( PG_FUNCTION_ARGS )

Definition at line 612 of file foreign.c.

References appendStringInfo(), buf, StringInfoData::data, DefElem::defname, ereport, errcode(), errhint(), errmsg(), ERROR, initStringInfo(), is_conninfo_option(), StringInfoData::len, lfirst, ConnectionOption::optcontext, ConnectionOption::optname, PG_GETARG_DATUM, PG_GETARG_OID, PG_RETURN_BOOL, and untransformRelOptions().

 {
     List       *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
     Oid         catalog = PG_GETARG_OID(1);
 
     ListCell   *cell;
 
     foreach(cell, options_list)
     {
         DefElem    *def = lfirst(cell);
 
         if (!is_conninfo_option(def->defname, catalog))
         {
             struct ConnectionOption *opt;
             StringInfoData buf;
 
             /*
              * Unknown option specified, complain about it. Provide a hint
              * with list of valid options for the object.
              */
             initStringInfo(&buf);
             for (opt = libpq_conninfo_options; opt->optname; opt++)
                 if (catalog == opt->optcontext)
                     appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "",
                                      opt->optname);
 
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("invalid option \"%s\"", def->defname),
                      errhint("Valid options in this context are: %s",
                              buf.data)));
 
             PG_RETURN_BOOL(false);
         }
     }
 
     PG_RETURN_BOOL(true);
 }

Variable Documentation

struct ConnectionOption libpq_conninfo_options[]

static

Initial value:

= {
    {"authtype", ForeignServerRelationId},
    {"service", ForeignServerRelationId},
    {"user", UserMappingRelationId},
    {"password", UserMappingRelationId},
    {"connect_timeout", ForeignServerRelationId},
    {"dbname", ForeignServerRelationId},
    {"host", ForeignServerRelationId},
    {"hostaddr", ForeignServerRelationId},
    {"port", ForeignServerRelationId},
    {"tty", ForeignServerRelationId},
    {"options", ForeignServerRelationId},
    {"requiressl", ForeignServerRelationId},
    {"sslmode", ForeignServerRelationId},
    {"gsslib", ForeignServerRelationId},
    {NULL, InvalidOid}
}

Definition at line 563 of file foreign.c.

Data Structures

Functions

Variables

Function Documentation

Variable Documentation