PostgreSQL Source Code  git master
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 "libpq/libpq-be.h"
#include "postgres_fdw.h"
#include "utils/builtins.h"
#include "utils/guc.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

void _PG_init (void)
 
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)
 
ListExtractExtensionList (const char *extensionsString, bool warnOnMissing)
 
char * process_pgfdw_appname (const char *appname)
 

Variables

static PgFdwOptionpostgres_fdw_options
 
static PQconninfoOptionlibpq_options
 
char * pgfdw_application_name = NULL
 

Typedef Documentation

◆ PgFdwOption

typedef struct PgFdwOption PgFdwOption

Function Documentation

◆ _PG_init()

void _PG_init ( void  )

Definition at line 514 of file option.c.

515 {
516  /*
517  * Unlike application_name GUC, don't set GUC_IS_NAME flag nor check_hook
518  * to allow postgres_fdw.application_name to be any string more than
519  * NAMEDATALEN characters and to include non-ASCII characters. Instead,
520  * remote server truncates application_name of remote connection to less
521  * than NAMEDATALEN and replaces any non-ASCII characters in it with a '?'
522  * character.
523  */
524  DefineCustomStringVariable("postgres_fdw.application_name",
525  "Sets the application name to be used on the remote server.",
526  NULL,
528  NULL,
529  PGC_USERSET,
530  0,
531  NULL,
532  NULL,
533  NULL);
534 
535  EmitWarningsOnPlaceholders("postgres_fdw");
536 }
char * pgfdw_application_name
Definition: option.c:52
void DefineCustomStringVariable(const char *name, const char *short_desc, const char *long_desc, char **valueAddr, const char *bootValue, GucContext context, int flags, GucStringCheckHook check_hook, GucStringAssignHook assign_hook, GucShowHook show_hook)
Definition: guc.c:9294
void EmitWarningsOnPlaceholders(const char *className)
Definition: guc.c:9351
@ PGC_USERSET
Definition: guc.h:76

References DefineCustomStringVariable(), EmitWarningsOnPlaceholders(), PGC_USERSET, and pgfdw_application_name.

◆ ExtractConnectionOptions()

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

Definition at line 380 of file option.c.

382 {
383  ListCell *lc;
384  int i;
385 
386  /* Build our options lists if we didn't yet. */
388 
389  i = 0;
390  foreach(lc, defelems)
391  {
392  DefElem *d = (DefElem *) lfirst(lc);
393 
394  if (is_libpq_option(d->defname))
395  {
396  keywords[i] = d->defname;
397  values[i] = defGetString(d);
398  i++;
399  }
400  }
401  return i;
402 }
static Datum values[MAXATTR]
Definition: bootstrap.c:156
static bool is_libpq_option(const char *keyword)
Definition: option.c:359
static void InitPgFdwOptions(void)
Definition: option.c:218
char * defGetString(DefElem *def)
Definition: define.c:49
int i
Definition: isn.c:73
#define lfirst(lc)
Definition: pg_list.h:169
char * defname
Definition: parsenodes.h:758

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

Referenced by connect_pg_server().

◆ ExtractExtensionList()

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

Definition at line 411 of file option.c.

