#include "postgres.h"
#include <ctype.h>
#include <float.h>
#include <math.h>
#include <limits.h>
#include <unistd.h>
#include <sys/stat.h>
#include "access/commit_ts.h"
#include "access/gin.h"
#include "access/rmgr.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog_internal.h"
#include "catalog/namespace.h"
#include "catalog/pg_authid.h"
#include "commands/async.h"
#include "commands/prepare.h"
#include "commands/user.h"
#include "commands/vacuum.h"
#include "commands/variable.h"
#include "commands/trigger.h"
#include "funcapi.h"
#include "libpq/auth.h"
#include "libpq/be-fsstubs.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "optimizer/cost.h"
#include "optimizer/geqo.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
#include "parser/parse_expr.h"
#include "parser/parse_type.h"
#include "parser/parser.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/bgwriter.h"
#include "postmaster/postmaster.h"
#include "postmaster/syslogger.h"
#include "postmaster/walwriter.h"
#include "replication/logicallauncher.h"
#include "replication/slot.h"
#include "replication/syncrep.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/dsm_impl.h"
#include "storage/standby.h"
#include "storage/fd.h"
#include "storage/pg_shmem.h"
#include "storage/proc.h"
#include "storage/predicate.h"
#include "tcop/tcopprot.h"
#include "tsearch/ts_cache.h"
#include "utils/builtins.h"
#include "utils/bytea.h"
#include "utils/guc_tables.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/plancache.h"
#include "utils/portal.h"
#include "utils/ps_status.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"
#include "utils/tzparser.h"
#include "utils/varlena.h"
#include "utils/xml.h"
#include "guc-file.c"

Include dependency graph for guc.c:

Data Structures
struct	unit_conversion

Macros
#define	PG_KRB_SRVTAB ""

#define	CONFIG_FILENAME "postgresql.conf"

#define	HBA_FILENAME "pg_hba.conf"

#define	IDENT_FILENAME "pg_ident.conf"

#define	REALTYPE_PRECISION 17

#define	MAX_UNIT_LEN 3 /* length of longest recognized unit string */

#define	newval (newval_union.boolval)

#define	newval (newval_union.intval)

#define	newval (newval_union.realval)

#define	newval (newval_union.stringval)

#define	newval (newval_union.enumval)

#define	NUM_PG_SETTINGS_ATTS 17

#define	NUM_PG_FILE_SETTINGS_ATTS 7

Functions
static void	do_serialize (char *destptr, Size maxbytes, const char *fmt,...) pg_attribute_printf(3

static void static void	set_config_sourcefile (const char name, char sourcefile, int sourceline)

static bool	call_bool_check_hook (struct config_bool conf, bool newval, void **extra, GucSource source, int elevel)

static bool	call_int_check_hook (struct config_int conf, int newval, void **extra, GucSource source, int elevel)

static bool	call_real_check_hook (struct config_real conf, double newval, void **extra, GucSource source, int elevel)

static bool	call_string_check_hook (struct config_string conf, char newval, void *extra, GucSource source, int elevel)

static bool	call_enum_check_hook (struct config_enum conf, int newval, void **extra, GucSource source, int elevel)

static bool	check_log_destination (char newval, void extra, GucSource source)

static void	assign_log_destination (const char newval, void extra)

static bool	check_wal_consistency_checking (char newval, void extra, GucSource source)

static void	assign_wal_consistency_checking (const char newval, void extra)

static void	assign_syslog_facility (int newval, void *extra)

static void	assign_syslog_ident (const char newval, void extra)

static void	assign_session_replication_role (int newval, void *extra)

static bool	check_temp_buffers (int newval, void *extra, GucSource source)

static bool	check_bonjour (bool newval, void *extra, GucSource source)

static bool	check_ssl (bool newval, void *extra, GucSource source)

static bool	check_stage_log_stats (bool newval, void *extra, GucSource source)

static bool	check_log_stats (bool newval, void *extra, GucSource source)

static bool	check_canonical_path (char newval, void extra, GucSource source)

static bool	check_timezone_abbreviations (char newval, void extra, GucSource source)

static void	assign_timezone_abbreviations (const char newval, void extra)

static void	pg_timezone_abbrev_initialize (void)

static const char *	show_archive_command (void)

static void	assign_tcp_keepalives_idle (int newval, void *extra)

static void	assign_tcp_keepalives_interval (int newval, void *extra)

static void	assign_tcp_keepalives_count (int newval, void *extra)

static const char *	show_tcp_keepalives_idle (void)

static const char *	show_tcp_keepalives_interval (void)

static const char *	show_tcp_keepalives_count (void)

static bool	check_maxconnections (int newval, void *extra, GucSource source)

static bool	check_max_worker_processes (int newval, void *extra, GucSource source)

static bool	check_autovacuum_max_workers (int newval, void *extra, GucSource source)

static bool	check_autovacuum_work_mem (int newval, void *extra, GucSource source)

static bool	check_effective_io_concurrency (int newval, void *extra, GucSource source)

static void	assign_effective_io_concurrency (int newval, void *extra)

static void	assign_pgstat_temp_directory (const char newval, void extra)

static bool	check_application_name (char newval, void extra, GucSource source)

static void	assign_application_name (const char newval, void extra)

static bool	check_cluster_name (char newval, void extra, GucSource source)

static const char *	show_unix_socket_permissions (void)

static const char *	show_log_file_mode (void)

static ConfigVariable *	ProcessConfigFileInternal (GucContext context, bool applySettings, int elevel)

static int	guc_var_compare (const void a, const void b)

static int	guc_name_compare (const char namea, const char nameb)

static void	InitializeGUCOptionsFromEnvironment (void)

static void	InitializeOneGUCOption (struct config_generic *gconf)

static void	push_old_value (struct config_generic *gconf, GucAction action)

static void	ReportGUCOption (struct config_generic *record)

static void	reapply_stacked_values (struct config_generic variable, struct config_string pHolder, GucStack stack, const char curvalue, GucContext curscontext, GucSource cursource)

static void	ShowGUCConfigOption (const char name, DestReceiver dest)

static void	ShowAllGUCConfig (DestReceiver *dest)

static char *	_ShowOption (struct config_generic *record, bool use_units)

static bool	validate_option_array_item (const char name, const char value, bool skipIfNoPermissions)

static void	write_auto_conf_file (int fd, const char filename, ConfigVariable head_p)

static void	replace_auto_config_value (ConfigVariable head_p, ConfigVariable tail_p, const char name, const char value)

static void *	guc_malloc (int elevel, size_t size)

static void *	guc_realloc (int elevel, void *old, size_t size)

static char *	guc_strdup (int elevel, const char *src)

static bool	string_field_used (struct config_string conf, char strval)

static void	set_string_field (struct config_string conf, char field, char newval)

static bool	extra_field_used (struct config_generic gconf, void extra)

static void	set_extra_field (struct config_generic gconf, void field, void newval)

static void	set_stack_value (struct config_generic gconf, config_var_value val)

static void	discard_stack_value (struct config_generic gconf, config_var_value val)

struct config_generic **	get_guc_variables (void)

void	build_guc_variables (void)

static bool	add_guc_variable (struct config_generic *var, int elevel)

static struct config_generic *	add_placeholder_variable (const char *name, int elevel)

static struct config_generic *	find_option (const char *name, bool create_placeholders, int elevel)

void	InitializeGUCOptions (void)

bool	SelectConfigFiles (const char userDoption, const char progname)

void	ResetAllOptions (void)

void	AtStart_GUC (void)

int	NewGUCNestLevel (void)

void	AtEOXact_GUC (bool isCommit, int nestLevel)

void	BeginReportingGUCOptions (void)

static bool	convert_to_base_unit (int64 value, const char unit, int base_unit, int64 base_value)

static void	convert_from_base_unit (int64 base_value, int base_unit, int64 value, const char *unit)

bool	parse_int (const char value, int result, int flags, const char **hintmsg)

bool	parse_real (const char value, double result)

const char *	config_enum_lookup_by_value (struct config_enum *record, int val)

bool	config_enum_lookup_by_name (struct config_enum record, const char value, int *retval)

static char *	config_enum_get_options (struct config_enum record, const char prefix, const char suffix, const char separator)

static bool	parse_and_validate_value (struct config_generic record, const char name, const char value, GucSource source, int elevel, union config_var_val newval, void **newextra)

int	set_config_option (const char name, const char value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)

void	SetConfigOption (const char name, const char value, GucContext context, GucSource source)

const char *	GetConfigOption (const char *name, bool missing_ok, bool restrict_superuser)

const char *	GetConfigOptionResetString (const char *name)

static char *	flatten_set_variable_args (const char name, List args)

void	AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)

void	ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)

char *	ExtractSetVariableArgs (VariableSetStmt *stmt)

void	SetPGVariable (const char name, List args, bool is_local)

Datum	set_config_by_name (PG_FUNCTION_ARGS)

static struct config_generic *	init_custom_variable (const char name, const char short_desc, const char *long_desc, GucContext context, int flags, enum config_type type, size_t sz)

static void	define_custom_variable (struct config_generic *variable)

void	DefineCustomBoolVariable (const char name, const char short_desc, const char long_desc, bool valueAddr, bool bootValue, GucContext context, int flags, GucBoolCheckHook check_hook, GucBoolAssignHook assign_hook, GucShowHook show_hook)

void	DefineCustomIntVariable (const char name, const char short_desc, const char long_desc, int valueAddr, int bootValue, int minValue, int maxValue, GucContext context, int flags, GucIntCheckHook check_hook, GucIntAssignHook assign_hook, GucShowHook show_hook)

void	DefineCustomRealVariable (const char name, const char short_desc, const char long_desc, double valueAddr, double bootValue, double minValue, double maxValue, GucContext context, int flags, GucRealCheckHook check_hook, GucRealAssignHook assign_hook, GucShowHook show_hook)

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)

void	DefineCustomEnumVariable (const char name, const char short_desc, const char long_desc, int valueAddr, int bootValue, const struct config_enum_entry *options, GucContext context, int flags, GucEnumCheckHook check_hook, GucEnumAssignHook assign_hook, GucShowHook show_hook)

void	EmitWarningsOnPlaceholders (const char *className)

void	GetPGVariable (const char name, DestReceiver dest)

TupleDesc	GetPGVariableResultDesc (const char *name)

char *	GetConfigOptionByName (const char name, const char *varname, bool missing_ok)

void	GetConfigOptionByNum (int varnum, const char *values, bool noshow)

int	GetNumConfigOptions (void)

Datum	show_config_by_name (PG_FUNCTION_ARGS)

Datum	show_config_by_name_missing_ok (PG_FUNCTION_ARGS)

Datum	show_all_settings (PG_FUNCTION_ARGS)

Datum	show_all_file_settings (PG_FUNCTION_ARGS)

static bool	can_skip_gucvar (struct config_generic *gconf)

static Size	estimate_variable_size (struct config_generic *gconf)

Size	EstimateGUCStateSpace (void)

static void	do_serialize_binary (char *destptr, Size maxbytes, void *val, Size valsize)

static void	serialize_variable (char *destptr, Size maxbytes, struct config_generic *gconf)

void	SerializeGUCState (Size maxsize, char *start_address)

static char *	read_gucstate (char *srcptr, char srcend)

static void	read_gucstate_binary (char *srcptr, char srcend, void *dest, Size size)

void	RestoreGUCState (void *gucstate)

void	ParseLongOption (const char string, char name, char *value)

void	ProcessGUCArray (ArrayType *array, GucContext context, GucSource source, GucAction action)

ArrayType *	GUCArrayAdd (ArrayType array, const char name, const char *value)

ArrayType *	GUCArrayDelete (ArrayType array, const char name)

ArrayType *	GUCArrayReset (ArrayType *array)

void	GUC_check_errcode (int sqlerrcode)

Variables
bool	Log_disconnections

int	CommitDelay

int	CommitSiblings

char *	default_tablespace

char *	temp_tablespaces

bool	ignore_checksum_failure

bool	synchronize_seqscans

static int	GUC_check_errcode_value

char *	GUC_check_errmsg_string

char *	GUC_check_errdetail_string

char *	GUC_check_errhint_string

static int	syslog_facility = 0

static const struct config_enum_entry	bytea_output_options []

static const struct config_enum_entry	client_message_level_options []

static const struct config_enum_entry	server_message_level_options []

static const struct config_enum_entry	intervalstyle_options []

static const struct config_enum_entry	log_error_verbosity_options []

static const struct config_enum_entry	log_statement_options []

static const struct config_enum_entry	isolation_level_options []

static const struct config_enum_entry	session_replication_role_options []

static const struct config_enum_entry	syslog_facility_options []

static const struct config_enum_entry	track_function_options []

static const struct config_enum_entry	xmlbinary_options []

static const struct config_enum_entry	xmloption_options []

static const struct config_enum_entry	backslash_quote_options []

static const struct config_enum_entry	constraint_exclusion_options []

static const struct config_enum_entry	synchronous_commit_options []

static const struct config_enum_entry	huge_pages_options []

static const struct config_enum_entry	force_parallel_mode_options []

static const struct config_enum_entry	password_encryption_options []

const struct config_enum_entry	wal_level_options []

const struct config_enum_entry	archive_mode_options []

const struct config_enum_entry	sync_method_options []

