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 "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:

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)
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 const struct ConnectionOption	libpq_conninfo_options []

Function Documentation

deflist_to_tuplestore()

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

static

Definition at line 506 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(), ReturnSetInfo::returnMode, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, strVal, 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(strVal(def->arg));
            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);
}

get_foreign_data_wrapper_oid()

Oid get_foreign_data_wrapper_oid	(	const char *	fdwname,
		bool	missing_ok
	)

Definition at line 691 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,
                          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;
}

get_foreign_server_oid()

Oid get_foreign_server_oid	(	const char *	servername,
		bool	missing_ok
	)

Definition at line 714 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, 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;
}

GetExistingLocalJoinPath()

Path* GetExistingLocalJoinPath

(

RelOptInfo *

joinrel

)

Definition at line 751 of file foreign.c.

References Assert, ForeignPath::fdw_outerpath, JoinPath::innerjoinpath, IS_JOIN_REL, IsA, lfirst, makeNode, 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;
}

GetFdwRoutine()

FdwRoutine* GetFdwRoutine

(

Oid

fdwhandler

)

Definition at line 319 of file foreign.c.

References DatumGetPointer, elog, ERROR, IsA, 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;
}

GetFdwRoutineByRelId()

FdwRoutine* GetFdwRoutineByRelId

(

Oid

relid

)

Definition at line 404 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);
}

GetFdwRoutineByServerId()

FdwRoutine* GetFdwRoutineByServerId

(

Oid

serverid

)

Definition at line 362 of file foreign.c.

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().

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

GetFdwRoutineForRelation()

FdwRoutine* GetFdwRoutineForRelation	(	Relation	relation,
		bool	makecopy
	)

Definition at line 427 of file foreign.c.

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().

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

GetForeignColumnOptions()

List* GetForeignColumnOptions	(	Oid	relid,
		AttrNumber	attnum
	)

Definition at line 286 of file foreign.c.

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

GetForeignDataWrapper()

ForeignDataWrapper* GetForeignDataWrapper

(

Oid

fdwid

)

Definition at line 35 of file foreign.c.

References GetForeignDataWrapperExtended().

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

{
    return GetForeignDataWrapperExtended(fdwid, 0);
}

GetForeignDataWrapperByName()

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

Definition at line 94 of file foreign.c.

References get_foreign_data_wrapper_oid(), GetForeignDataWrapper(), 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);
}

GetForeignDataWrapperExtended()

ForeignDataWrapper* GetForeignDataWrapperExtended	(	Oid	fdwid,
		bits16	flags
	)

Definition at line 47 of file foreign.c.

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().

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

GetForeignServer()

ForeignServer* GetForeignServer

(

Oid

serverid

)

Definition at line 109 of file foreign.c.

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().

{
    return GetForeignServerExtended(serverid, 0);
}

GetForeignServerByName()

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

Definition at line 180 of file foreign.c.

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

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

{
    Oid         serverid = get_foreign_server_oid(srvname, missing_ok);

    if (!OidIsValid(serverid))
        return NULL;

    return GetForeignServer(serverid);
}

GetForeignServerExtended()

ForeignServer* GetForeignServerExtended	(	Oid	serverid,
		bits16	flags
	)

Definition at line 121 of file foreign.c.

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().

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

GetForeignServerIdByRelId()

Oid GetForeignServerIdByRelId

(

Oid

relid

)

Definition at line 340 of file foreign.c.

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

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

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

GetForeignTable()

ForeignTable* GetForeignTable

(

Oid

relid

)

Definition at line 248 of file foreign.c.

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(), 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;
}

GetUserMapping()

UserMapping* GetUserMapping	(	Oid	userid,
		Oid	serverid
	)

Definition at line 198 of file foreign.c.

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(), 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 = ((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;
}

is_conninfo_option()

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

static

Definition at line 620 of file foreign.c.

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

Referenced by postgresql_fdw_validator().

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

IsImportableForeignTable()

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

Definition at line 467 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 */
}

pg_options_to_table()

Datum pg_options_to_table

(

PG_FUNCTION_ARGS

)

Definition at line 570 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;
}

postgresql_fdw_validator()

Datum postgresql_fdw_validator

(

PG_FUNCTION_ARGS

)

Definition at line 644 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))
        {
            const 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

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