412 {
413  List *extensionOids = NIL;
414  List *extlist;
415  ListCell *lc;
416 
417  /* SplitIdentifierString scribbles on its input, so pstrdup first */
418  if (!SplitIdentifierString(pstrdup(extensionsString), ',', &extlist))
419  {
420  /* syntax error in name list */
421  ereport(ERROR,
422  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
423  errmsg("parameter \"%s\" must be a list of extension names",
424  "extensions")));
425  }
426 
427  foreach(lc, extlist)
428  {
429  const char *extension_name = (const char *) lfirst(lc);
430  Oid extension_oid = get_extension_oid(extension_name, true);
431 
432  if (OidIsValid(extension_oid))
433  {
434  extensionOids = lappend_oid(extensionOids, extension_oid);
435  }
436  else if (warnOnMissing)
437  {
439  (errcode(ERRCODE_UNDEFINED_OBJECT),
440  errmsg("extension \"%s\" is not installed",
441  extension_name)));
442  }
443  }
444 
445  list_free(extlist);
446  return extensionOids;
447 }
#define OidIsValid(objectId)
Definition: c.h:710
int errcode(int sqlerrcode)
Definition: elog.c:693
int errmsg(const char *fmt,...)
Definition: elog.c:904
#define WARNING
Definition: elog.h:30
#define ERROR
Definition: elog.h:33
#define ereport(elevel,...)
Definition: elog.h:143
Oid get_extension_oid(const char *extname, bool missing_ok)
Definition: extension.c:140
List * lappend_oid(List *list, Oid datum)
Definition: list.c:372
void list_free(List *list)
Definition: list.c:1505
char * pstrdup(const char *in)
Definition: mcxt.c:1299
#define NIL
Definition: pg_list.h:65
unsigned int Oid
Definition: postgres_ext.h:31
Definition: pg_list.h:51
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3754

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

◆ InitPgFdwOptions()

static void InitPgFdwOptions ( void  )
static

Definition at line 218 of file option.c.

219 {
220  int num_libpq_opts;
221  PQconninfoOption *lopt;
222  PgFdwOption *popt;
223 
224  /* non-libpq FDW-specific FDW options */
225  static const PgFdwOption non_libpq_options[] = {
226  {"schema_name", ForeignTableRelationId, false},
227  {"table_name", ForeignTableRelationId, false},
228  {"column_name", AttributeRelationId, false},
229  /* use_remote_estimate is available on both server and table */
230  {"use_remote_estimate", ForeignServerRelationId, false},
231  {"use_remote_estimate", ForeignTableRelationId, false},
232  /* cost factors */
233  {"fdw_startup_cost", ForeignServerRelationId, false},
234  {"fdw_tuple_cost", ForeignServerRelationId, false},
235  /* shippable extensions */
236  {"extensions", ForeignServerRelationId, false},
237  /* updatable is available on both server and table */
238  {"updatable", ForeignServerRelationId, false},
239  {"updatable", ForeignTableRelationId, false},
240  /* truncatable is available on both server and table */
241  {"truncatable", ForeignServerRelationId, false},
242  {"truncatable", ForeignTableRelationId, false},
243  /* fetch_size is available on both server and table */
244  {"fetch_size", ForeignServerRelationId, false},
245  {"fetch_size", ForeignTableRelationId, false},
246  /* batch_size is available on both server and table */
247  {"batch_size", ForeignServerRelationId, false},
248  {"batch_size", ForeignTableRelationId, false},
249  /* async_capable is available on both server and table */
250  {"async_capable", ForeignServerRelationId, false},
251  {"async_capable", ForeignTableRelationId, false},
252  {"keep_connections", ForeignServerRelationId, false},
253  {"password_required", UserMappingRelationId, false},
254 
255  /*
256  * sslcert and sslkey are in fact libpq options, but we repeat them
257  * here to allow them to appear in both foreign server context (when
258  * we generate libpq options) and user mapping context (from here).
259  */
260  {"sslcert", UserMappingRelationId, true},
261  {"sslkey", UserMappingRelationId, true},
262 
263  {NULL, InvalidOid, false}
264  };
265 
266  /* Prevent redundant initialization. */
268  return;
269 
270  /*
271  * Get list of valid libpq options.
272  *
273  * To avoid unnecessary work, we get the list once and use it throughout
274  * the lifetime of this backend process. We don't need to care about
275  * memory context issues, because PQconndefaults allocates with malloc.
276  */
278  if (!libpq_options) /* assume reason for failure is OOM */
279  ereport(ERROR,
280  (errcode(ERRCODE_FDW_OUT_OF_MEMORY),
281  errmsg("out of memory"),
282  errdetail("Could not get libpq's default connection options.")));
283 
284  /* Count how many libpq options are available. */
285  num_libpq_opts = 0;
286  for (lopt = libpq_options; lopt->keyword; lopt++)
287  num_libpq_opts++;
288 
289  /*
290  * Construct an array which consists of all valid options for
291  * postgres_fdw, by appending FDW-specific options to libpq options.
292  *
293  * We use plain malloc here to allocate postgres_fdw_options because it
294  * lives as long as the backend process does. Besides, keeping
295  * libpq_options in memory allows us to avoid copying every keyword
296  * string.
297  */
299  malloc(sizeof(PgFdwOption) * num_libpq_opts +
300  sizeof(non_libpq_options));
301  if (postgres_fdw_options == NULL)
302  ereport(ERROR,
303  (errcode(ERRCODE_FDW_OUT_OF_MEMORY),
304  errmsg("out of memory")));
305 
306  popt = postgres_fdw_options;
307  for (lopt = libpq_options; lopt->keyword; lopt++)
308  {
309  /* Hide debug options, as well as settings we override internally. */
310  if (strchr(lopt->dispchar, 'D') ||
311  strcmp(lopt->keyword, "fallback_application_name") == 0 ||
312  strcmp(lopt->keyword, "client_encoding") == 0)
313  continue;
314 
315  /* We don't have to copy keyword string, as described above. */
316  popt->keyword = lopt->keyword;
317 
318  /*
319  * "user" and any secret options are allowed only on user mappings.
320  * Everything else is a server option.
321  */
322  if (strcmp(lopt->keyword, "user") == 0 || strchr(lopt->dispchar, '*'))
323  popt->optcontext = UserMappingRelationId;
324  else
325  popt->optcontext = ForeignServerRelationId;
326  popt->is_libpq_opt = true;
327 
328  popt++;
329  }
330 
331  /* Append FDW-specific options and dummy terminator. */
332  memcpy(popt, non_libpq_options, sizeof(non_libpq_options));
333 }
static PQconninfoOption * libpq_options
Definition: option.c:47
static PgFdwOption * postgres_fdw_options
Definition: option.c:41
int errdetail(const char *fmt,...)
Definition: elog.c:1037
PQconninfoOption * PQconndefaults(void)
Definition: fe-connect.c:1472
#define malloc(a)
Definition: header.h:50
#define InvalidOid
Definition: postgres_ext.h:36
Oid optcontext
Definition: option.c:33
const char * keyword
Definition: option.c:32
bool is_libpq_opt
Definition: option.c:34

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

Referenced by ExtractConnectionOptions(), and postgres_fdw_validator().

◆ is_libpq_option()

static bool is_libpq_option ( const char *  keyword)
static

Definition at line 359 of file option.c.

360 {
361  PgFdwOption *opt;
362 
363  Assert(postgres_fdw_options); /* must be initialized already */
364 
365  for (opt = postgres_fdw_options; opt->keyword; opt++)
366  {
367  if (opt->is_libpq_opt && strcmp(opt->keyword, keyword) == 0)
368  return true;
369  }
370 
371  return false;
372 }
Assert(fmt[strlen(fmt) - 1] !='\n')

References Assert(), PgFdwOption::is_libpq_opt, PgFdwOption::keyword, and postgres_fdw_options.

Referenced by ExtractConnectionOptions().

◆ is_valid_option()

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

Definition at line 340 of file option.c.

341 {
342  PgFdwOption *opt;
343 
344  Assert(postgres_fdw_options); /* must be initialized already */
345 
346  for (opt = postgres_fdw_options; opt->keyword; opt++)
347  {
348  if (context == opt->optcontext && strcmp(opt->keyword, keyword) == 0)
349  return true;
350  }
351 
352  return false;
353 }

References Assert(), PgFdwOption::keyword, PgFdwOption::optcontext, and postgres_fdw_options.