const struct config_enum_entry	dynamic_shared_memory_options []

bool	log_duration = false

bool	Debug_print_plan = false

bool	Debug_print_parse = false

bool	Debug_print_rewritten = false

bool	Debug_pretty_print = true

bool	log_parser_stats = false

bool	log_planner_stats = false

bool	log_executor_stats = false

bool	log_statement_stats = false

bool	log_btree_build_stats = false

char *	event_source

bool	row_security

bool	check_function_bodies = true

bool	default_with_oids = false

int	log_min_error_statement = ERROR

int	log_min_messages = WARNING

int	client_min_messages = NOTICE

int	log_min_duration_statement = -1

int	log_temp_files = -1

int	trace_recovery_messages = LOG

int	temp_file_limit = -1

int	num_temp_buffers = 1024

char *	cluster_name = ""

char *	ConfigFileName

char *	HbaFileName

char *	IdentFileName

char *	external_pid_file

char *	pgstat_temp_directory

char *	application_name

int	tcp_keepalives_idle

int	tcp_keepalives_interval

int	tcp_keepalives_count

int	ssl_renegotiation_limit

int	huge_pages

static char *	syslog_ident_str

static bool	session_auth_is_superuser

static double	phony_random_seed

static char *	client_encoding_string

static char *	datestyle_string

static char *	locale_collate

static char *	locale_ctype

static char *	server_encoding_string

static char *	server_version_string

static int	server_version_num

static char *	timezone_string

static char *	log_timezone_string

static char *	timezone_abbreviations_string

static char *	XactIsoLevel_string

static char *	data_directory

static char *	session_authorization_string

static int	max_function_args

static int	max_index_keys

static int	max_identifier_length

static int	block_size

static int	segment_size

static int	wal_block_size

static bool	data_checksums

static bool	integer_datetimes

static bool	assert_enabled

char *	role_string

const char *const	GucContext_Names []

const char *const	GucSource_Names []

const char *const	config_group_names []

const char *const	config_type_names []

static const char *	memory_units_hint = gettext_noop("Valid units for this parameter are \"kB\", \"MB\", \"GB\", and \"TB\".")

static const unit_conversion	memory_unit_conversion_table []

static const char *	time_units_hint = gettext_noop("Valid units for this parameter are \"ms\", \"s\", \"min\", \"h\", and \"d\".")

static const unit_conversion	time_unit_conversion_table []

static struct config_bool	ConfigureNamesBool []

static struct config_int	ConfigureNamesInt []

static struct config_real	ConfigureNamesReal []

static struct config_string	ConfigureNamesString []

static struct config_enum	ConfigureNamesEnum []

static const char *const	map_old_guc_names []

static struct config_generic **	guc_variables

static int	num_guc_variables

static int	size_guc_variables

static bool	guc_dirty

static bool	reporting_enabled

static int	GUCNestLevel = 0

Macro Definition Documentation

#define CONFIG_FILENAME "postgresql.conf"

Definition at line 97 of file guc.c.

Referenced by SelectConfigFiles().

#define HBA_FILENAME "pg_hba.conf"

Definition at line 98 of file guc.c.

Referenced by SelectConfigFiles().

#define IDENT_FILENAME "pg_ident.conf"

Definition at line 99 of file guc.c.

Referenced by SelectConfigFiles().

#define MAX_UNIT_LEN 3 /* length of longest recognized unit string */

Definition at line 697 of file guc.c.

Referenced by parse_int().

#define newval (newval_union.boolval)

#define newval (newval_union.intval)

#define newval (newval_union.realval)

#define newval (newval_union.stringval)

#define newval (newval_union.enumval)

#define NUM_PG_FILE_SETTINGS_ATTS 7

Referenced by show_all_file_settings().

#define NUM_PG_SETTINGS_ATTS 17

Definition at line 8397 of file guc.c.

Referenced by show_all_settings().

#define PG_KRB_SRVTAB ""

Definition at line 94 of file guc.c.

#define REALTYPE_PRECISION 17

Definition at line 110 of file guc.c.

Referenced by estimate_variable_size(), and serialize_variable().

Function Documentation

static char * _ShowOption	(	struct config_generic *	record,
		bool	use_units
	)

static

Definition at line 8644 of file guc.c.

References buffer, config_enum_lookup_by_value(), convert_from_base_unit(), config_generic::flags, GUC_UNIT, INT64_FORMAT, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, pstrdup(), config_bool::show_hook, config_int::show_hook, config_real::show_hook, config_string::show_hook, config_enum::show_hook, snprintf(), val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by GetConfigOptionByName(), GetConfigOptionByNum(), ReportGUCOption(), and ShowAllGUCConfig().

 {
     char        buffer[256];
     const char *val;
 
     switch (record->vartype)
     {
         case PGC_BOOL:
             {
                 struct config_bool *conf = (struct config_bool *) record;
 
                 if (conf->show_hook)
                     val = conf->show_hook();
                 else
                     val = *conf->variable ? "on" : "off";
             }
             break;
 
         case PGC_INT:
             {
                 struct config_int *conf = (struct config_int *) record;
 
                 if (conf->show_hook)
                     val = conf->show_hook();
                 else
                 {
                     /*
                      * Use int64 arithmetic to avoid overflows in units
                      * conversion.
                      */
                     int64       result = *conf->variable;
                     const char *unit;
 
                     if (use_units && result > 0 && (record->flags & GUC_UNIT))
                     {
                         convert_from_base_unit(result, record->flags & GUC_UNIT,
                                                &result, &unit);
                     }
                     else
                         unit = "";
 
                     snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
                              result, unit);
                     val = buffer;
                 }
             }
             break;
 
         case PGC_REAL:
             {
                 struct config_real *conf = (struct config_real *) record;
 
                 if (conf->show_hook)
                     val = conf->show_hook();
                 else
                 {
                     snprintf(buffer, sizeof(buffer), "%g",
                              *conf->variable);
                     val = buffer;
                 }
             }
             break;
 
         case PGC_STRING:
             {
                 struct config_string *conf = (struct config_string *) record;
 
                 if (conf->show_hook)
                     val = conf->show_hook();
                 else if (*conf->variable && **conf->variable)
                     val = *conf->variable;
                 else
                     val = "";
             }
             break;
 
         case PGC_ENUM:
             {
                 struct config_enum *conf = (struct config_enum *) record;
 
                 if (conf->show_hook)
                     val = conf->show_hook();
                 else
                     val = config_enum_lookup_by_value(conf, *conf->variable);
             }
             break;
 
         default:
             /* just to keep compiler quiet */
             val = "???";
             break;
     }
 
     return pstrdup(val);
 }

static bool add_guc_variable	(	struct config_generic *	var,
		int	elevel
	)

static

Definition at line 4295 of file guc.c.

References guc_malloc(), guc_realloc(), guc_var_compare(), and qsort.

Referenced by add_placeholder_variable(), and define_custom_variable().

 {
     if (num_guc_variables + 1 >= size_guc_variables)
     {
         /*
          * Increase the vector by 25%
          */
         int         size_vars = size_guc_variables + size_guc_variables / 4;
         struct config_generic **guc_vars;
 
         if (size_vars == 0)
         {
             size_vars = 100;
             guc_vars = (struct config_generic **)
                 guc_malloc(elevel, size_vars * sizeof(struct config_generic *));
         }
         else
         {
             guc_vars = (struct config_generic **)
                 guc_realloc(elevel, guc_variables, size_vars * sizeof(struct config_generic *));
         }
 
         if (guc_vars == NULL)
             return false;       /* out of memory */
 
         guc_variables = guc_vars;
         size_guc_variables = size_vars;
     }
     guc_variables[num_guc_variables++] = var;
     qsort((void *) guc_variables, num_guc_variables,
           sizeof(struct config_generic *), guc_var_compare);
     return true;
 }

static struct config_generic* add_placeholder_variable	(	const char *	name,
		int	elevel
	)

static

Definition at line 4333 of file guc.c.

References add_guc_variable(), config_generic::context, CUSTOM_OPTIONS, config_generic::flags, free, config_string::gen, config_generic::group, GUC_CUSTOM_PLACEHOLDER, guc_malloc(), GUC_NO_SHOW_ALL, GUC_NOT_IN_SAMPLE, guc_strdup(), config_generic::name, PGC_STRING, PGC_USERSET, config_generic::short_desc, config_string::variable, and config_generic::vartype.

Referenced by find_option().

 {
     size_t      sz = sizeof(struct config_string) + sizeof(char *);
     struct config_string *var;
     struct config_generic *gen;
 
     var = (struct config_string *) guc_malloc(elevel, sz);
     if (var == NULL)
         return NULL;
     memset(var, 0, sz);
     gen = &var->gen;
 
     gen->name = guc_strdup(elevel, name);
     if (gen->name == NULL)
     {
         free(var);
         return NULL;
     }
 
     gen->context = PGC_USERSET;
     gen->group = CUSTOM_OPTIONS;
     gen->short_desc = "GUC placeholder variable";
     gen->flags = GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_CUSTOM_PLACEHOLDER;
     gen->vartype = PGC_STRING;
 
     /*
      * The char* is allocated at the end of the struct since we have no
      * 'static' place to point to.  Note that the current value, as well as
      * the boot and reset values, start out NULL.
      */
     var->variable = (char **) (var + 1);
 
     if (!add_guc_variable((struct config_generic *) var, elevel))
     {
         free((void *) gen->name);
         free(var);
         return NULL;
     }
 
     return gen;
 }

void AlterSystemSetConfigFile ( AlterSystemStmt * altersysstmt )

Definition at line 7079 of file guc.c.

References AllocateFile(), BasicOpenFile(), close, config_generic::context, durable_rename(), elog, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, ExtractSetVariableArgs(), find_option(), config_generic::flags, free, FreeConfigVariables(), FreeFile(), GUC_DISALLOW_IN_AUTO_FILE, GUC_DISALLOW_IN_FILE, infile(), VariableSetStmt::kind, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXPGPATH, name, VariableSetStmt::name, parse_and_validate_value(), ParseConfigFp(), PG_AUTOCONF_FILENAME, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PGC_INTERNAL, PGC_S_FILE, PGC_STRING, replace_auto_config_value(), AlterSystemStmt::setstmt, snprintf(), config_var_val::stringval, superuser(), value, VAR_RESET, VAR_RESET_ALL, VAR_SET_DEFAULT, VAR_SET_VALUE, config_generic::vartype, and write_auto_conf_file().

Referenced by standard_ProcessUtility().

 {
     char       *name;
     char       *value;
     bool        resetall = false;
     ConfigVariable *head = NULL;
     ConfigVariable *tail = NULL;
     volatile int Tmpfd;
     char        AutoConfFileName[MAXPGPATH];
     char        AutoConfTmpFileName[MAXPGPATH];
 
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  (errmsg("must be superuser to execute ALTER SYSTEM command"))));
 
     /*
      * Extract statement arguments
      */
     name = altersysstmt->setstmt->name;
 
     switch (altersysstmt->setstmt->kind)
     {
         case VAR_SET_VALUE:
             value = ExtractSetVariableArgs(altersysstmt->setstmt);
             break;
 
         case VAR_SET_DEFAULT:
         case VAR_RESET:
             value = NULL;
             break;
 
         case VAR_RESET_ALL:
             value = NULL;
             resetall = true;
             break;
 
         default:
             elog(ERROR, "unrecognized alter system stmt type: %d",
                  altersysstmt->setstmt->kind);
             break;
     }
 
     /*
      * Unless it's RESET_ALL, validate the target variable and value
      */
     if (!resetall)
     {
         struct config_generic *record;
 
         record = find_option(name, false, ERROR);
         if (record == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("unrecognized configuration parameter \"%s\"",
                             name)));
 
         /*
          * Don't allow parameters that can't be set in configuration files to
          * be set in PG_AUTOCONF_FILENAME file.
          */
         if ((record->context == PGC_INTERNAL) ||
             (record->flags & GUC_DISALLOW_IN_FILE) ||
             (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
             ereport(ERROR,
                     (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                      errmsg("parameter \"%s\" cannot be changed",
                             name)));
 
         /*
          * If a value is specified, verify that it's sane.
          */
         if (value)
         {
             union config_var_val newval;
             void       *newextra = NULL;
 
             /* Check that it's acceptable for the indicated parameter */
             if (!parse_and_validate_value(record, name, value,
                                           PGC_S_FILE, ERROR,
                                           &newval, &newextra))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("invalid value for parameter \"%s\": \"%s\"",
                                 name, value)));
 
             if (record->vartype == PGC_STRING && newval.stringval != NULL)
                 free(newval.stringval);
             if (newextra)
                 free(newextra);
 
             /*
              * We must also reject values containing newlines, because the
              * grammar for config files doesn't support embedded newlines in
              * string literals.
              */
             if (strchr(value, '\n'))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
         }
     }
 
     /*
      * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
      * the data directory, so we can reference them by simple relative paths.
      */
     snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
              PG_AUTOCONF_FILENAME);
     snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
              AutoConfFileName,
              "tmp");
 
     /*
      * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
      * time.  Use AutoFileLock to ensure that.  We must hold the lock while
      * reading the old file contents.
      */
     LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
 
     /*
      * If we're going to reset everything, then no need to open or parse the
      * old file.  We'll just write out an empty list.
      */
     if (!resetall)
     {
         struct stat st;
 
         if (stat(AutoConfFileName, &st) == 0)
         {
             /* open old file PG_AUTOCONF_FILENAME */
             FILE       *infile;
 
             infile = AllocateFile(AutoConfFileName, "r");
             if (infile == NULL)
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not open file \"%s\": %m",
                                 AutoConfFileName)));
 
             /* parse it */
             if (!ParseConfigFp(infile, AutoConfFileName, 0, LOG, &head, &tail))
                 ereport(ERROR,
                         (errcode(ERRCODE_CONFIG_FILE_ERROR),
                          errmsg("could not parse contents of file \"%s\"",
                                 AutoConfFileName)));
 
             FreeFile(infile);
         }
 
         /*
          * Now, replace any existing entry with the new value, or add it if
          * not present.
          */
         replace_auto_config_value(&head, &tail, name, value);
     }
 
     /*
      * To ensure crash safety, first write the new file data to a temp file,
      * then atomically rename it into place.
      *
      * If there is a temp file left over due to a previous crash, it's okay to
      * truncate and reuse it.
      */
     Tmpfd = BasicOpenFile(AutoConfTmpFileName,
                           O_CREAT | O_RDWR | O_TRUNC);
     if (Tmpfd < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not open file \"%s\": %m",
                         AutoConfTmpFileName)));
 
     /*
      * Use a TRY block to clean up the file if we fail.  Since we need a TRY
      * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
      */
     PG_TRY();
     {
         /* Write and sync the new contents to the temporary file */
         write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
 
         /* Close before renaming; may be required on some platforms */
         close(Tmpfd);
         Tmpfd = -1;
 
         /*
          * As the rename is atomic operation, if any problem occurs after this
          * at worst it can lose the parameters set by last ALTER SYSTEM
          * command.
          */
         durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
     }
     PG_CATCH();
     {
         /* Close file first, else unlink might fail on some platforms */
         if (Tmpfd >= 0)
             close(Tmpfd);
 
         /* Unlink, but ignore any error */
         (void) unlink(AutoConfTmpFileName);
 
         PG_RE_THROW();
     }
     PG_END_TRY();
 
     FreeConfigVariables(head);
 
     LWLockRelease(AutoFileLock);
 }

