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 "miscadmin.h"
#include "optimizer/paths.h"
#include "tcop/tcopprot.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 682 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, GetSysCacheOid1, and OidIsValid.

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

get_foreign_server_oid()

Oid get_foreign_server_oid	(	const char *	servername,
		bool	missing_ok
	)

Definition at line 705 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, GetSysCacheOid1, and OidIsValid.

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

GetExistingLocalJoinPath()

Path * GetExistingLocalJoinPath

(

RelOptInfo *

joinrel

)

Definition at line 742 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 (joinpath->path.pathtype == T_MergeJoin)
                {
                    MergePath  *merge_path = (MergePath *) joinpath;
 
                    /*
                     * If the new outer path is already well enough ordered
                     * for the mergejoin, we can skip doing an explicit sort.
                     */
                    if (merge_path->outersortkeys &&
                        pathkeys_count_contained_in(merge_path->outersortkeys,
                                                    joinpath->outerjoinpath->pathkeys,
                                                    &merge_path->outer_presorted_keys))
                        merge_path->outersortkeys = NIL;
                }
            }
        }
 
        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;
 
                if (joinpath->path.pathtype == T_MergeJoin)
                {
                    MergePath  *merge_path = (MergePath *) joinpath;
 
                    /*
                     * If the new inner path is already well enough ordered
                     * for the mergejoin, we can skip doing an explicit sort.
                     */
                    if (merge_path->innersortkeys &&
                        pathkeys_contained_in(merge_path->innersortkeys,
                                              joinpath->innerjoinpath->pathkeys))
                        merge_path->innersortkeys = NIL;
                }
            }
        }
 
        return (Path *) joinpath;
    }
    return NULL;
}

References Assert(), ForeignPath::fdw_outerpath, if(), JoinPath::innerjoinpath, MergePath::innersortkeys, IS_JOIN_REL, IsA, lfirst, makeNode, NIL, MergePath::outer_presorted_keys, JoinPath::outerjoinpath, MergePath::outersortkeys, ForeignPath::path, Path::pathkeys, pathkeys_contained_in(), pathkeys_count_contained_in(), RelOptInfo::pathlist, and Path::pathtype.

Referenced by postgresGetForeignJoinPaths().

GetFdwRoutine()

FdwRoutine * GetFdwRoutine

(

Oid

fdwhandler

)

Definition at line 326 of file foreign.c.

{
    Datum       datum;
    FdwRoutine *routine;
 
    /* Check if the access to foreign tables is restricted */
    if (unlikely((restrict_nonsystem_relation_kind & RESTRICT_RELKIND_FOREIGN_TABLE) != 0))
    {
        /* there must not be built-in FDW handler  */
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("access to non-system foreign table is restricted")));
    }
 
    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, ereport, errcode(), errmsg(), ERROR, IsA, OidFunctionCall0, restrict_nonsystem_relation_kind, RESTRICT_RELKIND_FOREIGN_TABLE, and unlikely.

Referenced by GetFdwRoutineByServerId(), and ImportForeignSchema().

GetFdwRoutineByRelId()

FdwRoutine * GetFdwRoutineByRelId

(

Oid

relid

)

Definition at line 420 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 378 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, 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 443 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 293 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, 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 38 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 97 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 50 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, 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 112 of file foreign.c.

{
    return GetForeignServerExtended(serverid, 0);
}

References GetForeignServerExtended().

Referenced by ATExecAlterColumnGenericOptions(), ATExecGenericOptions(), fileGetOptions(), get_batch_size_option(), GetForeignServerByName(), getObjectDescription(), getObjectIdentityParts(), GetUserMapping(), 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 183 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 124 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, 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_internal().

GetForeignServerIdByRelId()

Oid GetForeignServerIdByRelId

(

Oid

relid

)

Definition at line 356 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, 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 255 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, 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 201 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))
    {
        ForeignServer *server = GetForeignServer(serverid);
 
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("user mapping not found for user \"%s\", server \"%s\"",
                        MappingUserName(userid), server->servername)));
    }
 
    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, GetForeignServer(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, MappingUserName, NIL, ObjectIdGetDatum(), UserMapping::options, palloc(), ReleaseSysCache(), SearchSysCache2(), UserMapping::serverid, ForeignServer::servername, 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 602 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 483 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 523 of file foreign.c.

{
    Datum       array = PG_GETARG_DATUM(0);
    ListCell   *cell;
    List       *options;
    ReturnSetInfo *rsinfo;
 
    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;
}

References DefElem::arg, CStringGetTextDatum, DefElem::defname, InitMaterializedSRF(), lfirst, MAT_SRF_USE_EXPECTED_DESC, options, PG_GETARG_DATUM, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, strVal, tuplestore_putvalues(), untransformRelOptions(), and values.

postgresql_fdw_validator()

Datum postgresql_fdw_validator

(

PG_FUNCTION_ARGS

)

Definition at line 626 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},
    {"gssdelegation", ForeignServerRelationId},
    {NULL, InvalidOid}
}

Definition at line 576 of file foreign.c.

Referenced by is_conninfo_option(), and postgresql_fdw_validator().