Referenced by postgres_fdw_validator().

◆ PG_FUNCTION_INFO_V1()

PG_FUNCTION_INFO_V1 ( postgres_fdw_validator  )

◆ postgres_fdw_validator()

Datum postgres_fdw_validator ( PG_FUNCTION_ARGS  )

Definition at line 74 of file option.c.

75 {
76  List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
77  Oid catalog = PG_GETARG_OID(1);
78  ListCell *cell;
79 
80  /* Build our options lists if we didn't yet. */
82 
83  /*
84  * Check that only options supported by postgres_fdw, and allowed for the
85  * current object type, are given.
86  */
87  foreach(cell, options_list)
88  {
89  DefElem *def = (DefElem *) lfirst(cell);
90 
91  if (!is_valid_option(def->defname, catalog))
92  {
93  /*
94  * Unknown option specified, complain about it. Provide a hint
95  * with list of valid options for the object.
96  */
97  PgFdwOption *opt;
99 
101  for (opt = postgres_fdw_options; opt->keyword; opt++)
102  {
103  if (catalog == opt->optcontext)
104  appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "",
105  opt->keyword);
106  }
107 
108  ereport(ERROR,
109  (errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
110  errmsg("invalid option \"%s\"", def->defname),
111  buf.len > 0
112  ? errhint("Valid options in this context are: %s",
113  buf.data)
114  : errhint("There are no valid options in this context.")));
115  }
116 
117  /*
118  * Validate option value, when we can do so without any context.
119  */
120  if (strcmp(def->defname, "use_remote_estimate") == 0 ||
121  strcmp(def->defname, "updatable") == 0 ||
122  strcmp(def->defname, "truncatable") == 0 ||
123  strcmp(def->defname, "async_capable") == 0 ||
124  strcmp(def->defname, "keep_connections") == 0)
125  {
126  /* these accept only boolean values */
127  (void) defGetBoolean(def);
128  }
129  else if (strcmp(def->defname, "fdw_startup_cost") == 0 ||
130  strcmp(def->defname, "fdw_tuple_cost") == 0)
131  {
132  /*
133  * These must have a floating point value greater than or equal to
134  * zero.
135  */
136  char *value;
137  double real_val;
138  bool is_parsed;
139 
140  value = defGetString(def);
141  is_parsed = parse_real(value, &real_val, 0, NULL);
142 
143  if (!is_parsed)
144  ereport(ERROR,
145  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
146  errmsg("invalid value for floating point option \"%s\": %s",
147  def->defname, value)));
148 
149  if (real_val < 0)
150  ereport(ERROR,
151  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
152  errmsg("\"%s\" must be a floating point value greater than or equal to zero",
153  def->defname)));
154  }
155  else if (strcmp(def->defname, "extensions") == 0)
156  {
157  /* check list syntax, warn about uninstalled extensions */
158  (void) ExtractExtensionList(defGetString(def), true);
159  }
160  else if (strcmp(def->defname, "fetch_size") == 0 ||
161  strcmp(def->defname, "batch_size") == 0)
162  {
163  char *value;
164  int int_val;
165  bool is_parsed;
166 
167  value = defGetString(def);
168  is_parsed = parse_int(value, &int_val, 0, NULL);
169 
170  if (!is_parsed)
171  ereport(ERROR,
172  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
173  errmsg("invalid value for integer option \"%s\": %s",
174  def->defname, value)));
175 
176  if (int_val <= 0)
177  ereport(ERROR,
178  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
179  errmsg("\"%s\" must be an integer value greater than zero",
180  def->defname)));
181  }
182  else if (strcmp(def->defname, "password_required") == 0)
183  {
184  bool pw_required = defGetBoolean(def);
185 
186  /*
187  * Only the superuser may set this option on a user mapping, or
188  * alter a user mapping on which this option is set. We allow a
189  * user to clear this option if it's set - in fact, we don't have
190  * a choice since we can't see the old mapping when validating an
191  * alter.
192  */
193  if (!superuser() && !pw_required)
194  ereport(ERROR,
195  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
196  errmsg("password_required=false is superuser-only"),
197  errhint("User mappings with the password_required option set to false may only be created or modified by the superuser")));
198  }
199  else if (strcmp(def->defname, "sslcert") == 0 ||
200  strcmp(def->defname, "sslkey") == 0)
201  {
202  /* similarly for sslcert / sslkey on user mapping */
203  if (catalog == UserMappingRelationId && !superuser())
204  ereport(ERROR,
205  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
206  errmsg("sslcert and sslkey are superuser-only"),
207  errhint("User mappings with the sslcert or sslkey options set may only be created or modified by the superuser")));
208  }
209  }
210 
211  PG_RETURN_VOID();
212 }
static bool is_valid_option(const char *keyword, Oid context)
Definition: option.c:340
List * ExtractExtensionList(const char *extensionsString, bool warnOnMissing)
Definition: option.c:411
bool defGetBoolean(DefElem *def)
Definition: define.c:108
int errhint(const char *fmt,...)
Definition: elog.c:1151
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:268
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:6890
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition: guc.c:6980
static struct @142 value
static char * buf
Definition: pg_test_fsync.c:70
List * untransformRelOptions(Datum options)
Definition: reloptions.c:1325
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
bool superuser(void)
Definition: superuser.c:46

