option.c File Reference

#include "postgres.h"
#include "access/reloptions.h"
#include "catalog/pg_foreign_server.h"
#include "catalog/pg_foreign_table.h"
#include "catalog/pg_user_mapping.h"
#include "commands/defrem.h"
#include "commands/extension.h"
#include "postgres_fdw.h"
#include "utils/builtins.h"
#include "utils/varlena.h"
#include "miscadmin.h"

Include dependency graph for option.c:

Go to the source code of this file.

Data Structures
struct	PgFdwOption

Typedefs
typedef struct PgFdwOption	PgFdwOption

Functions
static void	InitPgFdwOptions (void)
static bool	is_valid_option (const char *keyword, Oid context)
static bool	is_libpq_option (const char *keyword)
	PG_FUNCTION_INFO_V1 (postgres_fdw_validator)
Datum	postgres_fdw_validator (PG_FUNCTION_ARGS)
int	ExtractConnectionOptions (List *defelems, const char **keywords, const char **values)
List *	ExtractExtensionList (const char *extensionsString, bool warnOnMissing)

Variables
static PgFdwOption *	postgres_fdw_options
static PQconninfoOption *	libpq_options

Typedef Documentation

PgFdwOption

typedef struct PgFdwOption PgFdwOption

Function Documentation

ExtractConnectionOptions()

int ExtractConnectionOptions	(	List *	defelems,
		const char **	keywords,
		const char **	values
	)

Definition at line 347 of file option.c.

References defGetString(), DefElem::defname, i, InitPgFdwOptions(), is_libpq_option(), and lfirst.

Referenced by connect_pg_server().

{
    ListCell   *lc;
    int         i;

    /* Build our options lists if we didn't yet. */
    InitPgFdwOptions();

    i = 0;
    foreach(lc, defelems)
    {
        DefElem    *d = (DefElem *) lfirst(lc);

        if (is_libpq_option(d->defname))
        {
            keywords[i] = d->defname;
            values[i] = defGetString(d);
            i++;
        }
    }
    return i;
}

ExtractExtensionList()

List* ExtractExtensionList	(	const char *	extensionsString,
		bool	warnOnMissing
	)

Definition at line 378 of file option.c.

References ereport, errcode(), errmsg(), ERROR, get_extension_oid(), lappend_oid(), lfirst, list_free(), NIL, OidIsValid, pstrdup(), SplitIdentifierString(), and WARNING.

Referenced by apply_server_options(), and postgres_fdw_validator().

{
    List       *extensionOids = NIL;
    List       *extlist;
    ListCell   *lc;

    /* SplitIdentifierString scribbles on its input, so pstrdup first */
    if (!SplitIdentifierString(pstrdup(extensionsString), ',', &extlist))
    {
        /* syntax error in name list */
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("parameter \"%s\" must be a list of extension names",
                        "extensions")));
    }

    foreach(lc, extlist)
    {
        const char *extension_name = (const char *) lfirst(lc);
        Oid         extension_oid = get_extension_oid(extension_name, true);

        if (OidIsValid(extension_oid))
        {
            extensionOids = lappend_oid(extensionOids, extension_oid);
        }
        else if (warnOnMissing)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("extension \"%s\" is not installed",
                            extension_name)));
        }
    }

    list_free(extlist);
    return extensionOids;
}

InitPgFdwOptions()

static void InitPgFdwOptions ( void  )

static

Definition at line 192 of file option.c.

References _PQconninfoOption::dispchar, ereport, errcode(), errdetail(), errmsg(), ERROR, InvalidOid, PgFdwOption::is_libpq_opt, PgFdwOption::keyword, _PQconninfoOption::keyword, malloc, PgFdwOption::optcontext, postgres_fdw_options, and PQconndefaults().

Referenced by ExtractConnectionOptions(), and postgres_fdw_validator().

{
    int         num_libpq_opts;
    PQconninfoOption *lopt;
    PgFdwOption *popt;

    /* non-libpq FDW-specific FDW options */
    static const PgFdwOption non_libpq_options[] = {
        {"schema_name", ForeignTableRelationId, false},
        {"table_name", ForeignTableRelationId, false},
        {"column_name", AttributeRelationId, false},
        /* use_remote_estimate is available on both server and table */
        {"use_remote_estimate", ForeignServerRelationId, false},
        {"use_remote_estimate", ForeignTableRelationId, false},
        /* cost factors */
        {"fdw_startup_cost", ForeignServerRelationId, false},
        {"fdw_tuple_cost", ForeignServerRelationId, false},
        /* shippable extensions */
        {"extensions", ForeignServerRelationId, false},
        /* updatable is available on both server and table */
        {"updatable", ForeignServerRelationId, false},
        {"updatable", ForeignTableRelationId, false},
        /* fetch_size is available on both server and table */
        {"fetch_size", ForeignServerRelationId, false},
        {"fetch_size", ForeignTableRelationId, false},
        /* batch_size is available on both server and table */
        {"batch_size", ForeignServerRelationId, false},
        {"batch_size", ForeignTableRelationId, false},
        {"password_required", UserMappingRelationId, false},

        /*
         * sslcert and sslkey are in fact libpq options, but we repeat them
         * here to allow them to appear in both foreign server context (when
         * we generate libpq options) and user mapping context (from here).
         */
        {"sslcert", UserMappingRelationId, true},
        {"sslkey", UserMappingRelationId, true},

        {NULL, InvalidOid, false}
    };

    /* Prevent redundant initialization. */
    if (postgres_fdw_options)
        return;

    /*
     * Get list of valid libpq options.
     *
     * To avoid unnecessary work, we get the list once and use it throughout
     * the lifetime of this backend process.  We don't need to care about
     * memory context issues, because PQconndefaults allocates with malloc.
     */
    libpq_options = PQconndefaults();
    if (!libpq_options)         /* assume reason for failure is OOM */
        ereport(ERROR,
                (errcode(ERRCODE_FDW_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Could not get libpq's default connection options.")));

    /* Count how many libpq options are available. */
    num_libpq_opts = 0;
    for (lopt = libpq_options; lopt->keyword; lopt++)
        num_libpq_opts++;

    /*
     * Construct an array which consists of all valid options for
     * postgres_fdw, by appending FDW-specific options to libpq options.
     *
     * We use plain malloc here to allocate postgres_fdw_options because it
     * lives as long as the backend process does.  Besides, keeping
     * libpq_options in memory allows us to avoid copying every keyword
     * string.
     */
    postgres_fdw_options = (PgFdwOption *)
        malloc(sizeof(PgFdwOption) * num_libpq_opts +
               sizeof(non_libpq_options));
    if (postgres_fdw_options == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FDW_OUT_OF_MEMORY),
                 errmsg("out of memory")));

    popt = postgres_fdw_options;
    for (lopt = libpq_options; lopt->keyword; lopt++)
    {
        /* Hide debug options, as well as settings we override internally. */
        if (strchr(lopt->dispchar, 'D') ||
            strcmp(lopt->keyword, "fallback_application_name") == 0 ||
            strcmp(lopt->keyword, "client_encoding") == 0)
            continue;

        /* We don't have to copy keyword string, as described above. */
        popt->keyword = lopt->keyword;

        /*
         * "user" and any secret options are allowed only on user mappings.
         * Everything else is a server option.
         */
        if (strcmp(lopt->keyword, "user") == 0 || strchr(lopt->dispchar, '*'))
            popt->optcontext = UserMappingRelationId;
        else
            popt->optcontext = ForeignServerRelationId;
        popt->is_libpq_opt = true;

        popt++;
    }

    /* Append FDW-specific options and dummy terminator. */
    memcpy(popt, non_libpq_options, sizeof(non_libpq_options));
}

is_libpq_option()

static bool is_libpq_option ( const char *  keyword )

static

Definition at line 326 of file option.c.

References Assert, PgFdwOption::is_libpq_opt, and PgFdwOption::keyword.

Referenced by ExtractConnectionOptions().

{
    PgFdwOption *opt;

    Assert(postgres_fdw_options);   /* must be initialized already */

    for (opt = postgres_fdw_options; opt->keyword; opt++)
    {
        if (opt->is_libpq_opt && strcmp(opt->keyword, keyword) == 0)
            return true;
    }

    return false;
}

is_valid_option()

static bool is_valid_option ( const char *  keyword, Oid  context  )

static

Definition at line 307 of file option.c.

References Assert, PgFdwOption::keyword, and PgFdwOption::optcontext.

Referenced by postgres_fdw_validator().

{
    PgFdwOption *opt;

    Assert(postgres_fdw_options);   /* must be initialized already */

    for (opt = postgres_fdw_options; opt->keyword; opt++)
    {
        if (context == opt->optcontext && strcmp(opt->keyword, keyword) == 0)
            return true;
    }

    return false;
}

PG_FUNCTION_INFO_V1()

PG_FUNCTION_INFO_V1

(

postgres_fdw_validator

)

postgres_fdw_validator()

Datum postgres_fdw_validator

(

PG_FUNCTION_ARGS

)

Definition at line 65 of file option.c.

References appendStringInfo(), buf, StringInfoData::data, defGetBoolean(), defGetString(), DefElem::defname, ereport, errcode(), errhint(), errmsg(), ERROR, ExtractExtensionList(), fetch_size, InitPgFdwOptions(), initStringInfo(), is_valid_option(), PgFdwOption::keyword, StringInfoData::len, lfirst, PgFdwOption::optcontext, PG_GETARG_DATUM, PG_GETARG_OID, PG_RETURN_VOID, superuser(), untransformRelOptions(), and val.

{
    List       *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
    Oid         catalog = PG_GETARG_OID(1);
    ListCell   *cell;

    /* Build our options lists if we didn't yet. */
    InitPgFdwOptions();

    /*
     * Check that only options supported by postgres_fdw, and allowed for the
     * current object type, are given.
     */
    foreach(cell, options_list)
    {
        DefElem    *def = (DefElem *) lfirst(cell);

        if (!is_valid_option(def->defname, catalog))
        {
            /*
             * Unknown option specified, complain about it. Provide a hint
             * with list of valid options for the object.
             */
            PgFdwOption *opt;
            StringInfoData buf;

            initStringInfo(&buf);
            for (opt = postgres_fdw_options; opt->keyword; opt++)
            {
                if (catalog == opt->optcontext)
                    appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "",
                                     opt->keyword);
            }

            ereport(ERROR,
                    (errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
                     errmsg("invalid option \"%s\"", def->defname),
                     errhint("Valid options in this context are: %s",
                             buf.data)));
        }

        /*
         * Validate option value, when we can do so without any context.
         */
        if (strcmp(def->defname, "use_remote_estimate") == 0 ||
            strcmp(def->defname, "updatable") == 0)
        {
            /* these accept only boolean values */
            (void) defGetBoolean(def);
        }
        else if (strcmp(def->defname, "fdw_startup_cost") == 0 ||
                 strcmp(def->defname, "fdw_tuple_cost") == 0)
        {
            /* these must have a non-negative numeric value */
            double      val;
            char       *endp;

            val = strtod(defGetString(def), &endp);
            if (*endp || val < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("%s requires a non-negative numeric value",
                                def->defname)));
        }
        else if (strcmp(def->defname, "extensions") == 0)
        {
            /* check list syntax, warn about uninstalled extensions */
            (void) ExtractExtensionList(defGetString(def), true);
        }
        else if (strcmp(def->defname, "fetch_size") == 0)
        {
            int         fetch_size;

            fetch_size = strtol(defGetString(def), NULL, 10);
            if (fetch_size <= 0)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("%s requires a non-negative integer value",
                                def->defname)));
        }
        else if (strcmp(def->defname, "batch_size") == 0)
        {
            int         batch_size;

            batch_size = strtol(defGetString(def), NULL, 10);
            if (batch_size <= 0)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("%s requires a non-negative integer value",
                                def->defname)));
        }
        else if (strcmp(def->defname, "password_required") == 0)
        {
            bool        pw_required = defGetBoolean(def);

            /*
             * Only the superuser may set this option on a user mapping, or
             * alter a user mapping on which this option is set. We allow a
             * user to clear this option if it's set - in fact, we don't have
             * a choice since we can't see the old mapping when validating an
             * alter.
             */
            if (!superuser() && !pw_required)
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("password_required=false is superuser-only"),
                         errhint("User mappings with the password_required option set to false may only be created or modified by the superuser")));
        }
        else if (strcmp(def->defname, "sslcert") == 0 ||
                 strcmp(def->defname, "sslkey") == 0)
        {
            /* similarly for sslcert / sslkey on user mapping */
            if (catalog == UserMappingRelationId && !superuser())
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("sslcert and sslkey are superuser-only"),
                         errhint("User mappings with the sslcert or sslkey options set may only be created or modified by the superuser")));
        }
    }

    PG_RETURN_VOID();
}

Variable Documentation

libpq_options

PQconninfoOption* libpq_options

static

Definition at line 45 of file option.c.

postgres_fdw_options

PgFdwOption* postgres_fdw_options

static

Definition at line 39 of file option.c.

Referenced by InitPgFdwOptions().