static void assign_application_name	(	const char *	newval,
		void *	extra
	)

static

Definition at line 10474 of file guc.c.

References pgstat_report_appname().

 {
     /* Update the pg_stat_activity view */
     pgstat_report_appname(newval);
 }

static void assign_effective_io_concurrency	(	int	newval,
		void *	extra
	)

static

Definition at line 10422 of file guc.c.

References target_prefetch_pages.

 {
 #ifdef USE_PREFETCH
     target_prefetch_pages = *((int *) extra);
 #endif                          /* USE_PREFETCH */
 }

static void assign_log_destination	(	const char *	newval,
		void *	extra
	)

static

Definition at line 10110 of file guc.c.

References Log_destination.

 {
     Log_destination = *((int *) extra);
 }

static void assign_pgstat_temp_directory	(	const char *	newval,
		void *	extra
	)

static

Definition at line 10430 of file guc.c.

References ERROR, free, guc_malloc(), pgstat_stat_directory, pgstat_stat_filename, and pgstat_stat_tmpname.

 {
     /* check_canonical_path already canonicalized newval for us */
     char       *dname;
     char       *tname;
     char       *fname;
 
     /* directory */
     dname = guc_malloc(ERROR, strlen(newval) + 1);  /* runtime dir */
     sprintf(dname, "%s", newval);
 
     /* global stats */
     tname = guc_malloc(ERROR, strlen(newval) + 12); /* /global.tmp */
     sprintf(tname, "%s/global.tmp", newval);
     fname = guc_malloc(ERROR, strlen(newval) + 13); /* /global.stat */
     sprintf(fname, "%s/global.stat", newval);
 
     if (pgstat_stat_directory)
         free(pgstat_stat_directory);
     pgstat_stat_directory = dname;
     if (pgstat_stat_tmpname)
         free(pgstat_stat_tmpname);
     pgstat_stat_tmpname = tname;
     if (pgstat_stat_filename)
         free(pgstat_stat_filename);
     pgstat_stat_filename = fname;
 }

static void assign_session_replication_role	(	int	newval,
		void *	extra
	)

static

Definition at line 10136 of file guc.c.

References ResetPlanCache(), and SessionReplicationRole.

 {
     /*
      * Must flush the plan cache when changing replication role; but don't
      * flush unnecessarily.
      */
     if (SessionReplicationRole != newval)
         ResetPlanCache();
 }

static void assign_syslog_facility	(	int	newval,
		void *	extra
	)

static

Definition at line 10116 of file guc.c.

 {
 #ifdef HAVE_SYSLOG
     set_syslog_parameters(syslog_ident_str ? syslog_ident_str : "postgres",
                           newval);
 #endif
     /* Without syslog support, just ignore it */
 }

static void assign_syslog_ident	(	const char *	newval,
		void *	extra
	)

static

Definition at line 10126 of file guc.c.

 {
 #ifdef HAVE_SYSLOG
     set_syslog_parameters(newval, syslog_facility);
 #endif
     /* Without syslog support, it will always be set to "none", so ignore */
 }

static void assign_tcp_keepalives_count	(	int	newval,
		void *	extra
	)

static

Definition at line 10335 of file guc.c.

References MyProcPort, and pq_setkeepalivescount().

 {
     /* See comments in assign_tcp_keepalives_idle */
     (void) pq_setkeepalivescount(newval, MyProcPort);
 }

static void assign_tcp_keepalives_idle	(	int	newval,
		void *	extra
	)

static

Definition at line 10291 of file guc.c.

References MyProcPort, and pq_setkeepalivesidle().

 {
     /*
      * The kernel API provides no way to test a value without setting it; and
      * once we set it we might fail to unset it.  So there seems little point
      * in fully implementing the check-then-assign GUC API for these
      * variables.  Instead we just do the assignment on demand.  pqcomm.c
      * reports any problems via elog(LOG).
      *
      * This approach means that the GUC value might have little to do with the
      * actual kernel value, so we use a show_hook that retrieves the kernel
      * value rather than trusting GUC's copy.
      */
     (void) pq_setkeepalivesidle(newval, MyProcPort);
 }

static void assign_tcp_keepalives_interval	(	int	newval,
		void *	extra
	)

static

Definition at line 10318 of file guc.c.

References MyProcPort, and pq_setkeepalivesinterval().

 {
     /* See comments in assign_tcp_keepalives_idle */
     (void) pq_setkeepalivesinterval(newval, MyProcPort);
 }

static void assign_timezone_abbreviations	(	const char *	newval,
		void *	extra
	)

static

Definition at line 10255 of file guc.c.

References InstallTimeZoneAbbrevs().

 {
     /* Do nothing for the boot_val default of NULL */
     if (!extra)
         return;
 
     InstallTimeZoneAbbrevs((TimeZoneAbbrevTable *) extra);
 }

static void assign_wal_consistency_checking	(	const char *	newval,
		void *	extra
	)

static

Definition at line 10047 of file guc.c.

References wal_consistency_checking.

 {
     wal_consistency_checking = (bool *) extra;
 }

void AtEOXact_GUC	(	bool	isCommit,
		int	nestLevel
	)

Definition at line 5088 of file guc.c.

