foreign.c File Reference

#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 "funcapi.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 "utils/varlena.h"

Include dependency graph for foreign.c:

Go to the source code of this file.

Data Structures
struct	ConnectionOption

Functions
ForeignDataWrapper *	GetForeignDataWrapper (Oid fdwid)
ForeignDataWrapper *	GetForeignDataWrapperExtended (Oid fdwid, bits16 flags)
ForeignDataWrapper *	GetForeignDataWrapperByName (const char *fdwname, bool missing_ok)
ForeignServer *	GetForeignServer (Oid serverid)
ForeignServer *	GetForeignServerExtended (Oid serverid, bits16 flags)
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)
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 const struct ConnectionOption	libpq_conninfo_options []

Function Documentation

get_foreign_data_wrapper_oid()

Oid get_foreign_data_wrapper_oid	(	const char *	fdwname,
		bool	missing_ok
	)

Definition at line 667 of file foreign.c.

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

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

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

get_foreign_server_oid()

Oid get_foreign_server_oid	(	const char *	servername,
		bool	missing_ok
	)

Definition at line 690 of file foreign.c.

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

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

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

GetExistingLocalJoinPath()

Path* GetExistingLocalJoinPath

(

RelOptInfo *

joinrel

)

Definition at line 727 of file foreign.c.

{
    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;
}

References Assert(), ForeignPath::fdw_outerpath, if(), JoinPath::innerjoinpath, IS_JOIN_REL, IsA, lfirst, makeNode, JoinPath::outerjoinpath, ForeignPath::path, RelOptInfo::pathlist, and Path::pathtype.

Referenced by postgresGetForeignJoinPaths().

GetFdwRoutine()

FdwRoutine* GetFdwRoutine

(

Oid

fdwhandler

)

Definition at line 321 of file foreign.c.

{
    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;
}

References DatumGetPointer(), elog(), ERROR, IsA, and OidFunctionCall0.

Referenced by GetFdwRoutineByServerId(), and ImportForeignSchema().

GetFdwRoutineByRelId()

FdwRoutine* GetFdwRoutineByRelId

(

Oid

relid

)

Definition at line 406 of file foreign.c.

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

References GetFdwRoutineByServerId(), and GetForeignServerIdByRelId().

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

GetFdwRoutineByServerId()

FdwRoutine* GetFdwRoutineByServerId

(

Oid

serverid

)

Definition at line 364 of file foreign.c.

{
    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);
}

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

Referenced by ExecInitForeignScan(), ExecuteTruncateGuts(), GetFdwRoutineByRelId(), and truncate_check_rel().

GetFdwRoutineForRelation()

FdwRoutine* GetFdwRoutineForRelation	(	Relation	relation,
		bool	makecopy
	)

Definition at line 429 of file foreign.c.

{
    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;
}

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

Referenced by acquire_inherited_sample_rows(), add_row_identity_columns(), analyze_rel(), CheckValidRowMarkRel(), EvalPlanQualFetchRowMark(), ExecInitForeignScan(), ExecLockRows(), get_relation_info(), InitResultRelInfo(), and relation_is_updatable().

GetForeignColumnOptions()

List* GetForeignColumnOptions	(	Oid	relid,
		AttrNumber	attnum
	)

Definition at line 288 of file foreign.c.

{
    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;
}

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

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

GetForeignDataWrapper()

ForeignDataWrapper* GetForeignDataWrapper

(

Oid

fdwid

)

Definition at line 37 of file foreign.c.

{
    return GetForeignDataWrapperExtended(fdwid, 0);
}

References GetForeignDataWrapperExtended().

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

GetForeignDataWrapperByName()

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

Definition at line 96 of file foreign.c.

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

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

Referenced by CreateForeignDataWrapper(), and CreateForeignServer().

GetForeignDataWrapperExtended()

ForeignDataWrapper* GetForeignDataWrapperExtended	(	Oid	fdwid,
		bits16	flags
	)

Definition at line 49 of file foreign.c.

{
    Form_pg_foreign_data_wrapper fdwform;
    ForeignDataWrapper *fdw;
    Datum       datum;
    HeapTuple   tp;
    bool        isnull;
 
    tp = SearchSysCache1(FOREIGNDATAWRAPPEROID, ObjectIdGetDatum(fdwid));
 
    if (!HeapTupleIsValid(tp))
    {
        if ((flags & FDW_MISSING_OK) == 0)
            elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwid);
        return NULL;
    }
 
    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;
}

References elog(), ERROR, FDW_MISSING_OK, 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 GetForeignDataWrapper(), getObjectDescription(), and getObjectIdentityParts().

GetForeignServer()

ForeignServer* GetForeignServer

(

Oid

serverid

)

Definition at line 111 of file foreign.c.

{
    return GetForeignServerExtended(serverid, 0);
}

References GetForeignServerExtended().

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

GetForeignServerByName()

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

Definition at line 182 of file foreign.c.

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

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

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

GetForeignServerExtended()

ForeignServer* GetForeignServerExtended	(	Oid	serverid,
		bits16	flags
	)

Definition at line 123 of file foreign.c.

{
    Form_pg_foreign_server serverform;
    ForeignServer *server;
    HeapTuple   tp;
    Datum       datum;
    bool        isnull;
 
    tp = SearchSysCache1(FOREIGNSERVEROID, ObjectIdGetDatum(serverid));
 
    if (!HeapTupleIsValid(tp))
    {
        if ((flags & FSV_MISSING_OK) == 0)
            elog(ERROR, "cache lookup failed for foreign server %u", serverid);
        return NULL;
    }
 
    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;
}

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

Referenced by disconnect_cached_connections(), GetForeignServer(), getObjectDescription(), getObjectIdentityParts(), and postgres_fdw_get_connections().

GetForeignServerIdByRelId()

Oid GetForeignServerIdByRelId

(

Oid

relid

)

Definition at line 342 of file foreign.c.

{
    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;
}

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

Referenced by ExecuteTruncateGuts(), get_relation_info(), GetFdwRoutineByRelId(), and truncate_check_rel().

GetForeignTable()

ForeignTable* GetForeignTable

(

Oid

relid

)

Definition at line 250 of file foreign.c.

{
    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;
}

References 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(), create_foreign_modify(), deparseRelation(), fileGetOptions(), get_batch_size_option(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignScan(), postgresExecForeignTruncate(), postgresGetAnalyzeInfoForForeignTable(), postgresGetForeignRelSize(), and postgresIsForeignRelUpdatable().

GetUserMapping()

UserMapping* GetUserMapping	(	Oid	userid,
		Oid	serverid
	)

Definition at line 200 of file foreign.c.

{
    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 = ((Form_pg_user_mapping) GETSTRUCT(tp))->oid;
    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;
}

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

Referenced by create_foreign_modify(), get_connect_string(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignScan(), postgresExecForeignTruncate(), postgresGetAnalyzeInfoForForeignTable(), postgresGetForeignRelSize(), and postgresImportForeignSchema().

is_conninfo_option()

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

static

Definition at line 587 of file foreign.c.

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

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

Referenced by postgresql_fdw_validator().

IsImportableForeignTable()

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

Definition at line 469 of file foreign.c.

{
    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 */
}

References FDW_IMPORT_SCHEMA_ALL, FDW_IMPORT_SCHEMA_EXCEPT, FDW_IMPORT_SCHEMA_LIMIT_TO, lfirst, RangeVar::relname, and stmt.

Referenced by ImportForeignSchema().

pg_options_to_table()

Datum pg_options_to_table

(

PG_FUNCTION_ARGS

)

Definition at line 509 of file foreign.c.

{
    Datum       array = PG_GETARG_DATUM(0);
    ListCell   *cell;
    List       *options;
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 
    options = untransformRelOptions(array);
    rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 
    /* prepare the result set */
    InitMaterializedSRF(fcinfo, MAT_SRF_USE_EXPECTED_DESC);
 
    foreach(cell, options)
    {
        DefElem    *def = lfirst(cell);
        Datum       values[2];
        bool        nulls[2];
 
        values[0] = CStringGetTextDatum(def->defname);
        nulls[0] = false;
        if (def->arg)
        {
            values[1] = CStringGetTextDatum(strVal(def->arg));
            nulls[1] = false;
        }
        else
        {
            values[1] = (Datum) 0;
            nulls[1] = true;
        }
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
    return (Datum) 0;
}

postgresql_fdw_validator()

Datum postgresql_fdw_validator

(

PG_FUNCTION_ARGS

)

Definition at line 611 of file foreign.c.

{
    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))
        {
            const struct ConnectionOption *opt;
            const char *closest_match;
            ClosestMatchState match_state;
            bool        has_valid_options = false;
 
            /*
             * Unknown option specified, complain about it. Provide a hint
             * with a valid option that looks similar, if there is one.
             */
            initClosestMatch(&match_state, def->defname, 4);
            for (opt = libpq_conninfo_options; opt->optname; opt++)
            {
                if (catalog == opt->optcontext)
                {
                    has_valid_options = true;
                    updateClosestMatch(&match_state, opt->optname);
                }
            }
 
            closest_match = getClosestMatch(&match_state);
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("invalid option \"%s\"", def->defname),
                     has_valid_options ? closest_match ?
                     errhint("Perhaps you meant the option \"%s\".",
                             closest_match) : 0 :
                     errhint("There are no valid options in this context.")));
 
            PG_RETURN_BOOL(false);
        }
    }
 
    PG_RETURN_BOOL(true);
}

References DefElem::defname, ereport, errcode(), errhint(), errmsg(), ERROR, getClosestMatch(), initClosestMatch(), is_conninfo_option(), lfirst, libpq_conninfo_options, match_state, ConnectionOption::optcontext, ConnectionOption::optname, PG_GETARG_DATUM, PG_GETARG_OID, PG_RETURN_BOOL, untransformRelOptions(), and updateClosestMatch().

Variable Documentation

libpq_conninfo_options

const 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 509 of file foreign.c.

Referenced by is_conninfo_option(), and postgresql_fdw_validator().