References appendStringInfo(), buf, defGetBoolean(), defGetString(), DefElem::defname, ereport, errcode(), errhint(), errmsg(), ERROR, ExtractExtensionList(), InitPgFdwOptions(), initStringInfo(), is_valid_option(), PgFdwOption::keyword, lfirst, PgFdwOption::optcontext, parse_int(), parse_real(), PG_GETARG_DATUM, PG_GETARG_OID, PG_RETURN_VOID, postgres_fdw_options, superuser(), untransformRelOptions(), and value.

◆ process_pgfdw_appname()

char* process_pgfdw_appname ( const char *  appname)

Definition at line 457 of file option.c.

458 {
459  const char *p;
461 
462  Assert(MyProcPort != NULL);
463 
465 
466  for (p = appname; *p != '\0'; p++)
467  {
468  if (*p != '%')
469  {
470  /* literal char, just copy */
472  continue;
473  }
474 
475  /* must be a '%', so skip to the next char */
476  p++;
477  if (*p == '\0')
478  break; /* format error - ignore it */
479  else if (*p == '%')
480  {
481  /* string contains %% */
482  appendStringInfoChar(&buf, '%');
483  continue;
484  }
485 
486  /* process the option */
487  switch (*p)
488  {
489  case 'a':
491  break;
492  case 'd':
494  break;
495  case 'p':
496  appendStringInfo(&buf, "%d", MyProcPid);
497  break;
498  case 'u':
500  break;
501  default:
502  /* format error - ignore it */
503  break;
504  }
505  }
506 
507  return buf.data;
508 }
int MyProcPid
Definition: globals.c:43
struct Port * MyProcPort
Definition: globals.c:46
char * application_name
Definition: guc.c:623
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
char * user_name
Definition: libpq-be.h:146
char * database_name
Definition: libpq-be.h:145

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), application_name, Assert(), buf, Port::database_name, initStringInfo(), MyProcPid, MyProcPort, and Port::user_name.

Referenced by connect_pg_server().

Variable Documentation

◆ libpq_options

PQconninfoOption* libpq_options
static

Definition at line 47 of file option.c.

Referenced by InitPgFdwOptions().

◆ pgfdw_application_name

char* pgfdw_application_name = NULL

Definition at line 52 of file option.c.

Referenced by _PG_init(), and connect_pg_server().

◆ postgres_fdw_options

PgFdwOption* postgres_fdw_options
static