References Assert, config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_var_val::boolval, discard_stack_value(), config_var_val::enumval, config_var_value::extra, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_LOCAL, GUC_REPORT, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, i, config_var_val::intval, guc_stack::masked, guc_stack::masked_scontext, guc_stack::nest_level, newval, num_guc_variables, pfree(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_SESSION, PGC_STRING, guc_stack::prev, guc_stack::prior, config_var_val::realval, ReportGUCOption(), guc_stack::scontext, config_generic::scontext, set_extra_field(), set_string_field(), guc_stack::source, config_generic::source, config_generic::stack, guc_stack::state, config_var_val::stringval, config_var_value::val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by AbortSubTransaction(), AbortTransaction(), CommitSubTransaction(), CommitTransaction(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), PrepareTransaction(), ProcedureCreate(), reset_transmission_modes(), restoreLocalGucs(), RI_Initial_Check(), vacuum_rel(), and validate_index().

 {
     bool        still_dirty;
     int         i;
 
     /*
      * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
      * abort, if there is a failure during transaction start before
      * AtStart_GUC is called.
      */
     Assert(nestLevel > 0 &&
            (nestLevel <= GUCNestLevel ||
             (nestLevel == GUCNestLevel + 1 && !isCommit)));
 
     /* Quick exit if nothing's changed in this transaction */
     if (!guc_dirty)
     {
         GUCNestLevel = nestLevel - 1;
         return;
     }
 
     still_dirty = false;
     for (i = 0; i < num_guc_variables; i++)
     {
         struct config_generic *gconf = guc_variables[i];
         GucStack   *stack;
 
         /*
          * Process and pop each stack entry within the nest level. To simplify
          * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
          * we allow failure exit from code that uses a local nest level to be
          * recovered at the surrounding transaction or subtransaction abort;
          * so there could be more than one stack entry to pop.
          */
         while ((stack = gconf->stack) != NULL &&
                stack->nest_level >= nestLevel)
         {
             GucStack   *prev = stack->prev;
             bool        restorePrior = false;
             bool        restoreMasked = false;
             bool        changed;
 
             /*
              * In this next bit, if we don't set either restorePrior or
              * restoreMasked, we must "discard" any unwanted fields of the
              * stack entries to avoid leaking memory.  If we do set one of
              * those flags, unused fields will be cleaned up after restoring.
              */
             if (!isCommit)      /* if abort, always restore prior value */
                 restorePrior = true;
             else if (stack->state == GUC_SAVE)
                 restorePrior = true;
             else if (stack->nest_level == 1)
             {
                 /* transaction commit */
                 if (stack->state == GUC_SET_LOCAL)
                     restoreMasked = true;
                 else if (stack->state == GUC_SET)
                 {
                     /* we keep the current active value */
                     discard_stack_value(gconf, &stack->prior);
                 }
                 else            /* must be GUC_LOCAL */
                     restorePrior = true;
             }
             else if (prev == NULL ||
                      prev->nest_level < stack->nest_level - 1)
             {
                 /* decrement entry's level and do not pop it */
                 stack->nest_level--;
                 continue;
             }
             else
             {
                 /*
                  * We have to merge this stack entry into prev. See README for
                  * discussion of this bit.
                  */
                 switch (stack->state)
                 {
                     case GUC_SAVE:
                         Assert(false);  /* can't get here */
 
                     case GUC_SET:
                         /* next level always becomes SET */
                         discard_stack_value(gconf, &stack->prior);
                         if (prev->state == GUC_SET_LOCAL)
                             discard_stack_value(gconf, &prev->masked);
                         prev->state = GUC_SET;
                         break;
 
                     case GUC_LOCAL:
                         if (prev->state == GUC_SET)
                         {
                             /* LOCAL migrates down */
                             prev->masked_scontext = stack->scontext;
                             prev->masked = stack->prior;
                             prev->state = GUC_SET_LOCAL;
                         }
                         else
                         {
                             /* else just forget this stack level */
                             discard_stack_value(gconf, &stack->prior);
                         }
                         break;
 
                     case GUC_SET_LOCAL:
                         /* prior state at this level no longer wanted */
                         discard_stack_value(gconf, &stack->prior);
                         /* copy down the masked state */
                         prev->masked_scontext = stack->masked_scontext;
                         if (prev->state == GUC_SET_LOCAL)
                             discard_stack_value(gconf, &prev->masked);
                         prev->masked = stack->masked;
                         prev->state = GUC_SET_LOCAL;
                         break;
                 }
             }
 
             changed = false;
 
             if (restorePrior || restoreMasked)
             {
                 /* Perform appropriate restoration of the stacked value */
                 config_var_value newvalue;
                 GucSource   newsource;
                 GucContext  newscontext;
 
                 if (restoreMasked)
                 {
                     newvalue = stack->masked;
                     newsource = PGC_S_SESSION;
                     newscontext = stack->masked_scontext;
                 }
                 else
                 {
                     newvalue = stack->prior;
                     newsource = stack->source;
                     newscontext = stack->scontext;
                 }
 
                 switch (gconf->vartype)
                 {
                     case PGC_BOOL:
                         {
                             struct config_bool *conf = (struct config_bool *) gconf;
                             bool        newval = newvalue.val.boolval;
                             void       *newextra = newvalue.extra;
 
                             if (*conf->variable != newval ||
                                 conf->gen.extra != newextra)
                             {
                                 if (conf->assign_hook)
                                     conf->assign_hook(newval, newextra);
                                 *conf->variable = newval;
                                 set_extra_field(&conf->gen, &conf->gen.extra,
                                                 newextra);
                                 changed = true;
                             }
                             break;
                         }
                     case PGC_INT:
                         {
                             struct config_int *conf = (struct config_int *) gconf;
                             int         newval = newvalue.val.intval;
                             void       *newextra = newvalue.extra;
 
                             if (*conf->variable != newval ||
                                 conf->gen.extra != newextra)
                             {
                                 if (conf->assign_hook)
                                     conf->assign_hook(newval, newextra);
                                 *conf->variable = newval;
                                 set_extra_field(&conf->gen, &conf->gen.extra,
                                                 newextra);
                                 changed = true;
                             }
                             break;
                         }
                     case PGC_REAL:
                         {
                             struct config_real *conf = (struct config_real *) gconf;
                             double      newval = newvalue.val.realval;
                             void       *newextra = newvalue.extra;
 
                             if (*conf->variable != newval ||
                                 conf->gen.extra != newextra)
                             {
                                 if (conf->assign_hook)
                                     conf->assign_hook(newval, newextra);
                                 *conf->variable = newval;
                                 set_extra_field(&conf->gen, &conf->gen.extra,
                                                 newextra);
                                 changed = true;
                             }
                             break;
                         }
                     case PGC_STRING:
                         {
                             struct config_string *conf = (struct config_string *) gconf;
                             char       *newval = newvalue.val.stringval;
                             void       *newextra = newvalue.extra;
 
                             if (*conf->variable != newval ||
                                 conf->gen.extra != newextra)
                             {
                                 if (conf->assign_hook)
                                     conf->assign_hook(newval, newextra);
                                 set_string_field(conf, conf->variable, newval);
                                 set_extra_field(&conf->gen, &conf->gen.extra,
                                                 newextra);
                                 changed = true;
                             }
 
                             /*
                              * Release stacked values if not used anymore. We
                              * could use discard_stack_value() here, but since
                              * we have type-specific code anyway, might as
                              * well inline it.
                              */
                             set_string_field(conf, &stack->prior.val.stringval, NULL);
                             set_string_field(conf, &stack->masked.val.stringval, NULL);
                             break;
                         }
                     case PGC_ENUM:
                         {
                             struct config_enum *conf = (struct config_enum *) gconf;
                             int         newval = newvalue.val.enumval;
                             void       *newextra = newvalue.extra;
 
                             if (*conf->variable != newval ||
                                 conf->gen.extra != newextra)
                             {
                                 if (conf->assign_hook)
                                     conf->assign_hook(newval, newextra);
                                 *conf->variable = newval;
                                 set_extra_field(&conf->gen, &conf->gen.extra,
                                                 newextra);
                                 changed = true;
                             }
                             break;
                         }
                 }
 
                 /*
                  * Release stacked extra values if not used anymore.
                  */
                 set_extra_field(gconf, &(stack->prior.extra), NULL);
                 set_extra_field(gconf, &(stack->masked.extra), NULL);
 
                 /* And restore source information */
                 gconf->source = newsource;
                 gconf->scontext = newscontext;
             }
 
             /* Finish popping the state stack */
             gconf->stack = prev;
             pfree(stack);
 
             /* Report new value if we changed it */
             if (changed && (gconf->flags & GUC_REPORT))
                 ReportGUCOption(gconf);
         }                       /* end of stack-popping loop */
 
         if (stack != NULL)
             still_dirty = true;
     }
 
     /* If there are no remaining stack entries, we can reset guc_dirty */
     guc_dirty = still_dirty;
 
     /* Update nesting level */
     GUCNestLevel = nestLevel - 1;
 }

void AtStart_GUC ( void )

Definition at line 5054 of file guc.c.

References elog, and WARNING.

Referenced by StartTransaction().

 {
     /*
      * The nest level should be 0 between transactions; if it isn't, somebody
      * didn't call AtEOXact_GUC, or called it with the wrong nestLevel.  We
      * throw a warning but make no other effort to clean up.
      */
     if (GUCNestLevel != 0)
         elog(WARNING, "GUC nest level = %d at transaction start",
              GUCNestLevel);
     GUCNestLevel = 1;
 }

void BeginReportingGUCOptions ( void )

Definition at line 5369 of file guc.c.

References DestRemote, config_generic::flags, FrontendProtocol, GUC_REPORT, i, num_guc_variables, PG_PROTOCOL_MAJOR, ReportGUCOption(), and whereToSendOutput.

Referenced by PostgresMain().

 {
     int         i;
 
     /*
      * Don't do anything unless talking to an interactive frontend of protocol
      * 3.0 or later.
      */
     if (whereToSendOutput != DestRemote ||
         PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
         return;
 
     reporting_enabled = true;
 
     /* Transmit initial values of interesting variables */
     for (i = 0; i < num_guc_variables; i++)
     {
         struct config_generic *conf = guc_variables[i];
 
         if (conf->flags & GUC_REPORT)
             ReportGUCOption(conf);
     }
 }

void build_guc_variables ( void )

Definition at line 4208 of file guc.c.

References FATAL, free, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, guc_malloc(), guc_var_compare(), i, config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, qsort, and config_generic::vartype.

Referenced by GucInfoMain(), and InitializeGUCOptions().

 {
     int         size_vars;
     int         num_vars = 0;
     struct config_generic **guc_vars;
     int         i;
 
     for (i = 0; ConfigureNamesBool[i].gen.name; i++)
     {
         struct config_bool *conf = &ConfigureNamesBool[i];
 
         /* Rather than requiring vartype to be filled in by hand, do this: */
         conf->gen.vartype = PGC_BOOL;
         num_vars++;
     }
 
     for (i = 0; ConfigureNamesInt[i].gen.name; i++)
     {
         struct config_int *conf = &ConfigureNamesInt[i];
 
         conf->gen.vartype = PGC_INT;
         num_vars++;
     }
 
     for (i = 0; ConfigureNamesReal[i].gen.name; i++)
     {
         struct config_real *conf = &ConfigureNamesReal[i];
 
         conf->gen.vartype = PGC_REAL;
         num_vars++;
     }
 
     for (i = 0; ConfigureNamesString[i].gen.name; i++)
     {
         struct config_string *conf = &ConfigureNamesString[i];
 
         conf->gen.vartype = PGC_STRING;
         num_vars++;
     }
 
     for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
     {
         struct config_enum *conf = &ConfigureNamesEnum[i];
 
         conf->gen.vartype = PGC_ENUM;
         num_vars++;
     }
 
     /*
      * Create table with 20% slack
      */
     size_vars = num_vars + num_vars / 4;
 
     guc_vars = (struct config_generic **)
         guc_malloc(FATAL, size_vars * sizeof(struct config_generic *));
 
     num_vars = 0;
 
     for (i = 0; ConfigureNamesBool[i].gen.name; i++)
         guc_vars[num_vars++] = &ConfigureNamesBool[i].gen;
 
     for (i = 0; ConfigureNamesInt[i].gen.name; i++)
         guc_vars[num_vars++] = &ConfigureNamesInt[i].gen;
 
     for (i = 0; ConfigureNamesReal[i].gen.name; i++)
         guc_vars[num_vars++] = &ConfigureNamesReal[i].gen;
 
     for (i = 0; ConfigureNamesString[i].gen.name; i++)
         guc_vars[num_vars++] = &ConfigureNamesString[i].gen;
 
     for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
         guc_vars[num_vars++] = &ConfigureNamesEnum[i].gen;
 
     if (guc_variables)
         free(guc_variables);
     guc_variables = guc_vars;
     num_guc_variables = num_vars;
     size_guc_variables = size_vars;
     qsort((void *) guc_variables, num_guc_variables,
           sizeof(struct config_generic *), guc_var_compare);
 }

static bool call_bool_check_hook	(	struct config_bool *	conf,
		bool *	newval,
		void **	extra,
		GucSource	source,
		int	elevel
	)

static

Definition at line 9797 of file guc.c.

References config_bool::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_bool::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

 {
     /* Quick success if no hook */
     if (!conf->check_hook)
         return true;
 
     /* Reset variables that might be set by hook */
     GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
     GUC_check_errmsg_string = NULL;
     GUC_check_errdetail_string = NULL;
     GUC_check_errhint_string = NULL;
 
     if (!conf->check_hook(newval, extra, source))
     {
         ereport(elevel,
                 (errcode(GUC_check_errcode_value),
                  GUC_check_errmsg_string ?
                  errmsg_internal("%s", GUC_check_errmsg_string) :
                  errmsg("invalid value for parameter \"%s\": %d",
                         conf->gen.name, (int) *newval),
                  GUC_check_errdetail_string ?
                  errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                  GUC_check_errhint_string ?
                  errhint("%s", GUC_check_errhint_string) : 0));
         /* Flush any strings created in ErrorContext */
         FlushErrorState();
         return false;
     }
 
     return true;
 }

static bool call_enum_check_hook	(	struct config_enum *	conf,
		int *	newval,
		void **	extra,
		GucSource	source,
		int	elevel
	)

static

Definition at line 9933 of file guc.c.

References config_enum::check_hook, config_enum_lookup_by_value(), ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_enum::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

 {
     /* Quick success if no hook */
     if (!conf->check_hook)
         return true;
 
     /* Reset variables that might be set by hook */
     GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
     GUC_check_errmsg_string = NULL;
     GUC_check_errdetail_string = NULL;
     GUC_check_errhint_string = NULL;
 
     if (!conf->check_hook(newval, extra, source))
     {
         ereport(elevel,
                 (errcode(GUC_check_errcode_value),
                  GUC_check_errmsg_string ?
                  errmsg_internal("%s", GUC_check_errmsg_string) :
                  errmsg("invalid value for parameter \"%s\": \"%s\"",
                         conf->gen.name,
                         config_enum_lookup_by_value(conf, *newval)),
                  GUC_check_errdetail_string ?
                  errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                  GUC_check_errhint_string ?
                  errhint("%s", GUC_check_errhint_string) : 0));
         /* Flush any strings created in ErrorContext */
         FlushErrorState();
         return false;
     }
 
     return true;
 }

static bool call_int_check_hook	(	struct config_int *	conf,
		int *	newval,
		void **	extra,
		GucSource	source,
		int	elevel
	)

static

Definition at line 9831 of file guc.c.

References config_int::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_int::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

 {
     /* Quick success if no hook */
     if (!conf->check_hook)
         return true;
 
     /* Reset variables that might be set by hook */
     GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
     GUC_check_errmsg_string = NULL;
     GUC_check_errdetail_string = NULL;
     GUC_check_errhint_string = NULL;
 
     if (!conf->check_hook(newval, extra, source))
     {
         ereport(elevel,
                 (errcode(GUC_check_errcode_value),
                  GUC_check_errmsg_string ?
                  errmsg_internal("%s", GUC_check_errmsg_string) :
                  errmsg("invalid value for parameter \"%s\": %d",
                         conf->gen.name, *newval),
                  GUC_check_errdetail_string ?
                  errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                  GUC_check_errhint_string ?
                  errhint("%s", GUC_check_errhint_string) : 0));
         /* Flush any strings created in ErrorContext */
         FlushErrorState();
         return false;
     }
 
     return true;
 }

static bool call_real_check_hook	(	struct config_real *	conf,
		double *	newval,
		void **	extra,
		GucSource	source,
		int	elevel
	)

static

Definition at line 9865 of file guc.c.

References config_real::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_real::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

 {
     /* Quick success if no hook */
     if (!conf->check_hook)
         return true;
 
     /* Reset variables that might be set by hook */
     GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
     GUC_check_errmsg_string = NULL;
     GUC_check_errdetail_string = NULL;
     GUC_check_errhint_string = NULL;
 
     if (!conf->check_hook(newval, extra, source))
     {
         ereport(elevel,
                 (errcode(GUC_check_errcode_value),
                  GUC_check_errmsg_string ?
                  errmsg_internal("%s", GUC_check_errmsg_string) :
                  errmsg("invalid value for parameter \"%s\": %g",
                         conf->gen.name, *newval),
                  GUC_check_errdetail_string ?
                  errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                  GUC_check_errhint_string ?
                  errhint("%s", GUC_check_errhint_string) : 0));
         /* Flush any strings created in ErrorContext */
         FlushErrorState();
         return false;
     }
 
     return true;
 }

static bool call_string_check_hook	(	struct config_string *	conf,
		char **	newval,
		void **	extra,
		GucSource	source,
		int	elevel
	)

static

Definition at line 9899 of file guc.c.

References config_string::check_hook, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), errmsg_internal(), FlushErrorState(), config_string::gen, GUC_check_errcode_value, GUC_check_errdetail_string, GUC_check_errhint_string, GUC_check_errmsg_string, and config_generic::name.

Referenced by InitializeOneGUCOption(), parse_and_validate_value(), and set_config_option().

 {
     /* Quick success if no hook */
     if (!conf->check_hook)
         return true;
 
     /* Reset variables that might be set by hook */
     GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
     GUC_check_errmsg_string = NULL;
     GUC_check_errdetail_string = NULL;
     GUC_check_errhint_string = NULL;
 
     if (!conf->check_hook(newval, extra, source))
     {
         ereport(elevel,
                 (errcode(GUC_check_errcode_value),
                  GUC_check_errmsg_string ?
                  errmsg_internal("%s", GUC_check_errmsg_string) :
                  errmsg("invalid value for parameter \"%s\": \"%s\"",
                         conf->gen.name, *newval ? *newval : ""),
                  GUC_check_errdetail_string ?
                  errdetail_internal("%s", GUC_check_errdetail_string) : 0,
                  GUC_check_errhint_string ?
                  errhint("%s", GUC_check_errhint_string) : 0));
         /* Flush any strings created in ErrorContext */
         FlushErrorState();
         return false;
     }
 
     return true;
 }

static bool can_skip_gucvar ( struct config_generic * gconf )

static

Definition at line 8991 of file guc.c.

References config_generic::context, PGC_INTERNAL, PGC_POSTMASTER, PGC_S_DEFAULT, and config_generic::source.

Referenced by estimate_variable_size(), RestoreGUCState(), and serialize_variable().

 {
     return gconf->context == PGC_POSTMASTER ||
         gconf->context == PGC_INTERNAL || gconf->source == PGC_S_DEFAULT;
 }

static bool check_application_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10459 of file guc.c.

 {
     /* Only allow clean ASCII chars in the application name */
     char       *p;
 
     for (p = *newval; *p; p++)
     {
         if (*p < 32 || *p > 126)
             *p = '?';
     }
 
     return true;
 }

static bool check_autovacuum_max_workers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10361 of file guc.c.

References MAX_BACKENDS, max_worker_processes, and MaxConnections.

 {
     if (MaxConnections + *newval + 1 + max_worker_processes > MAX_BACKENDS)
         return false;
     return true;
 }

static bool check_autovacuum_work_mem	(	int *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10369 of file guc.c.

 {
     /*
      * -1 indicates fallback.
      *
      * If we haven't yet changed the boot_val default of -1, just let it be.
      * Autovacuum will look to maintenance_work_mem instead.
      */
     if (*newval == -1)
         return true;
 
     /*
      * We clamp manually-set values to at least 1MB.  Since
      * maintenance_work_mem is always set to at least this value, do the same
      * here.
      */
     if (*newval < 1024)
         *newval = 1024;
 
     return true;
 }

static bool check_bonjour	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10161 of file guc.c.

References GUC_check_errmsg.

 {
 #ifndef USE_BONJOUR
     if (*newval)
     {
         GUC_check_errmsg("Bonjour is not supported by this build");
         return false;
     }
 #endif
     return true;
 }

static bool check_canonical_path	(	char **	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10212 of file guc.c.

References canonicalize_path().

 {
     /*
      * Since canonicalize_path never enlarges the string, we can just modify
      * newval in-place.  But watch out for NULL, which is the default value
      * for external_pid_file.
      */
     if (*newval)
         canonicalize_path(*newval);
     return true;
 }

static bool check_cluster_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10481 of file guc.c.

 {
     /* Only allow clean ASCII chars in the cluster name */
     char       *p;
 
     for (p = *newval; *p; p++)
     {
         if (*p < 32 || *p > 126)
             *p = '?';
     }
 
     return true;
 }

static bool check_effective_io_concurrency	(	int *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10400 of file guc.c.

References ComputeIoConcurrency(), ERROR, guc_malloc(), and rint().

 {
 #ifdef USE_PREFETCH
     double      new_prefetch_pages;
 
     if (ComputeIoConcurrency(*newval, &new_prefetch_pages))
     {
         int        *myextra = (int *) guc_malloc(ERROR, sizeof(int));
 
         *myextra = (int) rint(new_prefetch_pages);
         *extra = (void *) myextra;
 
         return true;
     }
     else
         return false;
 #else
     return true;
 #endif                          /* USE_PREFETCH */
 }

static bool check_log_destination	(	char **	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10053 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, pfree(), pg_strcasecmp(), pstrdup(), and SplitIdentifierString().

 {
     char       *rawstring;
     List       *elemlist;
     ListCell   *l;
     int         newlogdest = 0;
     int        *myextra;
 
     /* Need a modifiable copy of string */
     rawstring = pstrdup(*newval);
 
     /* Parse string into list of identifiers */
     if (!SplitIdentifierString(rawstring, ',', &elemlist))
     {
         /* syntax error in list */
         GUC_check_errdetail("List syntax is invalid.");
         pfree(rawstring);
         list_free(elemlist);
         return false;
     }
 
     foreach(l, elemlist)
     {
         char       *tok = (char *) lfirst(l);
 
         if (pg_strcasecmp(tok, "stderr") == 0)
             newlogdest |= LOG_DESTINATION_STDERR;
         else if (pg_strcasecmp(tok, "csvlog") == 0)
             newlogdest |= LOG_DESTINATION_CSVLOG;
 #ifdef HAVE_SYSLOG
         else if (pg_strcasecmp(tok, "syslog") == 0)
             newlogdest |= LOG_DESTINATION_SYSLOG;
 #endif
 #ifdef WIN32
         else if (pg_strcasecmp(tok, "eventlog") == 0)
             newlogdest |= LOG_DESTINATION_EVENTLOG;
 #endif
         else
         {
             GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
             pfree(rawstring);
             list_free(elemlist);
             return false;
         }
     }
 
     pfree(rawstring);
     list_free(elemlist);
 
     myextra = (int *) guc_malloc(ERROR, sizeof(int));
     *myextra = newlogdest;
     *extra = (void *) myextra;
 
     return true;
 }

static bool check_log_stats	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10198 of file guc.c.

References GUC_check_errdetail.

 {
     if (*newval &&
         (log_parser_stats || log_planner_stats || log_executor_stats))
     {
         GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
                             "\"log_parser_stats\", \"log_planner_stats\", "
                             "or \"log_executor_stats\" is true.");
         return false;
     }
     return true;
 }

static bool check_max_worker_processes	(	int *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10392 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, and MaxConnections.

 {
     if (MaxConnections + autovacuum_max_workers + 1 + *newval > MAX_BACKENDS)
         return false;
     return true;
 }

static bool check_maxconnections	(	int *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10352 of file guc.c.

References autovacuum_max_workers, MAX_BACKENDS, and max_worker_processes.

 {
     if (*newval + autovacuum_max_workers + 1 +
         max_worker_processes > MAX_BACKENDS)
         return false;
     return true;
 }

static bool check_ssl	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10174 of file guc.c.

References GUC_check_errmsg.

 {
 #ifndef USE_SSL
     if (*newval)
     {
         GUC_check_errmsg("SSL is not supported by this build");
         return false;
     }
 #endif
     return true;
 }

static bool check_stage_log_stats	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10187 of file guc.c.

References GUC_check_errdetail.

 {
     if (*newval && log_statement_stats)
     {
         GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
         return false;
     }
     return true;
 }

static bool check_temp_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10147 of file guc.c.

References GUC_check_errdetail, and NLocBuffer.

 {
     /*
      * Once local buffers have been initialized, it's too late to change this.
      */
     if (NLocBuffer && NLocBuffer != *newval)
     {
         GUC_check_errdetail("\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
         return false;
     }
     return true;
 }

static bool check_timezone_abbreviations	(	char **	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 10225 of file guc.c.

References Assert, load_tzoffsets(), and PGC_S_DEFAULT.

 {
     /*
      * The boot_val given above for timezone_abbreviations is NULL. When we
      * see this we just do nothing.  If this value isn't overridden from the
      * config file then pg_timezone_abbrev_initialize() will eventually
      * replace it with "Default".  This hack has two purposes: to avoid
      * wasting cycles loading values that might soon be overridden from the
      * config file, and to avoid trying to read the timezone abbrev files
      * during InitializeGUCOptions().  The latter doesn't work in an
      * EXEC_BACKEND subprocess because my_exec_path hasn't been set yet and so
      * we can't locate PGSHAREDIR.
      */
     if (*newval == NULL)
     {
         Assert(source == PGC_S_DEFAULT);
         return true;
     }
 
     /* OK, load the file and produce a malloc'd TimeZoneAbbrevTable */
     *extra = load_tzoffsets(*newval);
 
     /* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
     if (!*extra)
         return false;
 
     return true;
 }

static bool check_wal_consistency_checking	(	char **	newval,
		void **	extra,
		GucSource	source
	)

static

Definition at line 9973 of file guc.c.

References ERROR, GUC_check_errdetail, guc_malloc(), lfirst, list_free(), MemSet, pfree(), pg_strcasecmp(), pstrdup(), RmgrData::rm_mask, RM_MAX_ID, RmgrTable, and SplitIdentifierString().

 {
     char       *rawstring;
     List       *elemlist;
     ListCell   *l;
     bool        newwalconsistency[RM_MAX_ID + 1];
 
     /* Initialize the array */
     MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
 
     /* Need a modifiable copy of string */
     rawstring = pstrdup(*newval);
 
     /* Parse string into list of identifiers */
     if (!SplitIdentifierString(rawstring, ',', &elemlist))
     {
         /* syntax error in list */
         GUC_check_errdetail("List syntax is invalid.");
         pfree(rawstring);
         list_free(elemlist);
         return false;
     }
 
     foreach(l, elemlist)
     {
         char       *tok = (char *) lfirst(l);
         bool        found = false;
         RmgrId      rmid;
 
         /* Check for 'all'. */
         if (pg_strcasecmp(tok, "all") == 0)
         {
             for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
                 if (RmgrTable[rmid].rm_mask != NULL)
                     newwalconsistency[rmid] = true;
             found = true;
         }
         else
         {
             /*
              * Check if the token matches with any individual resource
              * manager.
              */
             for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
             {
                 if (pg_strcasecmp(tok, RmgrTable[rmid].rm_name) == 0 &&
                     RmgrTable[rmid].rm_mask != NULL)
                 {
                     newwalconsistency[rmid] = true;
                     found = true;
                 }
             }
         }
 
         /* If a valid resource manager is found, check for the next one. */
         if (!found)
         {
             GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
             pfree(rawstring);
             list_free(elemlist);
             return false;
         }
     }
 
     pfree(rawstring);
     list_free(elemlist);
 
     /* assign new value */
     *extra = guc_malloc(ERROR, (RM_MAX_ID + 1) * sizeof(bool));
     memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
     return true;
 }

static char* config_enum_get_options	(	struct config_enum *	record,
		const char *	prefix,
		const char *	suffix,
		const char *	separator
	)

static

Definition at line 5675 of file guc.c.

References appendBinaryStringInfo(), appendStringInfoString(), StringInfoData::data, config_enum_entry::hidden, initStringInfo(), StringInfoData::len, config_enum_entry::name, and config_enum::options.

Referenced by GetConfigOptionByNum(), and parse_and_validate_value().

 {
     const struct config_enum_entry *entry;
     StringInfoData retstr;
     int         seplen;
 
     initStringInfo(&retstr);
     appendStringInfoString(&retstr, prefix);
 
     seplen = strlen(separator);
     for (entry = record->options; entry && entry->name; entry++)
     {
         if (!entry->hidden)
         {
             appendStringInfoString(&retstr, entry->name);
             appendBinaryStringInfo(&retstr, separator, seplen);
         }
     }
 
     /*
      * All the entries may have been hidden, leaving the string empty if no
      * prefix was given. This indicates a broken GUC setup, since there is no
      * use for an enum without any values, so we just check to make sure we
      * don't write to invalid memory instead of actually trying to do
      * something smart with it.
      */
     if (retstr.len >= seplen)
     {
         /* Replace final separator */
         retstr.data[retstr.len - seplen] = '\0';
         retstr.len -= seplen;
     }
 
     appendStringInfoString(&retstr, suffix);
 
     return retstr.data;
 }

bool config_enum_lookup_by_name	(	struct config_enum *	record,
		const char *	value,
		int *	retval
	)

Definition at line 5649 of file guc.c.

References FALSE, config_enum_entry::name, config_enum::options, pg_strcasecmp(), TRUE, and config_enum_entry::val.

Referenced by parse_and_validate_value().

 {
     const struct config_enum_entry *entry;
 
     for (entry = record->options; entry && entry->name; entry++)
     {
         if (pg_strcasecmp(value, entry->name) == 0)
         {
             *retval = entry->val;
             return TRUE;
         }
     }
 
     *retval = 0;
     return FALSE;
 }

const char* config_enum_lookup_by_value	(	struct config_enum *	record,
		int	val
	)

Definition at line 5626 of file guc.c.

References elog, ERROR, config_enum::gen, config_generic::name, config_enum_entry::name, config_enum::options, and config_enum_entry::val.

Referenced by _ShowOption(), call_enum_check_hook(), estimate_variable_size(), GetConfigOption(), GetConfigOptionByNum(), GetConfigOptionResetString(), printMixedStruct(), and serialize_variable().

 {
     const struct config_enum_entry *entry;
 
     for (entry = record->options; entry && entry->name; entry++)
     {
         if (entry->val == val)
             return entry->name;
     }
 
     elog(ERROR, "could not find enum option %d for %s",
          val, record->gen.name);
     return NULL;                /* silence compiler */
 }

static void convert_from_base_unit	(	int64	base_value,
		int	base_unit,
		int64 *	value,
		const char **	unit
	)

static

Definition at line 5454 of file guc.c.

References Assert, GUC_UNIT_MEMORY, i, memory_unit_conversion_table, unit_conversion::multiplier, time_unit_conversion_table, and unit_conversion::unit.

Referenced by _ShowOption().

 {
     const unit_conversion *table;
     int         i;
 
     *unit = NULL;
 
     if (base_unit & GUC_UNIT_MEMORY)
         table = memory_unit_conversion_table;
     else
         table = time_unit_conversion_table;
 
     for (i = 0; *table[i].unit; i++)
     {
         if (base_unit == table[i].base_unit)
         {
             /*
              * Accept the first conversion that divides the value evenly. We
              * assume that the conversions for each base unit are ordered from
              * greatest unit to the smallest!
              */
             if (table[i].multiplier < 0)
             {
                 *value = base_value * (-table[i].multiplier);
                 *unit = table[i].unit;
                 break;
             }
             else if (base_value % table[i].multiplier == 0)
             {
                 *value = base_value / table[i].multiplier;
                 *unit = table[i].unit;
                 break;
             }
         }
     }
 
     Assert(*unit != NULL);
 }

static bool convert_to_base_unit	(	int64	value,
		const char *	unit,
		int	base_unit,
		int64 *	base_value
	)

static

Definition at line 5421 of file guc.c.

References GUC_UNIT_MEMORY, i, memory_unit_conversion_table, unit_conversion::multiplier, time_unit_conversion_table, and unit_conversion::unit.

Referenced by parse_int().

 {
     const unit_conversion *table;
     int         i;
 
     if (base_unit & GUC_UNIT_MEMORY)
         table = memory_unit_conversion_table;
     else
         table = time_unit_conversion_table;
 
     for (i = 0; *table[i].unit; i++)
     {
         if (base_unit == table[i].base_unit &&
             strcmp(unit, table[i].unit) == 0)
         {
             if (table[i].multiplier < 0)
                 *base_value = value / (-table[i].multiplier);
             else
                 *base_value = value * table[i].multiplier;
             return true;
         }
     }
     return false;
 }

static void define_custom_variable ( struct config_generic * variable )

static

Definition at line 7556 of file guc.c.

References add_guc_variable(), Assert, ereport, errcode(), errmsg(), ERROR, free, config_string::gen, GUC_ACTION_SET, GUC_CUSTOM_PLACEHOLDER, guc_var_compare(), InitializeOneGUCOption(), config_generic::name, name, PGC_STRING, reapply_stacked_values(), config_generic::reset_scontext, config_generic::reset_source, config_string::reset_val, config_generic::scontext, set_config_option(), set_config_sourcefile(), set_string_field(), config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::stack, config_string::variable, and WARNING.

Referenced by DefineCustomBoolVariable(), DefineCustomEnumVariable(), DefineCustomIntVariable(), DefineCustomRealVariable(), and DefineCustomStringVariable().

 {
     const char *name = variable->name;
     const char **nameAddr = &name;
     struct config_string *pHolder;
     struct config_generic **res;
 
     /*
      * See if there's a placeholder by the same name.
      */
     res = (struct config_generic **) bsearch((void *) &nameAddr,
                                              (void *) guc_variables,
                                              num_guc_variables,
                                              sizeof(struct config_generic *),
                                              guc_var_compare);
     if (res == NULL)
     {
         /*
          * No placeholder to replace, so we can just add it ... but first,
          * make sure it's initialized to its default value.
          */
         InitializeOneGUCOption(variable);
         add_guc_variable(variable, ERROR);
         return;
     }
 
     /*
      * This better be a placeholder
      */
     if (((*res)->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INTERNAL_ERROR),
                  errmsg("attempt to redefine parameter \"%s\"", name)));
 
     Assert((*res)->vartype == PGC_STRING);
     pHolder = (struct config_string *) (*res);
 
     /*
      * First, set the variable to its default value.  We must do this even
      * though we intend to immediately apply a new value, since it's possible
      * that the new value is invalid.
      */
     InitializeOneGUCOption(variable);
 
     /*
      * Replace the placeholder. We aren't changing the name, so no re-sorting
      * is necessary
      */
     *res = variable;
 
     /*
      * Assign the string value(s) stored in the placeholder to the real
      * variable.  Essentially, we need to duplicate all the active and stacked
      * values, but with appropriate validation and datatype adjustment.
      *
      * If an assignment fails, we report a WARNING and keep going.  We don't
      * want to throw ERROR for bad values, because it'd bollix the add-on
      * module that's presumably halfway through getting loaded.  In such cases
      * the default or previous state will become active instead.
      */
 
     /* First, apply the reset value if any */
     if (pHolder->reset_val)
         (void) set_config_option(name, pHolder->reset_val,
                                  pHolder->gen.reset_scontext,
                                  pHolder->gen.reset_source,
                                  GUC_ACTION_SET, true, WARNING, false);
     /* That should not have resulted in stacking anything */
     Assert(variable->stack == NULL);
 
     /* Now, apply current and stacked values, in the order they were stacked */
     reapply_stacked_values(variable, pHolder, pHolder->gen.stack,
                            *(pHolder->variable),
                            pHolder->gen.scontext, pHolder->gen.source);
 
     /* Also copy over any saved source-location information */
     if (pHolder->gen.sourcefile)
         set_config_sourcefile(name, pHolder->gen.sourcefile,
                               pHolder->gen.sourceline);
 
     /*
      * Free up as much as we conveniently can of the placeholder structure.
      * (This neglects any stack items, so it's possible for some memory to be
      * leaked.  Since this can only happen once per session per variable, it
      * doesn't seem worth spending much code on.)
      */
     set_string_field(pHolder, pHolder->variable, NULL);
     set_string_field(pHolder, &pHolder->reset_val, NULL);
 
     free(pHolder);
 }

void DefineCustomBoolVariable	(	const char *	name,
		const char *	short_desc,
		const char *	long_desc,
		bool *	valueAddr,
		bool	bootValue,
		GucContext	context,
		int	flags,
		GucBoolCheckHook	check_hook,
		GucBoolAssignHook	assign_hook,
		GucShowHook	show_hook
	)

Definition at line 7737 of file guc.c.

References config_bool::assign_hook, config_bool::boot_val, config_bool::check_hook, define_custom_variable(), config_bool::gen, init_custom_variable(), PGC_BOOL, config_bool::reset_val, config_bool::show_hook, and config_bool::variable.

Referenced by _PG_init().

 {
     struct config_bool *var;
 
     var = (struct config_bool *)
         init_custom_variable(name, short_desc, long_desc, context, flags,
                              PGC_BOOL, sizeof(struct config_bool));
     var->variable = valueAddr;
     var->boot_val = bootValue;
     var->reset_val = bootValue;
     var->check_hook = check_hook;
     var->assign_hook = assign_hook;
     var->show_hook = show_hook;
     define_custom_variable(&var->gen);
 }

void DefineCustomEnumVariable	(	const char *	name,
		const char *	short_desc,
		const char *	long_desc,
		int *	valueAddr,
		int	bootValue,
		const struct config_enum_entry *	options,
		GucContext	context,
		int	flags,
		GucEnumCheckHook	check_hook,
		GucEnumAssignHook	assign_hook,
		GucShowHook	show_hook
	)

Definition at line 7848 of file guc.c.

References config_enum::assign_hook, config_enum::boot_val, config_enum::check_hook, define_custom_variable(), config_enum::gen, init_custom_variable(), options, config_enum::options, PGC_ENUM, config_enum::reset_val, config_enum::show_hook, and config_enum::variable.

Referenced by _PG_init().

 {
     struct config_enum *var;
 
     var = (struct config_enum *)
         init_custom_variable(name, short_desc, long_desc, context, flags,
                              PGC_ENUM, sizeof(struct config_enum));
     var->variable = valueAddr;
     var->boot_val = bootValue;
     var->reset_val = bootValue;
     var->options = options;
     var->check_hook = check_hook;
     var->assign_hook = assign_hook;
     var->show_hook = show_hook;
     define_custom_variable(&var->gen);
 }

void DefineCustomIntVariable	(	const char *	name,
		const char *	short_desc,
		const char *	long_desc,
		int *	valueAddr,
		int	bootValue,
		int	minValue,
		int	maxValue,
		GucContext	context,
		int	flags,
		GucIntCheckHook	check_hook,
		GucIntAssignHook	assign_hook,
		GucShowHook	show_hook
	)

Definition at line 7763 of file guc.c.

References config_int::assign_hook, config_int::boot_val, config_int::check_hook, define_custom_variable(), config_int::gen, init_custom_variable(), config_int::max, config_int::min, PGC_INT, config_int::reset_val, config_int::show_hook, and config_int::variable.

Referenced by _PG_init().

 {
     struct config_int *var;
 
     var = (struct config_int *)
         init_custom_variable(name, short_desc, long_desc, context, flags,
                              PGC_INT, sizeof(struct config_int));
     var->variable = valueAddr;
     var->boot_val = bootValue;
     var->reset_val = bootValue;
     var->min = minValue;
     var->max = maxValue;
     var->check_hook = check_hook;
     var->assign_hook = assign_hook;
     var->show_hook = show_hook;
     define_custom_variable(&var->gen);
 }

void DefineCustomRealVariable	(	const char *	name,
		const char *	short_desc,
		const char *	long_desc,
		double *	valueAddr,
		double	bootValue,
		double	minValue,
		double	maxValue,
		GucContext	context,
		int	flags,
		GucRealCheckHook	check_hook,
		GucRealAssignHook	assign_hook,
		GucShowHook	show_hook
	)

Definition at line 7793 of file guc.c.

References config_real::assign_hook, config_real::boot_val, config_real::check_hook, define_custom_variable(), config_real::gen, init_custom_variable(), config_real::max, config_real::min, PGC_REAL, config_real::reset_val, config_real::show_hook, and config_real::variable.

Referenced by _PG_init().

 {
     struct config_real *var;
 
     var = (struct config_real *)
         init_custom_variable(name, short_desc, long_desc, context, flags,
                              PGC_REAL, sizeof(struct config_real));
     var->variable = valueAddr;
     var->boot_val = bootValue;
     var->reset_val = bootValue;
     var->min = minValue;
     var->max = maxValue;
     var->check_hook = check_hook;
     var->assign_hook = assign_hook;
     var->show_hook = show_hook;
     define_custom_variable(&var->gen);
 }

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 at line 7823 of file guc.c.

References config_string::assign_hook, config_string::boot_val, config_string::check_hook, define_custom_variable(), config_string::gen, init_custom_variable(), PGC_STRING, config_string::show_hook, and config_string::variable.

Referenced by _PG_init().

 {
     struct config_string *var;
 
     var = (struct config_string *)
         init_custom_variable(name, short_desc, long_desc, context, flags,
                              PGC_STRING, sizeof(struct config_string));
     var->variable = valueAddr;
     var->boot_val = bootValue;
     var->check_hook = check_hook;
     var->assign_hook = assign_hook;
     var->show_hook = show_hook;
     define_custom_variable(&var->gen);
 }

static void discard_stack_value	(	struct config_generic *	gconf,
		config_var_value *	val
	)

static

Definition at line 4172 of file guc.c.

References config_var_value::extra, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, set_extra_field(), set_string_field(), config_var_val::stringval, config_var_value::val, and config_generic::vartype.

Referenced by AtEOXact_GUC(), and push_old_value().

 {
     switch (gconf->vartype)
     {
         case PGC_BOOL:
         case PGC_INT:
         case PGC_REAL:
         case PGC_ENUM:
             /* no need to do anything */
             break;
         case PGC_STRING:
             set_string_field((struct config_string *) gconf,
                              &(val->val.stringval),
                              NULL);
             break;
     }
     set_extra_field(gconf, &(val->extra), NULL);
 }

static void do_serialize	(	char **	destptr,
		Size *	maxbytes,
		const char *	fmt,
			...
	)

static

Definition at line 9125 of file guc.c.

References elog, ERROR, and vsnprintf().

Referenced by serialize_variable().

 {
     va_list     vargs;
     int         n;
 
     if (*maxbytes <= 0)
         elog(ERROR, "not enough space to serialize GUC state");
 
     va_start(vargs, fmt);
     n = vsnprintf(*destptr, *maxbytes, fmt, vargs);
     va_end(vargs);
 
     /*
      * Cater to portability hazards in the vsnprintf() return value just like
      * appendPQExpBufferVA() does.  Note that this requires an extra byte of
      * slack at the end of the buffer.  Since serialize_variable() ends with a
      * do_serialize_binary() rather than a do_serialize(), we'll always have
      * that slack; estimate_variable_size() need not add a byte for it.
      */
     if (n < 0 || n >= *maxbytes - 1)
     {
         if (n < 0 && errno != 0 && errno != ENOMEM)
             /* Shouldn't happen. Better show errno description. */
             elog(ERROR, "vsnprintf failed: %m");
         else
             elog(ERROR, "not enough space to serialize GUC state");
     }
 
     /* Shift the destptr ahead of the null terminator */
     *destptr += n + 1;
     *maxbytes -= n + 1;
 }

static void do_serialize_binary	(	char **	destptr,
		Size *	maxbytes,
		void *	val,
		Size	valsize
	)

static

Definition at line 9160 of file guc.c.

References elog, and ERROR.

Referenced by serialize_variable().

 {
     if (valsize > *maxbytes)
         elog(ERROR, "not enough space to serialize GUC state");
 
     memcpy(*destptr, val, valsize);
     *destptr += valsize;
     *maxbytes -= valsize;
 }

void EmitWarningsOnPlaceholders ( const char * className )

Definition at line 7876 of file guc.c.

References ereport, errcode(), errmsg(), config_generic::flags, GUC_CUSTOM_PLACEHOLDER, GUC_QUALIFIER_SEPARATOR, i, config_generic::name, num_guc_variables, and WARNING.

Referenced by _PG_init().

 {
     int         classLen = strlen(className);
     int         i;
 
     for (i = 0; i < num_guc_variables; i++)
     {
         struct config_generic *var = guc_variables[i];
 
         if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
             strncmp(className, var->name, classLen) == 0 &&
             var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
         {
             ereport(WARNING,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("unrecognized configuration parameter \"%s\"",
                             var->name)));
         }
     }
 }

static Size estimate_variable_size ( struct config_generic * gconf )

static

Definition at line 9004 of file guc.c.

References Abs, add_size(), can_skip_gucvar(), config_enum_lookup_by_value(), config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, REALTYPE_PRECISION, config_generic::scontext, config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_int::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by EstimateGUCStateSpace().

 {
     Size        size;
     Size        valsize = 0;
 
     if (can_skip_gucvar(gconf))
         return 0;
 
     /* Name, plus trailing zero byte. */
     size = strlen(gconf->name) + 1;
 
     /* Get the maximum display length of the GUC value. */
     switch (gconf->vartype)
     {
         case PGC_BOOL:
             {
                 valsize = 5;    /* max(strlen('true'), strlen('false')) */
             }
             break;
 
         case PGC_INT:
             {
                 struct config_int *conf = (struct config_int *) gconf;
 
                 /*
                  * Instead of getting the exact display length, use max
                  * length.  Also reduce the max length for typical ranges of
                  * small values.  Maximum value is 2147483647, i.e. 10 chars.
                  * Include one byte for sign.
                  */
                 if (Abs(*conf->variable) < 1000)
                     valsize = 3 + 1;
                 else
                     valsize = 10 + 1;
             }
             break;
 
         case PGC_REAL:
             {
                 /*
                  * We are going to print it with %e with REALTYPE_PRECISION
                  * fractional digits.  Account for sign, leading digit,
                  * decimal point, and exponent with up to 3 digits.  E.g.
                  * -3.99329042340000021e+110
                  */
                 valsize = 1 + 1 + 1 + REALTYPE_PRECISION + 5;
             }
             break;
 
         case PGC_STRING:
             {
                 struct config_string *conf = (struct config_string *) gconf;
 
                 /*
                  * If the value is NULL, we transmit it as an empty string.
                  * Although this is not physically the same value, GUC
                  * generally treats a NULL the same as empty string.
                  */
                 if (*conf->variable)
                     valsize = strlen(*conf->variable);
                 else
                     valsize = 0;
             }
             break;
 
         case PGC_ENUM:
             {
                 struct config_enum *conf = (struct config_enum *) gconf;
 
                 valsize = strlen(config_enum_lookup_by_value(conf, *conf->variable));
             }
             break;
     }
 
     /* Allow space for terminating zero-byte for value */
     size = add_size(size, valsize + 1);
 
     if (gconf->sourcefile)
         size = add_size(size, strlen(gconf->sourcefile));
 
     /* Allow space for terminating zero-byte for sourcefile */
     size = add_size(size, 1);
 
     /* Include line whenever file is nonempty. */
     if (gconf->sourcefile && gconf->sourcefile[0])
         size = add_size(size, sizeof(gconf->sourceline));
 
     size = add_size(size, sizeof(gconf->source));
     size = add_size(size, sizeof(gconf->scontext));
 
     return size;
 }

Size EstimateGUCStateSpace ( void )

Definition at line 9102 of file guc.c.

References add_size(), estimate_variable_size(), i, and num_guc_variables.

Referenced by InitializeParallelDSM().

 {
     Size        size;
     int         i;
 
     /* Add space reqd for saving the data size of the guc state */
     size = sizeof(Size);
 
     /* Add up the space needed for each GUC variable */
     for (i = 0; i < num_guc_variables; i++)
         size = add_size(size,
                         estimate_variable_size(guc_variables[i]));
 
     return size;
 }

void ExecSetVariableStmt	(	VariableSetStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 7293 of file guc.c.

References DefElem::arg, VariableSetStmt::args, Assert, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, ExtractSetVariableArgs(), GUC_ACTION_LOCAL, GUC_ACTION_SET, ImportSnapshot(), VariableSetStmt::is_local, IsInParallelMode(), VariableSetStmt::kind, lfirst, linitial_node, list_make1, VariableSetStmt::name, nodeTag, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, ResetAllOptions(), set_config_option(), SetPGVariable(), strVal, superuser(), T_String, A_Const::val, VAR_RESET, VAR_RESET_ALL, VAR_SET_CURRENT, VAR_SET_DEFAULT, VAR_SET_MULTI, VAR_SET_VALUE, and WarnNoTransactionChain().

Referenced by standard_ProcessUtility().

 {
     GucAction   action = stmt->is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET;
 
     /*
      * Workers synchronize these parameters at the start of the parallel
      * operation; then, we block SET during the operation.
      */
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot set parameters during a parallel operation")));
 
     switch (stmt->kind)
     {
         case VAR_SET_VALUE:
         case VAR_SET_CURRENT:
             if (stmt->is_local)
                 WarnNoTransactionChain(isTopLevel, "SET LOCAL");
             (void) set_config_option(stmt->name,
                                      ExtractSetVariableArgs(stmt),
                                      (superuser() ? PGC_SUSET : PGC_USERSET),
                                      PGC_S_SESSION,
                                      action, true, 0, false);
             break;
         case VAR_SET_MULTI:
 
             /*
              * Special-case SQL syntaxes.  The TRANSACTION and SESSION
              * CHARACTERISTICS cases effectively set more than one variable
              * per statement.  TRANSACTION SNAPSHOT only takes one argument,
              * but we put it here anyway since it's a special case and not
              * related to any GUC variable.
              */
             if (strcmp(stmt->name, "TRANSACTION") == 0)
             {
                 ListCell   *head;
 
                 WarnNoTransactionChain(isTopLevel, "SET TRANSACTION");
 
                 foreach(head, stmt->args)
                 {
                     DefElem    *item = (DefElem *) lfirst(head);
 
                     if (strcmp(item->defname, "transaction_isolation") == 0)
                         SetPGVariable("transaction_isolation",
                                       list_make1(item->arg), stmt->is_local);
                     else if (strcmp(item->defname, "transaction_read_only") == 0)
                         SetPGVariable("transaction_read_only",
                                       list_make1(item->arg), stmt->is_local);
                     else if (strcmp(item->defname, "transaction_deferrable") == 0)
                         SetPGVariable("transaction_deferrable",
                                       list_make1(item->arg), stmt->is_local);
                     else
                         elog(ERROR, "unexpected SET TRANSACTION element: %s",
                              item->defname);
                 }
             }
             else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0)
             {
                 ListCell   *head;
 
                 foreach(head, stmt->args)
                 {
                     DefElem    *item = (DefElem *) lfirst(head);
 
                     if (strcmp(item->defname, "transaction_isolation") == 0)
                         SetPGVariable("default_transaction_isolation",
                                       list_make1(item->arg), stmt->is_local);
                     else if (strcmp(item->defname, "transaction_read_only") == 0)
                         SetPGVariable("default_transaction_read_only",
                                       list_make1(item->arg), stmt->is_local);
                     else if (strcmp(item->defname, "transaction_deferrable") == 0)
                         SetPGVariable("default_transaction_deferrable",
                                       list_make1(item->arg), stmt->is_local);
                     else
                         elog(ERROR, "unexpected SET SESSION element: %s",
                              item->defname);
                 }
             }
             else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
             {
                 A_Const    *con = linitial_node(A_Const, stmt->args);
 
                 if (stmt->is_local)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));
 
                 WarnNoTransactionChain(isTopLevel, "SET TRANSACTION");
                 Assert(nodeTag(&con->val) == T_String);
                 ImportSnapshot(strVal(&con->val));
             }
             else
                 elog(ERROR, "unexpected SET MULTI element: %s",
                      stmt->name);
             break;
         case VAR_SET_DEFAULT:
             if (stmt->is_local)
                 WarnNoTransactionChain(isTopLevel, "SET LOCAL");
             /* fall through */
         case VAR_RESET:
             if (strcmp(stmt->name, "transaction_isolation") == 0)
                 WarnNoTransactionChain(isTopLevel, "RESET TRANSACTION");
 
             (void) set_config_option(stmt->name,
                                      NULL,
                                      (superuser() ? PGC_SUSET : PGC_USERSET),
                                      PGC_S_SESSION,
                                      action, true, 0, false);
             break;
         case VAR_RESET_ALL:
             ResetAllOptions();
             break;
     }
 }

static bool extra_field_used	(	struct config_generic *	gconf,
		void *	extra
	)

static

Definition at line 4073 of file guc.c.

References config_var_value::extra, config_generic::extra, guc_stack::masked, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, guc_stack::prev, guc_stack::prior, config_generic::stack, and config_generic::vartype.

Referenced by set_config_option(), and set_extra_field().

 {
     GucStack   *stack;
 
     if (extra == gconf->extra)
         return true;
     switch (gconf->vartype)
     {
         case PGC_BOOL:
             if (extra == ((struct config_bool *) gconf)->reset_extra)
                 return true;
             break;
         case PGC_INT:
             if (extra == ((struct config_int *) gconf)->reset_extra)
                 return true;
             break;
         case PGC_REAL:
             if (extra == ((struct config_real *) gconf)->reset_extra)
                 return true;
             break;
         case PGC_STRING:
             if (extra == ((struct config_string *) gconf)->reset_extra)
                 return true;
             break;
         case PGC_ENUM:
             if (extra == ((struct config_enum *) gconf)->reset_extra)
                 return true;
             break;
     }
     for (stack = gconf->stack; stack; stack = stack->prev)
     {
         if (extra == stack->prior.extra ||
             extra == stack->masked.extra)
             return true;
     }
 
     return false;
 }

char* ExtractSetVariableArgs ( VariableSetStmt * stmt )

Definition at line 7417 of file guc.c.

References VariableSetStmt::args, flatten_set_variable_args(), GetConfigOptionByName(), VariableSetStmt::kind, VariableSetStmt::name, VAR_SET_CURRENT, and VAR_SET_VALUE.

Referenced by AlterSetting(), AlterSystemSetConfigFile(), ExecSetVariableStmt(), and update_proconfig_value().

 {
     switch (stmt->kind)
     {
         case VAR_SET_VALUE:
             return flatten_set_variable_args(stmt->name, stmt->args);
         case VAR_SET_CURRENT:
             return GetConfigOptionByName(stmt->name, NULL, false);
         default:
             return NULL;
     }
 }

static struct config_generic* find_option	(	const char *	name,
		bool	create_placeholders,
		int	elevel
	)

static

Definition at line 4381 of file guc.c.

References add_placeholder_variable(), Assert, guc_name_compare(), GUC_QUALIFIER_SEPARATOR, guc_var_compare(), i, and name.

Referenced by AlterSystemSetConfigFile(), flatten_set_variable_args(), GetConfigOption(), GetConfigOptionByName(), GetConfigOptionResetString(), GUCArrayAdd(), GUCArrayDelete(), set_config_option(), set_config_sourcefile(), and validate_option_array_item().

 {
     const char **key = &name;
     struct config_generic **res;
     int         i;
 
     Assert(name);
 
     /*
      * By equating const char ** with struct config_generic *, we are assuming
      * the name field is first in config_generic.
      */
     res = (struct config_generic **) bsearch((void *) &key,
                                              (void *) guc_variables,
                                              num_guc_variables,
                                              sizeof(struct config_generic *),
                                              guc_var_compare);
     if (res)
         return *res;
 
     /*
      * See if the name is an obsolete name for a variable.  We assume that the
      * set of supported old names is short enough that a brute-force search is
      * the best way.
      */
     for (i = 0; map_old_guc_names[i] != NULL; i += 2)
     {
         if (guc_name_compare(name, map_old_guc_names[i]) == 0)
             return find_option(map_old_guc_names[i + 1], false, elevel);
     }
 
     if (create_placeholders)
     {
         /*
          * Check if the name is qualified, and if so, add a placeholder.
          */
         if (strchr(name, GUC_QUALIFIER_SEPARATOR) != NULL)
             return add_placeholder_variable(name, elevel);
     }
 
     /* Unknown name */
     return NULL;
 }

static char* flatten_set_variable_args	(	const char *	name,
		List *	args
	)

static

Definition at line 6816 of file guc.c.

References appendStringInfo(), appendStringInfoString(), arg, TypeCast::arg, Assert, buf, CStringGetDatum, StringInfoData::data, DatumGetCString, DirectFunctionCall1, DirectFunctionCall3, elog, ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GUC_LIST_INPUT, GUC_LIST_QUOTE, initStringInfo(), Int32GetDatum, interval_in(), interval_out(), INTERVALOID, intVal, InvalidOid, IsA, lfirst, list_head(), list_length(), NIL, nodeTag, ObjectIdGetDatum, quote_identifier(), strVal, T_Float, T_Integer, T_String, TypeCast::typeName, typenameTypeIdAndMod(), A_Const::val, val, and WARNING.

Referenced by ExtractSetVariableArgs(), and SetPGVariable().

 {
     struct config_generic *record;
     int         flags;
     StringInfoData buf;
     ListCell   *l;
 
     /* Fast path if just DEFAULT */
     if (args == NIL)
         return NULL;
 
     /*
      * Get flags for the variable; if it's not known, use default flags.
      * (Caller might throw error later, but not our business to do so here.)
      */
     record = find_option(name, false, WARNING);
     if (record)
         flags = record->flags;
     else
         flags = 0;
 
     /* Complain if list input and non-list variable */
     if ((flags & GUC_LIST_INPUT) == 0 &&
         list_length(args) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("SET %s takes only one argument", name)));
 
     initStringInfo(&buf);
 
     /*
      * Each list member may be a plain A_Const node, or an A_Const within a
      * TypeCast; the latter case is supported only for ConstInterval arguments
      * (for SET TIME ZONE).
      */
     foreach(l, args)
     {
         Node       *arg = (Node *) lfirst(l);
         char       *val;
         TypeName   *typeName = NULL;
         A_Const    *con;
 
         if (l != list_head(args))
             appendStringInfoString(&buf, ", ");
 
         if (IsA(arg, TypeCast))
         {
             TypeCast   *tc = (TypeCast *) arg;
 
             arg = tc->arg;
             typeName = tc->typeName;
         }
 
         if (!IsA(arg, A_Const))
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(arg));
         con = (A_Const *) arg;
 
         switch (nodeTag(&con->val))
         {
             case T_Integer:
                 appendStringInfo(&buf, "%ld", intVal(&con->val));
                 break;
             case T_Float:
                 /* represented as a string, so just copy it */
                 appendStringInfoString(&buf, strVal(&con->val));
                 break;
             case T_String:
                 val = strVal(&con->val);
                 if (typeName != NULL)
                 {
                     /*
                      * Must be a ConstInterval argument for TIME ZONE. Coerce
                      * to interval and back to normalize the value and account
                      * for any typmod.
                      */
                     Oid         typoid;
                     int32       typmod;
                     Datum       interval;
                     char       *intervalout;
 
                     typenameTypeIdAndMod(NULL, typeName, &typoid, &typmod);
                     Assert(typoid == INTERVALOID);
 
                     interval =
                         DirectFunctionCall3(interval_in,
                                             CStringGetDatum(val),
                                             ObjectIdGetDatum(InvalidOid),
                                             Int32GetDatum(typmod));
 
                     intervalout =
                         DatumGetCString(DirectFunctionCall1(interval_out,
                                                             interval));
                     appendStringInfo(&buf, "INTERVAL '%s'", intervalout);
                 }
                 else
                 {
                     /*
                      * Plain string literal or identifier.  For quote mode,
                      * quote it if it's not a vanilla identifier.
                      */
                     if (flags & GUC_LIST_QUOTE)
                         appendStringInfoString(&buf, quote_identifier(val));
                     else
                         appendStringInfoString(&buf, val);
                 }
                 break;
             default:
                 elog(ERROR, "unrecognized node type: %d",
                      (int) nodeTag(&con->val));
                 break;
         }
     }
 
     return buf.data;
 }

struct config_generic** get_guc_variables ( void )

Definition at line 4196 of file guc.c.

References guc_variables.

Referenced by GucInfoMain().

 {
     return guc_variables;
 }

const char* GetConfigOption	(	const char *	name,
		bool	missing_ok,
		bool	restrict_superuser
	)

Definition at line 6705 of file guc.c.

References buffer, config_enum_lookup_by_value(), DEFAULT_ROLE_READ_ALL_SETTINGS, ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, is_member_of_role(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, snprintf(), and config_generic::vartype.

Referenced by applyRemoteGucs(), and PostmasterMain().

 {
     struct config_generic *record;
     static char buffer[256];
 
     record = find_option(name, false, ERROR);
     if (record == NULL)
     {
         if (missing_ok)
             return NULL;
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("unrecognized configuration parameter \"%s\"",
                         name)));
     }
     if (restrict_superuser &&
         (record->flags & GUC_SUPERUSER_ONLY) &&
         !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
                         name)));
 
     switch (record->vartype)
     {
         case PGC_BOOL:
             return *((struct config_bool *) record)->variable ? "on" : "off";
 
         case PGC_INT:
             snprintf(buffer, sizeof(buffer), "%d",
                      *((struct config_int *) record)->variable);
             return buffer;
 
         case PGC_REAL:
             snprintf(buffer, sizeof(buffer), "%g",
                      *((struct config_real *) record)->variable);
             return buffer;
 
         case PGC_STRING:
             return *((struct config_string *) record)->variable;
 
         case PGC_ENUM:
             return config_enum_lookup_by_value((struct config_enum *) record,
                                                *((struct config_enum *) record)->variable);
     }
     return NULL;
 }

