#include "postgres.h"
#include "postgres_fdw.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 "utils/builtins.h"
#include "utils/varlena.h"

Include dependency graph for option.c:

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

typedef struct PgFdwOption PgFdwOption

Function Documentation

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

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

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

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

static void InitPgFdwOptions ( void )

static

Definition at line 155 of file option.c.

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

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

static bool is_libpq_option ( const char * keyword )

static

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

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

static

Definition at line 257 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 ( postgres_fdw_validator )

Datum postgres_fdw_validator ( PG_FUNCTION_ARGS )

Definition at line 66 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, NULL, PgFdwOption::optcontext, PG_GETARG_DATUM, PG_GETARG_OID, PG_RETURN_VOID, 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)));
         }
     }
 
     PG_RETURN_VOID();
 }

Variable Documentation

PQconninfoOption* libpq_options

static

Definition at line 47 of file option.c.

PgFdwOption* postgres_fdw_options

static

Definition at line 41 of file option.c.

Referenced by InitPgFdwOptions().

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation