PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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/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

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)
 
void _PG_init (void)
 

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 577 of file option.c.

578{
579 /*
580 * Unlike application_name GUC, don't set GUC_IS_NAME flag nor check_hook
581 * to allow postgres_fdw.application_name to be any string more than
582 * NAMEDATALEN characters and to include non-ASCII characters. Instead,
583 * remote server truncates application_name of remote connection to less
584 * than NAMEDATALEN and replaces any non-ASCII characters in it with a '?'
585 * character.
586 */
587 DefineCustomStringVariable("postgres_fdw.application_name",
588 "Sets the application name to be used on the remote server.",
589 NULL,
591 NULL,
593 0,
594 NULL,
595 NULL,
596 NULL);
597
598 MarkGUCPrefixReserved("postgres_fdw");
599}
char * pgfdw_application_name
Definition: option.c:51
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:5219
void MarkGUCPrefixReserved(const char *className)
Definition: guc.c:5280
@ PGC_USERSET
Definition: guc.h:79

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

◆ ExtractConnectionOptions()

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

Definition at line 423 of file option.c.

425{
426 ListCell *lc;
427 int i;
428
429 /* Build our options lists if we didn't yet. */
431
432 i = 0;
433 foreach(lc, defelems)
434 {
435 DefElem *d = (DefElem *) lfirst(lc);
436
437 if (is_libpq_option(d->defname))
438 {
439 keywords[i] = d->defname;
440 values[i] = defGetString(d);
441 i++;
442 }
443 }
444 return i;
445}
static Datum values[MAXATTR]
Definition: bootstrap.c:151
static bool is_libpq_option(const char *keyword)
Definition: option.c:402
static void InitPgFdwOptions(void)
Definition: option.c:239
char * defGetString(DefElem *def)
Definition: define.c:35
int i
Definition: isn.c:77
static const JsonPathKeyword keywords[]
#define lfirst(lc)
Definition: pg_list.h:172
char * defname
Definition: parsenodes.h:826

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

Referenced by connect_pg_server().

◆ ExtractExtensionList()

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

Definition at line 454 of file option.c.

455{
456 List *extensionOids = NIL;
457 List *extlist;
458 ListCell *lc;
459
460 /* SplitIdentifierString scribbles on its input, so pstrdup first */
461 if (!SplitIdentifierString(pstrdup(extensionsString), ',', &extlist))
462 {
463 /* syntax error in name list */
465 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
466 errmsg("parameter \"%s\" must be a list of extension names",
467 "extensions")));
468 }
469
470 foreach(lc, extlist)
471 {
472 const char *extension_name = (const char *) lfirst(lc);
473 Oid extension_oid = get_extension_oid(extension_name, true);
474
475 if (OidIsValid(extension_oid))
476 {
477 extensionOids = lappend_oid(extensionOids, extension_oid);
478 }
479 else if (warnOnMissing)
480 {
482 (errcode(ERRCODE_UNDEFINED_OBJECT),
483 errmsg("extension \"%s\" is not installed",
484 extension_name)));
485 }
486 }
487
488 list_free(extlist);
489 return extensionOids;
490}
#define OidIsValid(objectId)
Definition: c.h:746
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define WARNING
Definition: elog.h:36
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
Oid get_extension_oid(const char *extname, bool missing_ok)
Definition: extension.c:167
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
void list_free(List *list)
Definition: list.c:1546
char * pstrdup(const char *in)
Definition: mcxt.c:2327
#define NIL
Definition: pg_list.h:68
unsigned int Oid
Definition: postgres_ext.h:30
Definition: pg_list.h:54
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3525

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 239 of file option.c.

240{
241 int num_libpq_opts;
242 PQconninfoOption *lopt;
243 PgFdwOption *popt;
244
245 /* non-libpq FDW-specific FDW options */
246 static const PgFdwOption non_libpq_options[] = {
247 {"schema_name", ForeignTableRelationId, false},
248 {"table_name", ForeignTableRelationId, false},
249 {"column_name", AttributeRelationId, false},
250 /* use_remote_estimate is available on both server and table */
251 {"use_remote_estimate", ForeignServerRelationId, false},
252 {"use_remote_estimate", ForeignTableRelationId, false},
253 /* cost factors */
254 {"fdw_startup_cost", ForeignServerRelationId, false},
255 {"fdw_tuple_cost", ForeignServerRelationId, false},
256 /* shippable extensions */
257 {"extensions", ForeignServerRelationId, false},
258 /* updatable is available on both server and table */
259 {"updatable", ForeignServerRelationId, false},
260 {"updatable", ForeignTableRelationId, false},
261 /* truncatable is available on both server and table */
262 {"truncatable", ForeignServerRelationId, false},
263 {"truncatable", ForeignTableRelationId, false},
264 /* fetch_size is available on both server and table */
265 {"fetch_size", ForeignServerRelationId, false},
266 {"fetch_size", ForeignTableRelationId, false},
267 /* batch_size is available on both server and table */
268 {"batch_size", ForeignServerRelationId, false},
269 {"batch_size", ForeignTableRelationId, false},
270 /* async_capable is available on both server and table */
271 {"async_capable", ForeignServerRelationId, false},
272 {"async_capable", ForeignTableRelationId, false},
273 {"parallel_commit", ForeignServerRelationId, false},
274 {"parallel_abort", ForeignServerRelationId, false},
275 {"keep_connections", ForeignServerRelationId, false},
276 {"password_required", UserMappingRelationId, false},
277
278 /* sampling is available on both server and table */
279 {"analyze_sampling", ForeignServerRelationId, false},
280 {"analyze_sampling", ForeignTableRelationId, false},
281
282 {"use_scram_passthrough", ForeignServerRelationId, false},
283 {"use_scram_passthrough", UserMappingRelationId, false},
284
285 /*
286 * sslcert and sslkey are in fact libpq options, but we repeat them
287 * here to allow them to appear in both foreign server context (when
288 * we generate libpq options) and user mapping context (from here).
289 */
290 {"sslcert", UserMappingRelationId, true},
291 {"sslkey", UserMappingRelationId, true},
292
293 /*
294 * gssdelegation is also a libpq option but should be allowed in a
295 * user mapping context too
296 */
297 {"gssdelegation", UserMappingRelationId, true},
298
299 {NULL, InvalidOid, false}
300 };
301
302 /* Prevent redundant initialization. */
304 return;
305
306 /*
307 * Get list of valid libpq options.
308 *
309 * To avoid unnecessary work, we get the list once and use it throughout
310 * the lifetime of this backend process. We don't need to care about
311 * memory context issues, because PQconndefaults allocates with malloc.
312 */
314 if (!libpq_options) /* assume reason for failure is OOM */
316 (errcode(ERRCODE_FDW_OUT_OF_MEMORY),
317 errmsg("out of memory"),
318 errdetail("Could not get libpq's default connection options.")));
319
320 /* Count how many libpq options are available. */
321 num_libpq_opts = 0;
322 for (lopt = libpq_options; lopt->keyword; lopt++)
323 num_libpq_opts++;
324
325 /*
326 * Construct an array which consists of all valid options for
327 * postgres_fdw, by appending FDW-specific options to libpq options.
328 *
329 * We use plain malloc here to allocate postgres_fdw_options because it
330 * lives as long as the backend process does. Besides, keeping
331 * libpq_options in memory allows us to avoid copying every keyword
332 * string.
333 */
335 malloc(sizeof(PgFdwOption) * num_libpq_opts +
336 sizeof(non_libpq_options));
337 if (postgres_fdw_options == NULL)
339 (errcode(ERRCODE_FDW_OUT_OF_MEMORY),
340 errmsg("out of memory")));
341
343 for (lopt = libpq_options; lopt->keyword; lopt++)
344 {
345 /* Hide debug options, as well as settings we override internally. */
346 if (strchr(lopt->dispchar, 'D') ||
347 strcmp(lopt->keyword, "fallback_application_name") == 0 ||
348 strcmp(lopt->keyword, "client_encoding") == 0)
349 continue;
350
351 /*
352 * Disallow OAuth options for now, since the builtin flow communicates
353 * on stderr by default and can't cache tokens yet.
354 */
355 if (strncmp(lopt->keyword, "oauth_", strlen("oauth_")) == 0)
356 continue;
357
358 /* We don't have to copy keyword string, as described above. */
359 popt->keyword = lopt->keyword;
360
361 /*
362 * "user" and any secret options are allowed only on user mappings.
363 * Everything else is a server option.
364 */
365 if (strcmp(lopt->keyword, "user") == 0 || strchr(lopt->dispchar, '*'))
366 popt->optcontext = UserMappingRelationId;
367 else
368 popt->optcontext = ForeignServerRelationId;
369 popt->is_libpq_opt = true;
370
371 popt++;
372 }
373
374 /* Append FDW-specific options and dummy terminator. */
375 memcpy(popt, non_libpq_options, sizeof(non_libpq_options));
376}
static PQconninfoOption * libpq_options
Definition: option.c:46
static PgFdwOption * postgres_fdw_options
Definition: option.c:40
int errdetail(const char *fmt,...)
Definition: elog.c:1204
PQconninfoOption * PQconndefaults(void)
Definition: fe-connect.c:2196
#define malloc(a)
Definition: header.h:50
#define InvalidOid
Definition: postgres_ext.h:35
Oid optcontext
Definition: option.c:32
const char * keyword
Definition: option.c:31
bool is_libpq_opt
Definition: option.c:33

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 402 of file option.c.

403{
404 PgFdwOption *opt;
405
406 Assert(postgres_fdw_options); /* must be initialized already */
407
408 for (opt = postgres_fdw_options; opt->keyword; opt++)
409 {
410 if (opt->is_libpq_opt && strcmp(opt->keyword, keyword) == 0)
411 return true;
412 }
413
414 return false;
415}
Assert(PointerIsAligned(start, uint64))

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 383 of file option.c.

384{
385 PgFdwOption *opt;
386
387 Assert(postgres_fdw_options); /* must be initialized already */
388
389 for (opt = postgres_fdw_options; opt->keyword; opt++)
390 {
391 if (context == opt->optcontext && strcmp(opt->keyword, keyword) == 0)
392 return true;
393 }
394
395 return false;
396}

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 71 of file option.c.

72{
73 List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
74 Oid catalog = PG_GETARG_OID(1);
75 ListCell *cell;
76
77 /* Build our options lists if we didn't yet. */
79
80 /*
81 * Check that only options supported by postgres_fdw, and allowed for the
82 * current object type, are given.
83 */
84 foreach(cell, options_list)
85 {
86 DefElem *def = (DefElem *) lfirst(cell);
87
88 if (!is_valid_option(def->defname, catalog))
89 {
90 /*
91 * Unknown option specified, complain about it. Provide a hint
92 * with a valid option that looks similar, if there is one.
93 */
94 PgFdwOption *opt;
95 const char *closest_match;
97 bool has_valid_options = false;
98
100 for (opt = postgres_fdw_options; opt->keyword; opt++)
101 {
102 if (catalog == opt->optcontext)
103 {
104 has_valid_options = true;
106 }
107 }
108
109 closest_match = getClosestMatch(&match_state);
111 (errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
112 errmsg("invalid option \"%s\"", def->defname),
113 has_valid_options ? closest_match ?
114 errhint("Perhaps you meant the option \"%s\".",
115 closest_match) : 0 :
116 errhint("There are no valid options in this context.")));
117 }
118
119 /*
120 * Validate option value, when we can do so without any context.
121 */
122 if (strcmp(def->defname, "use_remote_estimate") == 0 ||
123 strcmp(def->defname, "updatable") == 0 ||
124 strcmp(def->defname, "truncatable") == 0 ||
125 strcmp(def->defname, "async_capable") == 0 ||
126 strcmp(def->defname, "parallel_commit") == 0 ||
127 strcmp(def->defname, "parallel_abort") == 0 ||
128 strcmp(def->defname, "keep_connections") == 0)
129 {
130 /* these accept only boolean values */
131 (void) defGetBoolean(def);
132 }
133 else if (strcmp(def->defname, "fdw_startup_cost") == 0 ||
134 strcmp(def->defname, "fdw_tuple_cost") == 0)
135 {
136 /*
137 * These must have a floating point value greater than or equal to
138 * zero.
139 */
140 char *value;
141 double real_val;
142 bool is_parsed;
143
144 value = defGetString(def);
145 is_parsed = parse_real(value, &real_val, 0, NULL);
146
147 if (!is_parsed)
149 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
150 errmsg("invalid value for floating point option \"%s\": %s",
151 def->defname, value)));
152
153 if (real_val < 0)
155 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
156 errmsg("\"%s\" must be a floating point value greater than or equal to zero",
157 def->defname)));
158 }
159 else if (strcmp(def->defname, "extensions") == 0)
160 {
161 /* check list syntax, warn about uninstalled extensions */
162 (void) ExtractExtensionList(defGetString(def), true);
163 }
164 else if (strcmp(def->defname, "fetch_size") == 0 ||
165 strcmp(def->defname, "batch_size") == 0)
166 {
167 char *value;
168 int int_val;
169 bool is_parsed;
170
171 value = defGetString(def);
172 is_parsed = parse_int(value, &int_val, 0, NULL);
173
174 if (!is_parsed)
176 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
177 errmsg("invalid value for integer option \"%s\": %s",
178 def->defname, value)));
179
180 if (int_val <= 0)
182 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
183 errmsg("\"%s\" must be an integer value greater than zero",
184 def->defname)));
185 }
186 else if (strcmp(def->defname, "password_required") == 0)
187 {
188 bool pw_required = defGetBoolean(def);
189
190 /*
191 * Only the superuser may set this option on a user mapping, or
192 * alter a user mapping on which this option is set. We allow a
193 * user to clear this option if it's set - in fact, we don't have
194 * a choice since we can't see the old mapping when validating an
195 * alter.
196 */
197 if (!superuser() && !pw_required)
199 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
200 errmsg("password_required=false is superuser-only"),
201 errhint("User mappings with the password_required option set to false may only be created or modified by the superuser.")));
202 }
203 else if (strcmp(def->defname, "sslcert") == 0 ||
204 strcmp(def->defname, "sslkey") == 0)
205 {
206 /* similarly for sslcert / sslkey on user mapping */
207 if (catalog == UserMappingRelationId && !superuser())
209 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
210 errmsg("sslcert and sslkey are superuser-only"),
211 errhint("User mappings with the sslcert or sslkey options set may only be created or modified by the superuser.")));
212 }
213 else if (strcmp(def->defname, "analyze_sampling") == 0)
214 {
215 char *value;
216
217 value = defGetString(def);
218
219 /* we recognize off/auto/random/system/bernoulli */
220 if (strcmp(value, "off") != 0 &&
221 strcmp(value, "auto") != 0 &&
222 strcmp(value, "random") != 0 &&
223 strcmp(value, "system") != 0 &&
224 strcmp(value, "bernoulli") != 0)
226 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
227 errmsg("invalid value for string option \"%s\": %s",
228 def->defname, value)));
229 }
230 }
231
233}
static bool is_valid_option(const char *keyword, Oid context)
Definition: option.c:383
List * ExtractExtensionList(const char *extensionsString, bool warnOnMissing)
Definition: option.c:454
bool defGetBoolean(DefElem *def)
Definition: define.c:94
int errhint(const char *fmt,...)
Definition: elog.c:1318
#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:2871
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition: guc.c:2961
struct parser_state match_state[5]
static struct @165 value
List * untransformRelOptions(Datum options)
Definition: reloptions.c:1342
bool superuser(void)
Definition: superuser.c:46
const char * getClosestMatch(ClosestMatchState *state)
Definition: varlena.c:6445
void initClosestMatch(ClosestMatchState *state, const char *source, int max_d)
Definition: varlena.c:6390
void updateClosestMatch(ClosestMatchState *state, const char *candidate)
Definition: varlena.c:6410

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

◆ process_pgfdw_appname()

char * process_pgfdw_appname ( const char *  appname)

Definition at line 500 of file option.c.

501{
502 const char *p;
504
506
507 for (p = appname; *p != '\0'; p++)
508 {
509 if (*p != '%')
510 {
511 /* literal char, just copy */
513 continue;
514 }
515
516 /* must be a '%', so skip to the next char */
517 p++;
518 if (*p == '\0')
519 break; /* format error - ignore it */
520 else if (*p == '%')
521 {
522 /* string contains %% */
524 continue;
525 }
526
527 /* process the option */
528 switch (*p)
529 {
530 case 'a':
532 break;
533 case 'c':
535 break;
536 case 'C':
538 break;
539 case 'd':
540 if (MyProcPort)
541 {
542 const char *dbname = MyProcPort->database_name;
543
544 if (dbname)
546 else
547 appendStringInfoString(&buf, "[unknown]");
548 }
549 break;
550 case 'p':
552 break;
553 case 'u':
554 if (MyProcPort)
555 {
556 const char *username = MyProcPort->user_name;
557
558 if (username)
560 else
561 appendStringInfoString(&buf, "[unknown]");
562 }
563 break;
564 default:
565 /* format error - ignore it */
566 break;
567 }
568 }
569
570 return buf.data;
571}
#define INT64_HEX_FORMAT
Definition: c.h:522
int MyProcPid
Definition: globals.c:48
struct Port * MyProcPort
Definition: globals.c:52
pg_time_t MyStartTime
Definition: globals.c:49
char * cluster_name
Definition: guc_tables.c:554
char * application_name
Definition: guc_tables.c:560
static char * username
Definition: initdb.c:153
static char * buf
Definition: pg_test_fsync.c:72
char * dbname
Definition: streamutil.c:49
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:145
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
char * user_name
Definition: libpq-be.h:151
char * database_name
Definition: libpq-be.h:150

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), application_name, buf, cluster_name, Port::database_name, dbname, initStringInfo(), INT64_HEX_FORMAT, MyProcPid, MyProcPort, MyStartTime, Port::user_name, and username.

Referenced by connect_pg_server().

Variable Documentation

◆ libpq_options

PQconninfoOption* libpq_options
static

Definition at line 46 of file option.c.

Referenced by InitPgFdwOptions().

◆ pgfdw_application_name

char* pgfdw_application_name = NULL

Definition at line 51 of file option.c.

Referenced by _PG_init(), and connect_pg_server().

◆ postgres_fdw_options

PgFdwOption* postgres_fdw_options
static