char* GetConfigOptionByName	(	const char *	name,
		const char **	varname,
		bool	missing_ok
	)

Definition at line 8043 of file guc.c.

References _ShowOption(), DEFAULT_ROLE_READ_ALL_SETTINGS, ereport, errcode(), errmsg(), ERROR, find_option(), config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, is_member_of_role(), and config_generic::name.

Referenced by ExtractSetVariableArgs(), GetPGVariableResultDesc(), set_config_by_name(), show_config_by_name(), show_config_by_name_missing_ok(), and ShowGUCConfigOption().

 {
     struct config_generic *record;
 
     record = find_option(name, false, ERROR);
     if (record == NULL)
     {
         if (missing_ok)
         {
             if (varname)
                 *varname = NULL;
             return NULL;
         }
 
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("unrecognized configuration parameter \"%s\"", name)));
     }
 
     if ((record->flags & GUC_SUPERUSER_ONLY) &&
         !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser or a member of pg_read_all_settings to examine \"%s\"",
                         name)));
 
     if (varname)
         *varname = record->name;
 
     return _ShowOption(record, true);
 }

void GetConfigOptionByNum	(	int	varnum,
		const char **	values,
		bool *	noshow
	)

Definition at line 8080 of file guc.c.

References _ShowOption(), Assert, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, buffer, config_enum_get_options(), config_enum_lookup_by_value(), config_generic::context, DEFAULT_ROLE_READ_ALL_SETTINGS, elog, ERROR, config_generic::flags, GetUserId(), config_generic::group, GUC_NO_SHOW_ALL, GUC_PENDING_RESTART, GUC_SUPERUSER_ONLY, GUC_UNIT_BLOCKS, GUC_UNIT_BYTE, GUC_UNIT_KB, GUC_UNIT_MB, GUC_UNIT_MEMORY, GUC_UNIT_MIN, GUC_UNIT_MS, GUC_UNIT_S, GUC_UNIT_TIME, GUC_UNIT_XBLOCKS, is_member_of_role(), config_generic::long_desc, config_int::max, config_real::max, config_int::min, config_real::min, config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_FILE, PGC_STRING, pstrdup(), config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, config_generic::short_desc, snprintf(), config_generic::source, config_generic::sourcefile, config_generic::sourceline, config_generic::status, superuser(), and config_generic::vartype.

Referenced by show_all_settings().

 {
     char        buffer[256];
     struct config_generic *conf;
 
     /* check requested variable number valid */
     Assert((varnum >= 0) && (varnum < num_guc_variables));
 
     conf = guc_variables[varnum];
 
     if (noshow)
     {
         if ((conf->flags & GUC_NO_SHOW_ALL) ||
             ((conf->flags & GUC_SUPERUSER_ONLY) &&
              !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_SETTINGS)))
             *noshow = true;
         else
             *noshow = false;
     }
 
     /* first get the generic attributes */
 
     /* name */
     values[0] = conf->name;
 
     /* setting : use _ShowOption in order to avoid duplicating the logic */
     values[1] = _ShowOption(conf, false);
 
     /* unit */
     if (conf->vartype == PGC_INT)
     {
         switch (conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME))
         {
             case GUC_UNIT_BYTE:
                 values[2] = "B";
                 break;
             case GUC_UNIT_KB:
                 values[2] = "kB";
                 break;
             case GUC_UNIT_MB:
                 values[2] = "MB";
                 break;
             case GUC_UNIT_BLOCKS:
                 snprintf(buffer, sizeof(buffer), "%dkB", BLCKSZ / 1024);
                 values[2] = pstrdup(buffer);
                 break;
             case GUC_UNIT_XBLOCKS:
                 snprintf(buffer, sizeof(buffer), "%dkB", XLOG_BLCKSZ / 1024);
                 values[2] = pstrdup(buffer);
                 break;
             case GUC_UNIT_MS:
                 values[2] = "ms";
                 break;
             case GUC_UNIT_S:
                 values[2] = "s";
                 break;
             case GUC_UNIT_MIN:
                 values[2] = "min";
                 break;
             case 0:
                 values[2] = NULL;
                 break;
             default:
                 elog(ERROR, "unrecognized GUC units value: %d",
                      conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME));
                 values[2] = NULL;
                 break;
         }
     }
     else
         values[2] = NULL;
 
     /* group */
     values[3] = config_group_names[conf->group];
 
     /* short_desc */
     values[4] = conf->short_desc;
 
     /* extra_desc */
     values[5] = conf->long_desc;
 
     /* context */
     values[6] = GucContext_Names[conf->context];
 
     /* vartype */
     values[7] = config_type_names[conf->vartype];
 
     /* source */
     values[8] = GucSource_Names[conf->source];
 
     /* now get the type specific attributes */
     switch (conf->vartype)
     {
         case PGC_BOOL:
             {
                 struct config_bool *lconf = (struct config_bool *) conf;
 
                 /* min_val */
                 values[9] = NULL;
 
                 /* max_val */
                 values[10] = NULL;
 
                 /* enumvals */
                 values[11] = NULL;
 
                 /* boot_val */
                 values[12] = pstrdup(lconf->boot_val ? "on" : "off");
 
                 /* reset_val */
                 values[13] = pstrdup(lconf->reset_val ? "on" : "off");
             }
             break;
 
         case PGC_INT:
             {
                 struct config_int *lconf = (struct config_int *) conf;
 
                 /* min_val */
                 snprintf(buffer, sizeof(buffer), "%d", lconf->min);
                 values[9] = pstrdup(buffer);
 
                 /* max_val */
                 snprintf(buffer, sizeof(buffer), "%d", lconf->max);
                 values[10] = pstrdup(buffer);
 
                 /* enumvals */
                 values[11] = NULL;
 
                 /* boot_val */
                 snprintf(buffer, sizeof(buffer), "%d", lconf->boot_val);
                 values[12] = pstrdup(buffer);
 
                 /* reset_val */
                 snprintf(buffer, sizeof(buffer), "%d", lconf->reset_val);
                 values[13] = pstrdup(buffer);
             }
             break;
 
         case PGC_REAL:
             {
                 struct config_real *lconf = (struct config_real *) conf;
 
                 /* min_val */
                 snprintf(buffer, sizeof(buffer), "%g", lconf->min);
                 values[9] = pstrdup(buffer);
 
                 /* max_val */
                 snprintf(buffer, sizeof(buffer), "%g", lconf->max);
                 values[10] = pstrdup(buffer);
 
                 /* enumvals */
                 values[11] = NULL;
 
                 /* boot_val */
                 snprintf(buffer, sizeof(buffer), "%g", lconf->boot_val);
                 values[12] = pstrdup(buffer);
 
                 /* reset_val */
                 snprintf(buffer, sizeof(buffer), "%g", lconf->reset_val);
                 values[13] = pstrdup(buffer);
             }
             break;
 
         case PGC_STRING:
             {
                 struct config_string *lconf = (struct config_string *) conf;
 
                 /* min_val */
                 values[9] = NULL;
 
                 /* max_val */
                 values[10] = NULL;
 
                 /* enumvals */
                 values[11] = NULL;
 
                 /* boot_val */
                 if (lconf->boot_val == NULL)
                     values[12] = NULL;
                 else
                     values[12] = pstrdup(lconf->boot_val);
 
                 /* reset_val */
                 if (lconf->reset_val == NULL)
                     values[13] = NULL;
                 else
                     values[13] = pstrdup(lconf->reset_val);
             }
             break;
 
         case PGC_ENUM:
             {
                 struct config_enum *lconf = (struct config_enum *) conf;
 
                 /* min_val */
                 values[9] = NULL;
 
                 /* max_val */
                 values[10] = NULL;
 
                 /* enumvals */
 
                 /*
                  * NOTE! enumvals with double quotes in them are not
                  * supported!
                  */
                 values[11] = config_enum_get_options((struct config_enum *) conf,
                                                      "{\"", "\"}", "\",\"");
 
                 /* boot_val */
                 values[12] = pstrdup(config_enum_lookup_by_value(lconf,
                                                                  lconf->boot_val));
 
                 /* reset_val */
                 values[13] = pstrdup(config_enum_lookup_by_value(lconf,
                                                                  lconf->reset_val));
             }
             break;
 
         default:
             {
                 /*
                  * should never get here, but in case we do, set 'em to NULL
                  */
 
                 /* min_val */
                 values[9] = NULL;
 
                 /* max_val */
                 values[10] = NULL;
 
                 /* enumvals */
                 values[11] = NULL;
 
                 /* boot_val */
                 values[12] = NULL;
 
                 /* reset_val */
                 values[13] = NULL;
             }
             break;
     }
 
     /*
      * If the setting came from a config file, set the source location. For
      * security reasons, we don't show source file/line number for
      * non-superusers.
      */
     if (conf->source == PGC_S_FILE && superuser())
     {
         values[14] = conf->sourcefile;
         snprintf(buffer, sizeof(buffer), "%d", conf->sourceline);
         values[15] = pstrdup(buffer);
     }
     else
     {
         values[14] = NULL;
         values[15] = NULL;
     }
 
     values[16] = (conf->status & GUC_PENDING_RESTART) ? "t" : "f";
 }

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation