#include "nodes/parsenodes.h"
#include "tcop/dest.h"
#include "utils/array.h"

Include dependency graph for guc.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	ConfigVariable

struct	config_enum_entry

Macros
#define	MAX_KILOBYTES (INT_MAX / 1024)

#define	PG_AUTOCONF_FILENAME "postgresql.auto.conf"

#define	GUC_QUALIFIER_SEPARATOR '.'

#define	GUC_LIST_INPUT 0x0001 /* input can be list format */

#define	GUC_LIST_QUOTE 0x0002 /* double-quote list elements */

#define	GUC_NO_SHOW_ALL 0x0004 /* exclude from SHOW ALL */

#define	GUC_NO_RESET_ALL 0x0008 /* exclude from RESET ALL */

#define	GUC_REPORT 0x0010 /* auto-report changes to client */

#define	GUC_NOT_IN_SAMPLE 0x0020 /* not in postgresql.conf.sample */

#define	GUC_DISALLOW_IN_FILE 0x0040 /* can't set in postgresql.conf */

#define	GUC_CUSTOM_PLACEHOLDER 0x0080 /* placeholder for custom variable */

#define	GUC_SUPERUSER_ONLY 0x0100 /* show only to superusers */

#define	GUC_IS_NAME 0x0200 /* limit string to NAMEDATALEN-1 */

#define	GUC_NOT_WHILE_SEC_REST 0x0400 /* can't set if security restricted */

#define	GUC_DISALLOW_IN_AUTO_FILE

#define	GUC_UNIT_KB 0x1000 /* value is in kilobytes */

#define	GUC_UNIT_BLOCKS 0x2000 /* value is in blocks */

#define	GUC_UNIT_XBLOCKS 0x3000 /* value is in xlog blocks */

#define	GUC_UNIT_MB 0x4000 /* value is in megabytes */

#define	GUC_UNIT_BYTE 0x8000 /* value is in bytes */

#define	GUC_UNIT_MEMORY 0xF000 /* mask for size-related units */

#define	GUC_UNIT_MS 0x10000 /* value is in milliseconds */

#define	GUC_UNIT_S 0x20000 /* value is in seconds */

#define	GUC_UNIT_MIN 0x30000 /* value is in minutes */

#define	GUC_UNIT_TIME 0xF0000 /* mask for time-related units */

#define	GUC_EXPLAIN 0x100000 /* include in explain */

#define	GUC_RUNTIME_COMPUTED 0x200000

#define	GUC_UNIT (GUC_UNIT_MEMORY \| GUC_UNIT_TIME)

#define	EmitWarningsOnPlaceholders(className) MarkGUCPrefixReserved(className)

#define	GUC_check_errmsg

#define	GUC_check_errdetail

#define	GUC_check_errhint

Typedefs
typedef struct ConfigVariable	ConfigVariable

typedef bool(*	GucBoolCheckHook) (bool newval, void *extra, GucSource source)

typedef bool(*	GucIntCheckHook) (int newval, void *extra, GucSource source)

typedef bool(*	GucRealCheckHook) (double newval, void *extra, GucSource source)

typedef bool(*	GucStringCheckHook) (char newval, void extra, GucSource source)

typedef bool(*	GucEnumCheckHook) (int newval, void *extra, GucSource source)

typedef void(*	GucBoolAssignHook) (bool newval, void *extra)

typedef void(*	GucIntAssignHook) (int newval, void *extra)

typedef void(*	GucRealAssignHook) (double newval, void *extra)

typedef void(*	GucStringAssignHook) (const char newval, void extra)

typedef void(*	GucEnumAssignHook) (int newval, void *extra)

typedef const char (	GucShowHook) (void)

Enumerations
enum	GucContext { PGC_INTERNAL , PGC_POSTMASTER , PGC_SIGHUP , PGC_SU_BACKEND , PGC_BACKEND , PGC_SUSET , PGC_USERSET }

enum	GucSource { PGC_S_DEFAULT , PGC_S_DYNAMIC_DEFAULT , PGC_S_ENV_VAR , PGC_S_FILE , PGC_S_ARGV , PGC_S_GLOBAL , PGC_S_DATABASE , PGC_S_USER , PGC_S_DATABASE_USER , PGC_S_CLIENT , PGC_S_OVERRIDE , PGC_S_INTERACTIVE , PGC_S_TEST , PGC_S_SESSION }

enum	GucAction { GUC_ACTION_SET , GUC_ACTION_LOCAL , GUC_ACTION_SAVE }

Functions
bool	ParseConfigFile (const char config_file, bool strict, const char calling_file, int calling_lineno, int depth, int elevel, ConfigVariable head_p, ConfigVariable tail_p)

bool	ParseConfigFp (FILE fp, const char config_file, int depth, int elevel, ConfigVariable head_p, ConfigVariable tail_p)

bool	ParseConfigDirectory (const char includedir, const char calling_file, int calling_lineno, int depth, int elevel, ConfigVariable head_p, ConfigVariable tail_p)

void	FreeConfigVariables (ConfigVariable *list)

char *	DeescapeQuotedString (const char *s)

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

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	MarkGUCPrefixReserved (const char *className)

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

const char *	GetConfigOptionResetString (const char *name)

int	GetConfigOptionFlags (const char *name, bool missing_ok)

void	ProcessConfigFile (GucContext context)

char *	convert_GUC_name_for_parameter_acl (const char *name)

bool	check_GUC_name_for_parameter_acl (const char *name)

void	InitializeGUCOptions (void)

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

void	ReportChangedGUCOptions (void)

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

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

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

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

void	AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)

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

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

int	GetNumConfigOptions (void)

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

void	GetPGVariable (const char name, DestReceiver dest)

TupleDesc	GetPGVariableResultDesc (const char *name)

void	ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)

char *	ExtractSetVariableArgs (VariableSetStmt *stmt)

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)

Size	EstimateGUCStateSpace (void)

void	SerializeGUCState (Size maxsize, char *start_address)

void	RestoreGUCState (void *gucstate)

void	GUC_check_errcode (int sqlerrcode)

bool	check_default_tablespace (char newval, void extra, GucSource source)

bool	check_temp_tablespaces (char newval, void extra, GucSource source)

void	assign_temp_tablespaces (const char newval, void extra)

bool	check_search_path (char newval, void extra, GucSource source)

void	assign_search_path (const char newval, void extra)

bool	check_wal_buffers (int newval, void *extra, GucSource source)

void	assign_xlog_sync_method (int new_sync_method, void *extra)

bool	check_recovery_prefetch (int new_value, void *extra, GucSource source)

void	assign_recovery_prefetch (int new_value, void *extra)

Variables
PGDLLIMPORT bool	Debug_print_plan

PGDLLIMPORT bool	Debug_print_parse

PGDLLIMPORT bool	Debug_print_rewritten

PGDLLIMPORT bool	Debug_pretty_print

PGDLLIMPORT bool	log_parser_stats

PGDLLIMPORT bool	log_planner_stats

PGDLLIMPORT bool	log_executor_stats

PGDLLIMPORT bool	log_statement_stats

PGDLLIMPORT bool	log_btree_build_stats

PGDLLIMPORT bool	check_function_bodies

PGDLLIMPORT bool	session_auth_is_superuser

PGDLLIMPORT bool	log_duration

PGDLLIMPORT int	log_parameter_max_length

PGDLLIMPORT int	log_parameter_max_length_on_error

PGDLLIMPORT int	log_min_error_statement

PGDLLIMPORT int	log_min_messages

PGDLLIMPORT int	client_min_messages

PGDLLIMPORT int	log_min_duration_sample

PGDLLIMPORT int	log_min_duration_statement

PGDLLIMPORT int	log_temp_files

PGDLLIMPORT double	log_statement_sample_rate

PGDLLIMPORT double	log_xact_sample_rate

PGDLLIMPORT char *	backtrace_functions

PGDLLIMPORT char *	backtrace_symbol_list

PGDLLIMPORT int	temp_file_limit

PGDLLIMPORT int	num_temp_buffers

PGDLLIMPORT char *	cluster_name

PGDLLIMPORT char *	ConfigFileName

PGDLLIMPORT char *	HbaFileName

PGDLLIMPORT char *	IdentFileName

PGDLLIMPORT char *	external_pid_file

PGDLLIMPORT char *	application_name

PGDLLIMPORT int	tcp_keepalives_idle

PGDLLIMPORT int	tcp_keepalives_interval

PGDLLIMPORT int	tcp_keepalives_count

PGDLLIMPORT int	tcp_user_timeout

PGDLLIMPORT char *	GUC_check_errmsg_string

PGDLLIMPORT char *	GUC_check_errdetail_string

PGDLLIMPORT char *	GUC_check_errhint_string

Macro Definition Documentation

◆ EmitWarningsOnPlaceholders

#define EmitWarningsOnPlaceholders ( className ) MarkGUCPrefixReserved(className)

Definition at line 359 of file guc.h.

◆ GUC_check_errdetail

#define GUC_check_errdetail

Value:

pre_format_elog_string(errno, TEXTDOMAIN), \

GUC_check_errdetail_string = format_elog_string

pre_format_elog_string

void pre_format_elog_string(int errnumber, const char *domain)

Definition: elog.c:1462

format_elog_string

char * format_elog_string(const char *fmt,...)

Definition: elog.c:1471

TEXTDOMAIN

#define TEXTDOMAIN

Definition: elog.h:146

Definition at line 427 of file guc.h.

◆ GUC_check_errhint

#define GUC_check_errhint

Value:

pre_format_elog_string(errno, TEXTDOMAIN), \

GUC_check_errhint_string = format_elog_string

Definition at line 431 of file guc.h.

◆ GUC_check_errmsg

#define GUC_check_errmsg

Value:

pre_format_elog_string(errno, TEXTDOMAIN), \

GUC_check_errmsg_string = format_elog_string

Definition at line 423 of file guc.h.

◆ GUC_CUSTOM_PLACEHOLDER

#define GUC_CUSTOM_PLACEHOLDER 0x0080 /* placeholder for custom variable */

Definition at line 211 of file guc.h.

◆ GUC_DISALLOW_IN_AUTO_FILE

#define GUC_DISALLOW_IN_AUTO_FILE

Value:

0x0800 /* can't set in

* PG_AUTOCONF_FILENAME */

Definition at line 215 of file guc.h.

◆ GUC_DISALLOW_IN_FILE

#define GUC_DISALLOW_IN_FILE 0x0040 /* can't set in postgresql.conf */

Definition at line 210 of file guc.h.

◆ GUC_EXPLAIN

#define GUC_EXPLAIN 0x100000 /* include in explain */

Definition at line 229 of file guc.h.

◆ GUC_IS_NAME

#define GUC_IS_NAME 0x0200 /* limit string to NAMEDATALEN-1 */

Definition at line 213 of file guc.h.

◆ GUC_LIST_INPUT

#define GUC_LIST_INPUT 0x0001 /* input can be list format */

Definition at line 204 of file guc.h.

◆ GUC_LIST_QUOTE

#define GUC_LIST_QUOTE 0x0002 /* double-quote list elements */

Definition at line 205 of file guc.h.

◆ GUC_NO_RESET_ALL

#define GUC_NO_RESET_ALL 0x0008 /* exclude from RESET ALL */

Definition at line 207 of file guc.h.

◆ GUC_NO_SHOW_ALL

#define GUC_NO_SHOW_ALL 0x0004 /* exclude from SHOW ALL */

Definition at line 206 of file guc.h.

◆ GUC_NOT_IN_SAMPLE

#define GUC_NOT_IN_SAMPLE 0x0020 /* not in postgresql.conf.sample */

Definition at line 209 of file guc.h.

◆ GUC_NOT_WHILE_SEC_REST

#define GUC_NOT_WHILE_SEC_REST 0x0400 /* can't set if security restricted */

Definition at line 214 of file guc.h.

◆ GUC_QUALIFIER_SEPARATOR

#define GUC_QUALIFIER_SEPARATOR '.'

Definition at line 199 of file guc.h.

◆ GUC_REPORT

#define GUC_REPORT 0x0010 /* auto-report changes to client */

Definition at line 208 of file guc.h.

◆ GUC_RUNTIME_COMPUTED

#define GUC_RUNTIME_COMPUTED 0x200000

Definition at line 235 of file guc.h.

◆ GUC_SUPERUSER_ONLY

#define GUC_SUPERUSER_ONLY 0x0100 /* show only to superusers */

Definition at line 212 of file guc.h.

◆ GUC_UNIT

#define GUC_UNIT (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 237 of file guc.h.

◆ GUC_UNIT_BLOCKS

#define GUC_UNIT_BLOCKS 0x2000 /* value is in blocks */

Definition at line 218 of file guc.h.

◆ GUC_UNIT_BYTE

#define GUC_UNIT_BYTE 0x8000 /* value is in bytes */

Definition at line 221 of file guc.h.

◆ GUC_UNIT_KB

#define GUC_UNIT_KB 0x1000 /* value is in kilobytes */

Definition at line 217 of file guc.h.

◆ GUC_UNIT_MB

#define GUC_UNIT_MB 0x4000 /* value is in megabytes */

Definition at line 220 of file guc.h.

◆ GUC_UNIT_MEMORY

#define GUC_UNIT_MEMORY 0xF000 /* mask for size-related units */

Definition at line 222 of file guc.h.

◆ GUC_UNIT_MIN

#define GUC_UNIT_MIN 0x30000 /* value is in minutes */

Definition at line 226 of file guc.h.

◆ GUC_UNIT_MS

#define GUC_UNIT_MS 0x10000 /* value is in milliseconds */

Definition at line 224 of file guc.h.

◆ GUC_UNIT_S

#define GUC_UNIT_S 0x20000 /* value is in seconds */

Definition at line 225 of file guc.h.

◆ GUC_UNIT_TIME

#define GUC_UNIT_TIME 0xF0000 /* mask for time-related units */

Definition at line 227 of file guc.h.

◆ GUC_UNIT_XBLOCKS

#define GUC_UNIT_XBLOCKS 0x3000 /* value is in xlog blocks */

Definition at line 219 of file guc.h.

◆ MAX_KILOBYTES

#define MAX_KILOBYTES (INT_MAX / 1024)

Definition at line 26 of file guc.h.

◆ PG_AUTOCONF_FILENAME

#define PG_AUTOCONF_FILENAME "postgresql.auto.conf"

Definition at line 34 of file guc.h.

Typedef Documentation

◆ ConfigVariable

typedef struct ConfigVariable ConfigVariable

◆ GucBoolAssignHook

typedef void(* GucBoolAssignHook) (bool newval, void *extra)

Definition at line 180 of file guc.h.

◆ GucBoolCheckHook

typedef bool(* GucBoolCheckHook) (bool *newval, void **extra, GucSource source)

Definition at line 174 of file guc.h.

◆ GucEnumAssignHook

typedef void(* GucEnumAssignHook) (int newval, void *extra)

Definition at line 184 of file guc.h.

◆ GucEnumCheckHook

typedef bool(* GucEnumCheckHook) (int *newval, void **extra, GucSource source)

Definition at line 178 of file guc.h.

◆ GucIntAssignHook

typedef void(* GucIntAssignHook) (int newval, void *extra)

Definition at line 181 of file guc.h.

◆ GucIntCheckHook

typedef bool(* GucIntCheckHook) (int *newval, void **extra, GucSource source)

Definition at line 175 of file guc.h.

◆ GucRealAssignHook

typedef void(* GucRealAssignHook) (double newval, void *extra)

Definition at line 182 of file guc.h.

◆ GucRealCheckHook

typedef bool(* GucRealCheckHook) (double *newval, void **extra, GucSource source)

Definition at line 176 of file guc.h.

◆ GucShowHook

typedef const char*(* GucShowHook) (void)

Definition at line 186 of file guc.h.

◆ GucStringAssignHook

typedef void(* GucStringAssignHook) (const char *newval, void *extra)

Definition at line 183 of file guc.h.

◆ GucStringCheckHook

typedef bool(* GucStringCheckHook) (char **newval, void **extra, GucSource source)

Definition at line 177 of file guc.h.

Enumeration Type Documentation

◆ GucAction

enum GucAction

Enumerator
GUC_ACTION_SET
GUC_ACTION_LOCAL
GUC_ACTION_SAVE

Definition at line 191 of file guc.h.

 {
     /* Types of set_config_option actions */
     GUC_ACTION_SET,             /* regular SET command */
     GUC_ACTION_LOCAL,           /* SET LOCAL command */
     GUC_ACTION_SAVE             /* function SET option, or temp assignment */
 } GucAction;

◆ GucContext

enum GucContext

Enumerator
PGC_INTERNAL
PGC_POSTMASTER
PGC_SIGHUP
PGC_SU_BACKEND
PGC_BACKEND
PGC_SUSET
PGC_USERSET

Definition at line 68 of file guc.h.

 {
     PGC_INTERNAL,
     PGC_POSTMASTER,
     PGC_SIGHUP,
     PGC_SU_BACKEND,
     PGC_BACKEND,
     PGC_SUSET,
     PGC_USERSET
 } GucContext;

◆ GucSource

enum GucSource

Enumerator
PGC_S_DEFAULT
PGC_S_DYNAMIC_DEFAULT
PGC_S_ENV_VAR
PGC_S_FILE
PGC_S_ARGV
PGC_S_GLOBAL
PGC_S_DATABASE
PGC_S_USER
PGC_S_DATABASE_USER
PGC_S_CLIENT
PGC_S_OVERRIDE
PGC_S_INTERACTIVE
PGC_S_TEST
PGC_S_SESSION

Definition at line 104 of file guc.h.

 {
     PGC_S_DEFAULT,              /* hard-wired default ("boot_val") */
     PGC_S_DYNAMIC_DEFAULT,      /* default computed during initialization */
     PGC_S_ENV_VAR,              /* postmaster environment variable */
     PGC_S_FILE,                 /* postgresql.conf */
     PGC_S_ARGV,                 /* postmaster command line */
     PGC_S_GLOBAL,               /* global in-database setting */
     PGC_S_DATABASE,             /* per-database setting */
     PGC_S_USER,                 /* per-user setting */
     PGC_S_DATABASE_USER,        /* per-user-and-database setting */
     PGC_S_CLIENT,               /* from client connection request */
     PGC_S_OVERRIDE,             /* special case to forcibly set default */
     PGC_S_INTERACTIVE,          /* dividing line for error reporting */
     PGC_S_TEST,                 /* test per-database or per-user setting */
     PGC_S_SESSION               /* SET command */
 } GucSource;

Function Documentation

◆ AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt * altersysstmt )

Definition at line 8772 of file guc.c.

 {
     char       *name;
     char       *value;
     bool        resetall = false;
     ConfigVariable *head = NULL;
     ConfigVariable *tail = NULL;
     volatile int Tmpfd;
     char        AutoConfFileName[MAXPGPATH];
     char        AutoConfTmpFileName[MAXPGPATH];
  
     /*
      * 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;
     }
  
     /*
      * Check permission to run ALTER SYSTEM on the target variable
      */
     if (!superuser())
     {
         if (resetall)
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
         else
         {
             AclResult   aclresult;
  
             aclresult = pg_parameter_aclcheck(name, GetUserId(),
                                               ACL_ALTER_SYSTEM);
             if (aclresult != ACLCHECK_OK)
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("permission denied to set parameter \"%s\"",
                                 name)));
         }
     }
  
     /*
      * Unless it's RESET_ALL, validate the target variable and value
      */
     if (!resetall)
     {
         struct config_generic *record;
  
         record = find_option(name, false, false, ERROR);
         Assert(record != NULL);
  
         /*
          * 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);
     }
  
     /*
      * Invoke the post-alter hook for setting this GUC variable.  GUCs
      * typically do not have corresponding entries in pg_parameter_acl, so we
      * call the hook using the name rather than a potentially-non-existent
      * OID.  Nonetheless, we pass ParameterAclRelationId so that this call
      * context can be distinguished from others.  (Note that "name" will be
      * NULL in the RESET ALL case.)
      *
      * We do this here rather than at the end, because ALTER SYSTEM is not
      * transactional.  If the hook aborts our transaction, it will be cleaner
      * to do so before we touch any files.
      */
     InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
                                     ACL_ALTER_SYSTEM,
                                     altersysstmt->setstmt->kind,
                                     false);
  
     /*
      * 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);
 }

References ACL_ALTER_SYSTEM, ACLCHECK_OK, AllocateFile(), Assert(), 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(), GetUserId(), GUC_DISALLOW_IN_AUTO_FILE, GUC_DISALLOW_IN_FILE, infile(), InvokeObjectPostAlterHookArgStr, VariableSetStmt::kind, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAXPGPATH, name, VariableSetStmt::name, newval, parse_and_validate_value(), ParseConfigFp(), PG_AUTOCONF_FILENAME, PG_CATCH, PG_END_TRY, pg_parameter_aclcheck(), PG_RE_THROW, PG_TRY, PGC_INTERNAL, PGC_S_FILE, PGC_STRING, replace_auto_config_value(), AlterSystemStmt::setstmt, snprintf, stat, 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().

◆ assign_recovery_prefetch()

void assign_recovery_prefetch	(	int	new_value,
		void *	extra
	)

Definition at line 1081 of file xlogprefetcher.c.

 {
     /* Reconfigure prefetching, because a setting it depends on changed. */
     recovery_prefetch = new_value;
     if (AmStartupProcess())
         XLogPrefetchReconfigure();
 }

References AmStartupProcess, recovery_prefetch, and XLogPrefetchReconfigure().

◆ assign_search_path()

void assign_search_path	(	const char *	newval,
		void *	extra
	)

Definition at line 4356 of file namespace.c.

 {
     /*
      * We mark the path as needing recomputation, but don't do anything until
      * it's needed.  This avoids trying to do database access during GUC
      * initialization, or outside a transaction.
      */
     baseSearchPathValid = false;
 }

References baseSearchPathValid.

◆ assign_temp_tablespaces()

void assign_temp_tablespaces	(	const char *	newval,
		void *	extra
	)

Definition at line 1354 of file tablespace.c.

 {
     temp_tablespaces_extra *myextra = (temp_tablespaces_extra *) extra;
  
     /*
      * If check_temp_tablespaces was executed inside a transaction, then pass
      * the list it made to fd.c.  Otherwise, clear fd.c's list; we must be
      * still outside a transaction, or else restoring during transaction exit,
      * and in either case we can just let the next PrepareTempTablespaces call
      * make things sane.
      */
     if (myextra)
         SetTempTablespaces(myextra->tblSpcs, myextra->numSpcs);
     else
         SetTempTablespaces(NULL, 0);
 }

References temp_tablespaces_extra::numSpcs, SetTempTablespaces(), and temp_tablespaces_extra::tblSpcs.

◆ assign_xlog_sync_method()

void assign_xlog_sync_method	(	int	new_sync_method,
		void *	extra
	)

Definition at line 7926 of file xlog.c.

 {
     if (sync_method != new_sync_method)
     {
         /*
          * To ensure that no blocks escape unsynced, force an fsync on the
          * currently open log segment (if any).  Also, if the open flag is
          * changing, close the log file so it will be reopened (with new flag
          * bit) at next use.
          */
         if (openLogFile >= 0)
         {
             pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
             if (pg_fsync(openLogFile) != 0)
             {
                 char        xlogfname[MAXFNAMELEN];
                 int         save_errno;
  
                 save_errno = errno;
                 XLogFileName(xlogfname, openLogTLI, openLogSegNo,
                              wal_segment_size);
                 errno = save_errno;
                 ereport(PANIC,
                         (errcode_for_file_access(),
                          errmsg("could not fsync file \"%s\": %m", xlogfname)));
             }
  
             pgstat_report_wait_end();
             if (get_sync_bit(sync_method) != get_sync_bit(new_sync_method))
                 XLogFileClose();
         }
     }
 }

References ereport, errcode_for_file_access(), errmsg(), get_sync_bit(), MAXFNAMELEN, openLogFile, openLogSegNo, openLogTLI, PANIC, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), sync_method, WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN, wal_segment_size, XLogFileClose(), and XLogFileName.

◆ AtEOXact_GUC()

void AtEOXact_GUC	(	bool	isCommit,
		int	nestLevel
	)

Definition at line 6481 of file guc.c.

 {
     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 */
                         break;
  
                     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))
             {
                 gconf->status |= GUC_NEEDS_REPORT;
                 report_needed = true;
             }
         }                       /* 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;
 }

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_dirty, GUC_LOCAL, GUC_NEEDS_REPORT, GUC_REPORT, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, guc_variables, GUCNestLevel, 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, report_needed, 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_generic::status, 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(), brin_summarize_range(), bt_index_check_internal(), cluster_rel(), CommitSubTransaction(), CommitTransaction(), DefineIndex(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), PrepareTransaction(), ProcedureCreate(), reindex_index(), ReindexRelationConcurrently(), reset_transmission_modes(), restoreLocalGucs(), RI_Initial_Check(), RI_PartitionRemove_Check(), vacuum_rel(), and validate_index().

◆ AtStart_GUC()

void AtStart_GUC ( void )

Definition at line 6447 of file guc.c.

 {
     /*
      * 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;
 }

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void )

Definition at line 6766 of file guc.c.

 {
     int         i;
  
     /*
      * Don't do anything unless talking to an interactive frontend.
      */
     if (whereToSendOutput != DestRemote)
         return;
  
     reporting_enabled = true;
  
     /*
      * Hack for in_hot_standby: initialize with the value we're about to send.
      * (This could be out of date by the time we actually send it, in which
      * case the next ReportChangedGUCOptions call will send a duplicate
      * report.)
      */
     in_hot_standby = RecoveryInProgress();
  
     /* 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);
     }
  
     report_needed = false;
 }

References DestRemote, config_generic::flags, GUC_REPORT, guc_variables, i, in_hot_standby, num_guc_variables, RecoveryInProgress(), report_needed, ReportGUCOption(), reporting_enabled, and whereToSendOutput.

Referenced by PostgresMain().

◆ check_default_tablespace()

bool check_default_tablespace	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1139 of file tablespace.c.

 {
     /*
      * If we aren't inside a transaction, or connected to a database, we
      * cannot do the catalog accesses necessary to verify the name.  Must
      * accept the value on faith.
      */
     if (IsTransactionState() && MyDatabaseId != InvalidOid)
     {
         if (**newval != '\0' &&
             !OidIsValid(get_tablespace_oid(*newval, true)))
         {
             /*
              * When source == PGC_S_TEST, don't throw a hard error for a
              * nonexistent tablespace, only a NOTICE.  See comments in guc.h.
              */
             if (source == PGC_S_TEST)
             {
                 ereport(NOTICE,
                         (errcode(ERRCODE_UNDEFINED_OBJECT),
                          errmsg("tablespace \"%s\" does not exist",
                                 *newval)));
             }
             else
             {
                 GUC_check_errdetail("Tablespace \"%s\" does not exist.",
                                     *newval);
                 return false;
             }
         }
     }
  
     return true;
 }

References ereport, errcode(), errmsg(), get_tablespace_oid(), GUC_check_errdetail, InvalidOid, IsTransactionState(), MyDatabaseId, newval, NOTICE, OidIsValid, PGC_S_TEST, and source.

◆ check_GUC_name_for_parameter_acl()

bool check_GUC_name_for_parameter_acl ( const char * name )

Definition at line 5817 of file guc.c.

 {
     /* OK if the GUC exists. */
     if (find_option(name, false, true, DEBUG1) != NULL)
         return true;
     /* Otherwise, it'd better be a valid custom GUC name. */
     if (valid_custom_variable_name(name))
         return true;
     return false;
 }

References DEBUG1, find_option(), name, and valid_custom_variable_name().

Referenced by ParameterAclCreate().

◆ check_recovery_prefetch()

bool check_recovery_prefetch	(	int *	new_value,
		void **	extra,
		GucSource	source
	)

Definition at line 1067 of file xlogprefetcher.c.

 {
 #ifndef USE_PREFETCH
     if (*new_value == RECOVERY_PREFETCH_ON)
     {
         GUC_check_errdetail("recovery_prefetch not supported on platforms that lack posix_fadvise().");
         return false;
     }
 #endif
  
     return true;
 }

References GUC_check_errdetail, and RECOVERY_PREFETCH_ON.

◆ check_search_path()

bool check_search_path	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4322 of file namespace.c.

 {
     char       *rawname;
     List       *namelist;
  
     /* Need a modifiable copy of string */
     rawname = pstrdup(*newval);
  
     /* Parse string into list of identifiers */
     if (!SplitIdentifierString(rawname, ',', &namelist))
     {
         /* syntax error in name list */
         GUC_check_errdetail("List syntax is invalid.");
         pfree(rawname);
         list_free(namelist);
         return false;
     }
  
     /*
      * We used to try to check that the named schemas exist, but there are
      * many valid use-cases for having search_path settings that include
      * schemas that don't exist; and often, we are not inside a transaction
      * here and so can't consult the system catalogs anyway.  So now, the only
      * requirement is syntactic validity of the identifier list.
      */
  
     pfree(rawname);
     list_free(namelist);
  
     return true;
 }

References GUC_check_errdetail, list_free(), newval, pfree(), pstrdup(), and SplitIdentifierString().

◆ check_temp_tablespaces()

bool check_temp_tablespaces	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 1246 of file tablespace.c.

 {
     char       *rawname;
     List       *namelist;
  
     /* Need a modifiable copy of string */
     rawname = pstrdup(*newval);
  
     /* Parse string into list of identifiers */
     if (!SplitIdentifierString(rawname, ',', &namelist))
     {
         /* syntax error in name list */
         GUC_check_errdetail("List syntax is invalid.");
         pfree(rawname);
         list_free(namelist);
         return false;
     }
  
     /*
      * If we aren't inside a transaction, or connected to a database, we
      * cannot do the catalog accesses necessary to verify the name.  Must
      * accept the value on faith. Fortunately, there's then also no need to
      * pass the data to fd.c.
      */
     if (IsTransactionState() && MyDatabaseId != InvalidOid)
     {
         temp_tablespaces_extra *myextra;
         Oid        *tblSpcs;
         int         numSpcs;
         ListCell   *l;
  
         /* temporary workspace until we are done verifying the list */
         tblSpcs = (Oid *) palloc(list_length(namelist) * sizeof(Oid));
         numSpcs = 0;
         foreach(l, namelist)
         {
             char       *curname = (char *) lfirst(l);
             Oid         curoid;
             AclResult   aclresult;
  
             /* Allow an empty string (signifying database default) */
             if (curname[0] == '\0')
             {
                 /* InvalidOid signifies database's default tablespace */
                 tblSpcs[numSpcs++] = InvalidOid;
                 continue;
             }
  
             /*
              * In an interactive SET command, we ereport for bad info.  When
              * source == PGC_S_TEST, don't throw a hard error for a
              * nonexistent tablespace, only a NOTICE.  See comments in guc.h.
              */
             curoid = get_tablespace_oid(curname, source <= PGC_S_TEST);
             if (curoid == InvalidOid)
             {
                 if (source == PGC_S_TEST)
                     ereport(NOTICE,
                             (errcode(ERRCODE_UNDEFINED_OBJECT),
                              errmsg("tablespace \"%s\" does not exist",
                                     curname)));
                 continue;
             }
  
             /*
              * Allow explicit specification of database's default tablespace
              * in temp_tablespaces without triggering permissions checks.
              */
             if (curoid == MyDatabaseTableSpace)
             {
                 /* InvalidOid signifies database's default tablespace */
                 tblSpcs[numSpcs++] = InvalidOid;
                 continue;
             }
  
             /* Check permissions, similarly complaining only if interactive */
             aclresult = pg_tablespace_aclcheck(curoid, GetUserId(),
                                                ACL_CREATE);
             if (aclresult != ACLCHECK_OK)
             {
                 if (source >= PGC_S_INTERACTIVE)
                     aclcheck_error(aclresult, OBJECT_TABLESPACE, curname);
                 continue;
             }
  
             tblSpcs[numSpcs++] = curoid;
         }
  
         /* Now prepare an "extra" struct for assign_temp_tablespaces */
         myextra = malloc(offsetof(temp_tablespaces_extra, tblSpcs) +
                          numSpcs * sizeof(Oid));
         if (!myextra)
             return false;
         myextra->numSpcs = numSpcs;
         memcpy(myextra->tblSpcs, tblSpcs, numSpcs * sizeof(Oid));
         *extra = (void *) myextra;
  
         pfree(tblSpcs);
     }
  
     pfree(rawname);
     list_free(namelist);
  
     return true;
 }

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, ereport, errcode(), errmsg(), get_tablespace_oid(), GetUserId(), GUC_check_errdetail, InvalidOid, IsTransactionState(), lfirst, list_free(), list_length(), malloc, MyDatabaseId, MyDatabaseTableSpace, newval, NOTICE, temp_tablespaces_extra::numSpcs, OBJECT_TABLESPACE, offsetof, palloc(), pfree(), pg_tablespace_aclcheck(), PGC_S_INTERACTIVE, PGC_S_TEST, pstrdup(), source, SplitIdentifierString(), and temp_tablespaces_extra::tblSpcs.

◆ check_wal_buffers()

bool check_wal_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4282 of file xlog.c.

 {
     /*
      * -1 indicates a request for auto-tune.
      */
     if (*newval == -1)
     {
         /*
          * If we haven't yet changed the boot_val default of -1, just let it
          * be.  We'll fix it when XLOGShmemSize is called.
          */
         if (XLOGbuffers == -1)
             return true;
  
         /* Otherwise, substitute the auto-tune value */
         *newval = XLOGChooseNumBuffers();
     }
  
     /*
      * We clamp manually-set values to at least 4 blocks.  Prior to PostgreSQL
      * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
      * the case, we just silently treat such values as a request for the
      * minimum.  (We could throw an error instead, but that doesn't seem very
      * helpful.)
      */
     if (*newval < 4)
         *newval = 4;
  
     return true;
 }

References newval, XLOGbuffers, and XLOGChooseNumBuffers().

◆ convert_GUC_name_for_parameter_acl()

char* convert_GUC_name_for_parameter_acl ( const char * name )

Definition at line 5781 of file guc.c.

 {
     char       *result;
  
     /* Apply old-GUC-name mapping. */
     for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
     {
         if (guc_name_compare(name, map_old_guc_names[i]) == 0)
         {
             name = map_old_guc_names[i + 1];
             break;
         }
     }
  
     /* Apply case-folding that matches guc_name_compare(). */
     result = pstrdup(name);
     for (char *ptr = result; *ptr != '\0'; ptr++)
     {
         char        ch = *ptr;
  
         if (ch >= 'A' && ch <= 'Z')
         {
             ch += 'a' - 'A';
             *ptr = ch;
         }
     }
  
     return result;
 }

References guc_name_compare(), i, map_old_guc_names, name, and pstrdup().

Referenced by ParameterAclCreate(), ParameterAclLookup(), and pg_parameter_aclmask().

◆ DeescapeQuotedString()

char* DeescapeQuotedString ( const char * s )

◆ DefineCustomBoolVariable()

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 9476 of file guc.c.

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

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

Referenced by _PG_init().

◆ DefineCustomEnumVariable()

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 9587 of file guc.c.

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

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

Referenced by _PG_init().

◆ DefineCustomIntVariable()

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 9502 of file guc.c.

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

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, name, PGC_INT, config_int::reset_val, config_int::show_hook, and config_int::variable.

Referenced by _PG_init().

◆ DefineCustomRealVariable()

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 9532 of file guc.c.

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

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, name, PGC_REAL, config_real::reset_val, config_real::show_hook, and config_real::variable.

Referenced by _PG_init().

◆ DefineCustomStringVariable()

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 9562 of file guc.c.

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

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

Referenced by _PG_init().

◆ EstimateGUCStateSpace()

Size EstimateGUCStateSpace ( void )

Definition at line 10931 of file guc.c.

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

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

Referenced by InitializeParallelDSM().

◆ ExecSetVariableStmt()

void ExecSetVariableStmt	(	VariableSetStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 9017 of file guc.c.

 {
     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)
                 WarnNoTransactionBlock(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;
  
                 WarnNoTransactionBlock(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")));
  
                 WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
                 ImportSnapshot(strVal(&con->val));
             }
             else
                 elog(ERROR, "unexpected SET MULTI element: %s",
                      stmt->name);
             break;
         case VAR_SET_DEFAULT:
             if (stmt->is_local)
                 WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
             /* fall through */
         case VAR_RESET:
             if (strcmp(stmt->name, "transaction_isolation") == 0)
                 WarnNoTransactionBlock(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;
     }
  
     /* Invoke the post-alter hook for setting this GUC variable, by name. */
     InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, stmt->name,
                                     ACL_SET, stmt->kind, false);
 }

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

Referenced by standard_ProcessUtility().

◆ ExtractSetVariableArgs()

char* ExtractSetVariableArgs ( VariableSetStmt * stmt )

Definition at line 9144 of file guc.c.

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

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

◆ FreeConfigVariables()

void FreeConfigVariables ( ConfigVariable * list )

Referenced by AlterSystemSetConfigFile(), and parse_extension_control_file().

◆ GetConfigOption()

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

Definition at line 8394 of file guc.c.

 {
     struct config_generic *record;
     static char buffer[256];
  
     record = find_option(name, false, missing_ok, ERROR);
     if (record == NULL)
         return NULL;
     if (restrict_privileged &&
         (record->flags & GUC_SUPERUSER_ONLY) &&
         !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser or have privileges 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;
 }

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

Referenced by applyRemoteGucs(), be_tls_init(), and PostmasterMain().

◆ GetConfigOptionByName()

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

Definition at line 9901 of file guc.c.

 {
     struct config_generic *record;
  
     record = find_option(name, false, missing_ok, ERROR);
     if (record == NULL)
     {
         if (varname)
             *varname = NULL;
         return NULL;
     }
  
     if ((record->flags & GUC_SUPERUSER_ONLY) &&
         !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser or have privileges of pg_read_all_settings to examine \"%s\"",
                         name)));
  
     if (varname)
         *varname = record->name;
  
     return _ShowOption(record, true);
 }

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

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

◆ GetConfigOptionByNum()

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

Definition at line 9970 of file guc.c.

 {
     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) &&
              !has_privs_of_role(GetUserId(), ROLE_PG_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 any (NULL is fine) */
     values[2] = get_config_unit_name(conf->flags);
  
     /* group */
     values[3] = _(config_group_names[conf->group]);
  
     /* short_desc */
     values[4] = _(conf->short_desc);
  
     /* extra_desc */
     values[5] = conf->long_desc != NULL ? _(conf->long_desc) : NULL;
  
     /* 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
      * insufficiently-privileged users.
      */
     if (conf->source == PGC_S_FILE &&
         has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
     {
         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";
 }

References _, _ShowOption(), Assert(), config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, config_enum_get_options(), config_enum_lookup_by_value(), config_group_names, config_type_names, config_generic::context, config_generic::flags, get_config_unit_name(), GetUserId(), config_generic::group, GUC_NO_SHOW_ALL, GUC_PENDING_RESTART, GUC_SUPERUSER_ONLY, guc_variables, GucContext_Names, GucSource_Names, has_privs_of_role(), config_generic::long_desc, config_int::max, config_real::max, config_int::min, config_real::min, config_generic::name, num_guc_variables, 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, values, and config_generic::vartype.

Referenced by show_all_settings().

◆ GetConfigOptionFlags()

int GetConfigOptionFlags	(	const char *	name,
		bool	missing_ok
	)

Definition at line 8489 of file guc.c.

 {
     struct config_generic *record;
  
     record = find_option(name, false, missing_ok, ERROR);
     if (record == NULL)
         return 0;
     return record->flags;
 }

References ERROR, find_option(), config_generic::flags, and name.

Referenced by pg_get_functiondef(), and PostmasterMain().

◆ GetConfigOptionResetString()

const char* GetConfigOptionResetString ( const char * name )

Definition at line 8443 of file guc.c.

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

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

Referenced by check_datestyle().

◆ GetNumConfigOptions()

int GetNumConfigOptions ( void )

Definition at line 10198 of file guc.c.

 {
     return num_guc_variables;
 }

References num_guc_variables.

Referenced by GucInfoMain(), and show_all_settings().

◆ GetPGVariable()

void GetPGVariable	(	const char *	name,
		DestReceiver *	dest
	)

Definition at line 9666 of file guc.c.

 {
     if (guc_name_compare(name, "all") == 0)
         ShowAllGUCConfig(dest);
     else
         ShowGUCConfigOption(name, dest);
 }

References generate_unaccent_rules::dest, guc_name_compare(), name, ShowAllGUCConfig(), and ShowGUCConfigOption().

Referenced by exec_replication_command(), and standard_ProcessUtility().

◆ GetPGVariableResultDesc()

TupleDesc GetPGVariableResultDesc ( const char * name )

Definition at line 9675 of file guc.c.

 {
     TupleDesc   tupdesc;
  
     if (guc_name_compare(name, "all") == 0)
     {
         /* need a tuple descriptor representing three TEXT columns */
         tupdesc = CreateTemplateTupleDesc(3);
         TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
                            TEXTOID, -1, 0);
         TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
                            TEXTOID, -1, 0);
         TupleDescInitEntry(tupdesc, (AttrNumber) 3, "description",
                            TEXTOID, -1, 0);
     }
     else
     {
         const char *varname;
  
         /* Get the canonical spelling of name */
         (void) GetConfigOptionByName(name, &varname, false);
  
         /* need a tuple descriptor representing a single TEXT column */
         tupdesc = CreateTemplateTupleDesc(1);
         TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
                            TEXTOID, -1, 0);
     }
     return tupdesc;
 }

References CreateTemplateTupleDesc(), GetConfigOptionByName(), guc_name_compare(), name, and TupleDescInitEntry().

Referenced by UtilityTupleDescriptor().

◆ GUC_check_errcode()

void GUC_check_errcode ( int sqlerrcode )

Definition at line 11726 of file guc.c.

 {
     GUC_check_errcode_value = sqlerrcode;
 }

References GUC_check_errcode_value.

Referenced by check_client_encoding(), check_default_with_oids(), check_role(), check_synchronous_standby_names(), check_transaction_deferrable(), check_transaction_read_only(), and check_XactIsoLevel().

◆ GUCArrayAdd()

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

Definition at line 11428 of file guc.c.

 {
     struct config_generic *record;
     Datum       datum;
     char       *newval;
     ArrayType  *a;
  
     Assert(name);
     Assert(value);
  
     /* test if the option is valid and we're allowed to set it */
     (void) validate_option_array_item(name, value, false);
  
     /* normalize name (converts obsolete GUC names to modern spellings) */
     record = find_option(name, false, true, WARNING);
     if (record)
         name = record->name;
  
     /* build new item for array */
     newval = psprintf("%s=%s", name, value);
     datum = CStringGetTextDatum(newval);
  
     if (array)
     {
         int         index;
         bool        isnull;
         int         i;
  
         Assert(ARR_ELEMTYPE(array) == TEXTOID);
         Assert(ARR_NDIM(array) == 1);
         Assert(ARR_LBOUND(array)[0] == 1);
  
         index = ARR_DIMS(array)[0] + 1; /* add after end */
  
         for (i = 1; i <= ARR_DIMS(array)[0]; i++)
         {
             Datum       d;
             char       *current;
  
             d = array_ref(array, 1, &i,
                           -1 /* varlenarray */ ,
                           -1 /* TEXT's typlen */ ,
                           false /* TEXT's typbyval */ ,
                           TYPALIGN_INT /* TEXT's typalign */ ,
                           &isnull);
             if (isnull)
                 continue;
             current = TextDatumGetCString(d);
  
             /* check for match up through and including '=' */
             if (strncmp(current, newval, strlen(name) + 1) == 0)
             {
                 index = i;
                 break;
             }
         }
  
         a = array_set(array, 1, &index,
                       datum,
                       false,
                       -1 /* varlena array */ ,
                       -1 /* TEXT's typlen */ ,
                       false /* TEXT's typbyval */ ,
                       TYPALIGN_INT /* TEXT's typalign */ );
     }
     else
         a = construct_array(&datum, 1,
                             TEXTOID,
                             -1, false, TYPALIGN_INT);
  
     return a;
 }

References a, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), array_set(), Assert(), construct_array(), CStringGetTextDatum, find_option(), i, name, config_generic::name, newval, psprintf(), TextDatumGetCString, validate_option_array_item(), value, and WARNING.

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayDelete()

ArrayType* GUCArrayDelete	(	ArrayType *	array,
		const char *	name
	)

Definition at line 11508 of file guc.c.

 {
     struct config_generic *record;
     ArrayType  *newarray;
     int         i;
     int         index;
  
     Assert(name);
  
     /* test if the option is valid and we're allowed to set it */
     (void) validate_option_array_item(name, NULL, false);
  
     /* normalize name (converts obsolete GUC names to modern spellings) */
     record = find_option(name, false, true, WARNING);
     if (record)
         name = record->name;
  
     /* if array is currently null, then surely nothing to delete */
     if (!array)
         return NULL;
  
     newarray = NULL;
     index = 1;
  
     for (i = 1; i <= ARR_DIMS(array)[0]; i++)
     {
         Datum       d;
         char       *val;
         bool        isnull;
  
         d = array_ref(array, 1, &i,
                       -1 /* varlenarray */ ,
                       -1 /* TEXT's typlen */ ,
                       false /* TEXT's typbyval */ ,
                       TYPALIGN_INT /* TEXT's typalign */ ,
                       &isnull);
         if (isnull)
             continue;
         val = TextDatumGetCString(d);
  
         /* ignore entry if it's what we want to delete */
         if (strncmp(val, name, strlen(name)) == 0
             && val[strlen(name)] == '=')
             continue;
  
         /* else add it to the output array */
         if (newarray)
             newarray = array_set(newarray, 1, &index,
                                  d,
                                  false,
                                  -1 /* varlenarray */ ,
                                  -1 /* TEXT's typlen */ ,
                                  false /* TEXT's typbyval */ ,
                                  TYPALIGN_INT /* TEXT's typalign */ );
         else
             newarray = construct_array(&d, 1,
                                        TEXTOID,
                                        -1, false, TYPALIGN_INT);
  
         index++;
     }
  
     return newarray;
 }

References ARR_DIMS, array_ref(), array_set(), Assert(), construct_array(), find_option(), i, name, config_generic::name, TextDatumGetCString, val, validate_option_array_item(), and WARNING.

Referenced by AlterSetting(), and update_proconfig_value().

◆ GUCArrayReset()

ArrayType* GUCArrayReset ( ArrayType * array )

Definition at line 11580 of file guc.c.

 {
     ArrayType  *newarray;
     int         i;
     int         index;
  
     /* if array is currently null, nothing to do */
     if (!array)
         return NULL;
  
     /* if we're superuser, we can delete everything, so just do it */
     if (superuser())
         return NULL;
  
     newarray = NULL;
     index = 1;
  
     for (i = 1; i <= ARR_DIMS(array)[0]; i++)
     {
         Datum       d;
         char       *val;
         char       *eqsgn;
         bool        isnull;
  
         d = array_ref(array, 1, &i,
                       -1 /* varlenarray */ ,
                       -1 /* TEXT's typlen */ ,
                       false /* TEXT's typbyval */ ,
                       TYPALIGN_INT /* TEXT's typalign */ ,
                       &isnull);
         if (isnull)
             continue;
         val = TextDatumGetCString(d);
  
         eqsgn = strchr(val, '=');
         *eqsgn = '\0';
  
         /* skip if we have permission to delete it */
         if (validate_option_array_item(val, NULL, true))
             continue;
  
         /* else add it to the output array */
         if (newarray)
             newarray = array_set(newarray, 1, &index,
                                  d,
                                  false,
                                  -1 /* varlenarray */ ,
                                  -1 /* TEXT's typlen */ ,
                                  false /* TEXT's typbyval */ ,
                                  TYPALIGN_INT /* TEXT's typalign */ );
         else
             newarray = construct_array(&d, 1,
                                        TEXTOID,
                                        -1, false, TYPALIGN_INT);
  
         index++;
         pfree(val);
     }
  
     return newarray;
 }

References ARR_DIMS, array_ref(), array_set(), construct_array(), i, pfree(), superuser(), TextDatumGetCString, val, and validate_option_array_item().

Referenced by AlterSetting().

◆ InitializeGUCOptions()

void InitializeGUCOptions ( void )

Definition at line 5836 of file guc.c.

 {
     int         i;
  
     /*
      * Before log_line_prefix could possibly receive a nonempty setting, make
      * sure that timezone processing is minimally alive (see elog.c).
      */
     pg_timezone_initialize();
  
     /*
      * Build sorted array of all GUC variables.
      */
     build_guc_variables();
  
     /*
      * Load all variables with their compiled-in defaults, and initialize
      * status fields as needed.
      */
     for (i = 0; i < num_guc_variables; i++)
     {
         InitializeOneGUCOption(guc_variables[i]);
     }
  
     guc_dirty = false;
  
     reporting_enabled = false;
  
     /*
      * Prevent any attempt to override the transaction modes from
      * non-interactive sources.
      */
     SetConfigOption("transaction_isolation", "read committed",
                     PGC_POSTMASTER, PGC_S_OVERRIDE);
     SetConfigOption("transaction_read_only", "no",
                     PGC_POSTMASTER, PGC_S_OVERRIDE);
     SetConfigOption("transaction_deferrable", "no",
                     PGC_POSTMASTER, PGC_S_OVERRIDE);
  
     /*
      * For historical reasons, some GUC parameters can receive defaults from
      * environment variables.  Process those settings.
      */
     InitializeGUCOptionsFromEnvironment();
 }

References build_guc_variables(), guc_dirty, guc_variables, i, InitializeGUCOptionsFromEnvironment(), InitializeOneGUCOption(), num_guc_variables, pg_timezone_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, reporting_enabled, and SetConfigOption().

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ InitializeWalConsistencyChecking()

void InitializeWalConsistencyChecking ( void )

Definition at line 5889 of file guc.c.

 {
     Assert(process_shared_preload_libraries_done);
  
     if (check_wal_consistency_checking_deferred)
     {
         struct config_generic *guc;
  
         guc = find_option("wal_consistency_checking", false, false, ERROR);
  
         check_wal_consistency_checking_deferred = false;
  
         set_config_option("wal_consistency_checking",
                           wal_consistency_checking_string,
                           PGC_POSTMASTER, guc->source,
                           GUC_ACTION_SET, true, ERROR, false);
  
         /* checking should not be deferred again */
         Assert(!check_wal_consistency_checking_deferred);
     }
 }

References Assert(), check_wal_consistency_checking_deferred, ERROR, find_option(), GUC_ACTION_SET, PGC_POSTMASTER, process_shared_preload_libraries_done, set_config_option(), config_generic::source, and wal_consistency_checking_string.

Referenced by PostmasterMain().

◆ MarkGUCPrefixReserved()

void MarkGUCPrefixReserved ( const char * className )

Definition at line 9623 of file guc.c.

 {
     int         classLen = strlen(className);
     int         i;
     MemoryContext oldcontext;
  
     /*
      * Check for existing placeholders.  We must actually remove invalid
      * placeholders, else future parallel worker startups will fail.  (We
      * don't bother trying to free associated memory, since this shouldn't
      * happen often.)
      */
     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_INVALID_NAME),
                      errmsg("invalid configuration parameter name \"%s\", removing it",
                             var->name),
                      errdetail("\"%s\" is now a reserved prefix.",
                                className)));
             num_guc_variables--;
             memmove(&guc_variables[i], &guc_variables[i + 1],
                     (num_guc_variables - i) * sizeof(struct config_generic *));
         }
     }
  
     /* And remember the name so we can prevent future mistakes. */
     oldcontext = MemoryContextSwitchTo(TopMemoryContext);
     reserved_class_prefix = lappend(reserved_class_prefix, pstrdup(className));
     MemoryContextSwitchTo(oldcontext);
 }

References ereport, errcode(), errdetail(), errmsg(), config_generic::flags, GUC_CUSTOM_PLACEHOLDER, GUC_QUALIFIER_SEPARATOR, guc_variables, i, lappend(), MemoryContextSwitchTo(), config_generic::name, num_guc_variables, pstrdup(), reserved_class_prefix, TopMemoryContext, and WARNING.

Referenced by _PG_init().

◆ NewGUCNestLevel()

int NewGUCNestLevel ( void )

Definition at line 6467 of file guc.c.

 {
     return ++GUCNestLevel;
 }

References GUCNestLevel.

Referenced by applyRemoteGucs(), brin_summarize_range(), bt_index_check_internal(), cluster_rel(), DefineIndex(), do_analyze_rel(), ExecCreateTableAs(), ExecRefreshMatView(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), ProcedureCreate(), PushTransaction(), reindex_index(), ReindexRelationConcurrently(), RI_Initial_Check(), RI_PartitionRemove_Check(), set_transmission_modes(), vacuum_rel(), and validate_index().

◆ parse_int()

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

Definition at line 7098 of file guc.c.

 {
     /*
      * We assume here that double is wide enough to represent any integer
      * value with adequate precision.
      */
     double      val;
     char       *endptr;
  
     /* To suppress compiler warnings, always set output params */
     if (result)
         *result = 0;
     if (hintmsg)
         *hintmsg = NULL;
  
     /*
      * Try to parse as an integer (allowing octal or hex input).  If the
      * conversion stops at a decimal point or 'e', or overflows, re-parse as
      * float.  This should work fine as long as we have no unit names starting
      * with 'e'.  If we ever do, the test could be extended to check for a
      * sign or digit after 'e', but for now that's unnecessary.
      */
     errno = 0;
     val = strtol(value, &endptr, 0);
     if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
         errno == ERANGE)
     {
         errno = 0;
         val = strtod(value, &endptr);
     }
  
     if (endptr == value || errno == ERANGE)
         return false;           /* no HINT for these cases */
  
     /* reject NaN (infinities will fail range check below) */
     if (isnan(val))
         return false;           /* treat same as syntax error; no HINT */
  
     /* allow whitespace between number and unit */
     while (isspace((unsigned char) *endptr))
         endptr++;
  
     /* Handle possible unit */
     if (*endptr != '\0')
     {
         if ((flags & GUC_UNIT) == 0)
             return false;       /* this setting does not accept a unit */
  
         if (!convert_to_base_unit(val,
                                   endptr, (flags & GUC_UNIT),
                                   &val))
         {
             /* invalid unit, or garbage after the unit; set hint and fail. */
             if (hintmsg)
             {
                 if (flags & GUC_UNIT_MEMORY)
                     *hintmsg = memory_units_hint;
                 else
                     *hintmsg = time_units_hint;
             }
             return false;
         }
     }
  
     /* Round to int, then check for overflow */
     val = rint(val);
  
     if (val > INT_MAX || val < INT_MIN)
     {
         if (hintmsg)
             *hintmsg = gettext_noop("Value exceeds integer range.");
         return false;
     }
  
     if (result)
         *result = (int) val;
     return true;
 }

References convert_to_base_unit(), config_generic::flags, gettext_noop, GUC_UNIT, GUC_UNIT_MEMORY, memory_units_hint, time_units_hint, val, and value.

Referenced by apply_server_options(), apply_table_options(), get_batch_size_option(), parse_and_validate_value(), parse_one_reloption(), postgres_fdw_validator(), and postgresAcquireSampleRowsFunc().

◆ parse_real()

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

Definition at line 7188 of file guc.c.

 {
     double      val;
     char       *endptr;
  
     /* To suppress compiler warnings, always set output params */
     if (result)
         *result = 0;
     if (hintmsg)
         *hintmsg = NULL;
  
     errno = 0;
     val = strtod(value, &endptr);
  
     if (endptr == value || errno == ERANGE)
         return false;           /* no HINT for these cases */
  
     /* reject NaN (infinities will fail range checks later) */
     if (isnan(val))
         return false;           /* treat same as syntax error; no HINT */
  
     /* allow whitespace between number and unit */
     while (isspace((unsigned char) *endptr))
         endptr++;
  
     /* Handle possible unit */
     if (*endptr != '\0')
     {
         if ((flags & GUC_UNIT) == 0)
             return false;       /* this setting does not accept a unit */
  
         if (!convert_to_base_unit(val,
                                   endptr, (flags & GUC_UNIT),
                                   &val))
         {
             /* invalid unit, or garbage after the unit; set hint and fail. */
             if (hintmsg)
             {
                 if (flags & GUC_UNIT_MEMORY)
                     *hintmsg = memory_units_hint;
                 else
                     *hintmsg = time_units_hint;
             }
             return false;
         }
     }
  
     if (result)
         *result = val;
     return true;
 }

References convert_to_base_unit(), config_generic::flags, GUC_UNIT, GUC_UNIT_MEMORY, memory_units_hint, time_units_hint, val, and value.

Referenced by apply_server_options(), parse_and_validate_value(), parse_one_reloption(), and postgres_fdw_validator().

◆ ParseConfigDirectory()

bool ParseConfigDirectory	(	const char *	includedir,
		const char *	calling_file,
		int	calling_lineno,
		int	depth,
		int	elevel,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

◆ ParseConfigFile()

bool ParseConfigFile	(	const char *	config_file,
		bool	strict,
		const char *	calling_file,
		int	calling_lineno,
		int	depth,
		int	elevel,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

◆ ParseConfigFp()

bool ParseConfigFp	(	FILE *	fp,
		const char *	config_file,
		int	depth,
		int	elevel,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

Referenced by AlterSystemSetConfigFile(), and parse_extension_control_file().

◆ ParseLongOption()

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

Definition at line 11325 of file guc.c.

 {
     size_t      equal_pos;
     char       *cp;
  
     AssertArg(string);
     AssertArg(name);
     AssertArg(value);
  
     equal_pos = strcspn(string, "=");
  
     if (string[equal_pos] == '=')
     {
         *name = guc_malloc(FATAL, equal_pos + 1);
         strlcpy(*name, string, equal_pos + 1);
  
         *value = guc_strdup(FATAL, &string[equal_pos + 1]);
     }
     else
     {
         /* no equal sign in string */
         *name = guc_strdup(FATAL, string);
         *value = NULL;
     }
  
     for (cp = *name; *cp; cp++)
         if (*cp == '-')
             *cp = '_';
 }

References AssertArg, FATAL, guc_malloc(), guc_strdup(), name, strlcpy(), and value.

Referenced by BootstrapModeMain(), PostmasterMain(), process_postgres_switches(), and ProcessGUCArray().

◆ ProcessConfigFile()

◆ ProcessGUCArray()

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

Definition at line 11363 of file guc.c.

 {
     int         i;
  
     Assert(array != NULL);
     Assert(ARR_ELEMTYPE(array) == TEXTOID);
     Assert(ARR_NDIM(array) == 1);
     Assert(ARR_LBOUND(array)[0] == 1);
  
     for (i = 1; i <= ARR_DIMS(array)[0]; i++)
     {
         Datum       d;
         bool        isnull;
         char       *s;
         char       *name;
         char       *value;
         char       *namecopy;
         char       *valuecopy;
  
         d = array_ref(array, 1, &i,
                       -1 /* varlenarray */ ,
                       -1 /* TEXT's typlen */ ,
                       false /* TEXT's typbyval */ ,
                       TYPALIGN_INT /* TEXT's typalign */ ,
                       &isnull);
  
         if (isnull)
             continue;
  
         s = TextDatumGetCString(d);
  
         ParseLongOption(s, &name, &value);
         if (!value)
         {
             ereport(WARNING,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("could not parse setting for parameter \"%s\"",
                             name)));
             free(name);
             continue;
         }
  
         /* free malloc'd strings immediately to avoid leak upon error */
         namecopy = pstrdup(name);
         free(name);
         valuecopy = pstrdup(value);
         free(value);
  
         (void) set_config_option(namecopy, valuecopy,
                                  context, source,
                                  action, true, 0, false);
  
         pfree(namecopy);
         pfree(valuecopy);
         pfree(s);
     }
 }

References generate_unaccent_rules::action, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert(), ereport, errcode(), errmsg(), free, i, name, ParseLongOption(), pfree(), pstrdup(), set_config_option(), source, TextDatumGetCString, value, and WARNING.

Referenced by ApplySetting(), fmgr_security_definer(), and ProcedureCreate().

◆ ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void )

Definition at line 6812 of file guc.c.

 {
     /* Quick exit if not (yet) enabled */
     if (!reporting_enabled)
         return;
  
     /*
      * Since in_hot_standby isn't actually changed by normal GUC actions, we
      * need a hack to check whether a new value needs to be reported to the
      * client.  For speed, we rely on the assumption that it can never
      * transition from false to true.
      */
     if (in_hot_standby && !RecoveryInProgress())
     {
         struct config_generic *record;
  
         record = find_option("in_hot_standby", false, false, ERROR);
         Assert(record != NULL);
         record->status |= GUC_NEEDS_REPORT;
         report_needed = true;
         in_hot_standby = false;
     }
  
     /* Quick exit if no values have been changed */
     if (!report_needed)
         return;
  
     /* Transmit new values of interesting variables */
     for (int i = 0; i < num_guc_variables; i++)
     {
         struct config_generic *conf = guc_variables[i];
  
         if ((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT))
             ReportGUCOption(conf);
     }
  
     report_needed = false;
 }

References Assert(), ERROR, find_option(), config_generic::flags, GUC_NEEDS_REPORT, GUC_REPORT, guc_variables, i, in_hot_standby, num_guc_variables, RecoveryInProgress(), report_needed, ReportGUCOption(), reporting_enabled, and config_generic::status.

Referenced by PostgresMain().

◆ ResetAllOptions()

void ResetAllOptions ( void )

Definition at line 6263 of file guc.c.

 {
     int         i;
  
     for (i = 0; i < num_guc_variables; i++)
     {
         struct config_generic *gconf = guc_variables[i];
  
         /* Don't reset non-SET-able values */
         if (gconf->context != PGC_SUSET &&
             gconf->context != PGC_USERSET)
             continue;
         /* Don't reset if special exclusion from RESET ALL */
         if (gconf->flags & GUC_NO_RESET_ALL)
             continue;
         /* No need to reset if wasn't SET */
         if (gconf->source <= PGC_S_OVERRIDE)
             continue;
  
         /* Save old value to support transaction abort */
         push_old_value(gconf, GUC_ACTION_SET);
  
         switch (gconf->vartype)
         {
             case PGC_BOOL:
                 {
                     struct config_bool *conf = (struct config_bool *) gconf;
  
                     if (conf->assign_hook)
                         conf->assign_hook(conf->reset_val,
                                           conf->reset_extra);
                     *conf->variable = conf->reset_val;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     conf->reset_extra);
                     break;
                 }
             case PGC_INT:
                 {
                     struct config_int *conf = (struct config_int *) gconf;
  
                     if (conf->assign_hook)
                         conf->assign_hook(conf->reset_val,
                                           conf->reset_extra);
                     *conf->variable = conf->reset_val;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     conf->reset_extra);
                     break;
                 }
             case PGC_REAL:
                 {
                     struct config_real *conf = (struct config_real *) gconf;
  
                     if (conf->assign_hook)
                         conf->assign_hook(conf->reset_val,
                                           conf->reset_extra);
                     *conf->variable = conf->reset_val;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     conf->reset_extra);
                     break;
                 }
             case PGC_STRING:
                 {
                     struct config_string *conf = (struct config_string *) gconf;
  
                     if (conf->assign_hook)
                         conf->assign_hook(conf->reset_val,
                                           conf->reset_extra);
                     set_string_field(conf, conf->variable, conf->reset_val);
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     conf->reset_extra);
                     break;
                 }
             case PGC_ENUM:
                 {
                     struct config_enum *conf = (struct config_enum *) gconf;
  
                     if (conf->assign_hook)
                         conf->assign_hook(conf->reset_val,
                                           conf->reset_extra);
                     *conf->variable = conf->reset_val;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     conf->reset_extra);
                     break;
                 }
         }
  
         gconf->source = gconf->reset_source;
         gconf->scontext = gconf->reset_scontext;
  
         if (gconf->flags & GUC_REPORT)
         {
             gconf->status |= GUC_NEEDS_REPORT;
             report_needed = true;
         }
     }
 }

References config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_generic::context, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_ACTION_SET, GUC_NEEDS_REPORT, GUC_NO_RESET_ALL, GUC_REPORT, guc_variables, i, num_guc_variables, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_OVERRIDE, PGC_STRING, PGC_SUSET, PGC_USERSET, push_old_value(), report_needed, config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, config_generic::scontext, set_extra_field(), set_string_field(), config_generic::source, config_generic::status, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by DiscardAll(), and ExecSetVariableStmt().

◆ RestoreGUCState()

void RestoreGUCState ( void * gucstate )

Definition at line 11160 of file guc.c.

 {
     char       *varname,
                *varvalue,
                *varsourcefile;
     int         varsourceline;
     GucSource   varsource;
     GucContext  varscontext;
     char       *srcptr = (char *) gucstate;
     char       *srcend;
     Size        len;
     int         i;
     ErrorContextCallback error_context_callback;
  
     /*
      * First, ensure that all potentially-shippable GUCs are reset to their
      * default values.  We must not touch those GUCs that the leader will
      * never ship, while there is no need to touch those that are shippable
      * but already have their default values.  Thus, this ends up being the
      * same test that SerializeGUCState uses, even though the sets of
      * variables involved may well be different since the leader's set of
      * variables-not-at-default-values can differ from the set that are
      * not-default in this freshly started worker.
      *
      * Once we have set all the potentially-shippable GUCs to default values,
      * restoring the GUCs that the leader sent (because they had non-default
      * values over there) leads us to exactly the set of GUC values that the
      * leader has.  This is true even though the worker may have initially
      * absorbed postgresql.conf settings that the leader hasn't yet seen, or
      * ALTER USER/DATABASE SET settings that were established after the leader
      * started.
      *
      * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
      * also ensures that set_config_option won't refuse to set them because of
      * source-priority comparisons.
      */
     for (i = 0; i < num_guc_variables; i++)
     {
         struct config_generic *gconf = guc_variables[i];
  
         /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
         if (can_skip_gucvar(gconf))
             continue;
  
         /*
          * We can use InitializeOneGUCOption to reset the GUC to default, but
          * first we must free any existing subsidiary data to avoid leaking
          * memory.  The stack must be empty, but we have to clean up all other
          * fields.  Beware that there might be duplicate value or "extra"
          * pointers.
          */
         Assert(gconf->stack == NULL);
         if (gconf->extra)
             free(gconf->extra);
         if (gconf->last_reported)   /* probably can't happen */
             free(gconf->last_reported);
         if (gconf->sourcefile)
             free(gconf->sourcefile);
         switch (gconf->vartype)
         {
             case PGC_BOOL:
                 {
                     struct config_bool *conf = (struct config_bool *) gconf;
  
                     if (conf->reset_extra && conf->reset_extra != gconf->extra)
                         free(conf->reset_extra);
                     break;
                 }
             case PGC_INT:
                 {
                     struct config_int *conf = (struct config_int *) gconf;
  
                     if (conf->reset_extra && conf->reset_extra != gconf->extra)
                         free(conf->reset_extra);
                     break;
                 }
             case PGC_REAL:
                 {
                     struct config_real *conf = (struct config_real *) gconf;
  
                     if (conf->reset_extra && conf->reset_extra != gconf->extra)
                         free(conf->reset_extra);
                     break;
                 }
             case PGC_STRING:
                 {
                     struct config_string *conf = (struct config_string *) gconf;
  
                     if (*conf->variable)
                         free(*conf->variable);
                     if (conf->reset_val && conf->reset_val != *conf->variable)
                         free(conf->reset_val);
                     if (conf->reset_extra && conf->reset_extra != gconf->extra)
                         free(conf->reset_extra);
                     break;
                 }
             case PGC_ENUM:
                 {
                     struct config_enum *conf = (struct config_enum *) gconf;
  
                     if (conf->reset_extra && conf->reset_extra != gconf->extra)
                         free(conf->reset_extra);
                     break;
                 }
         }
         /* Now we can reset the struct to PGS_S_DEFAULT state. */
         InitializeOneGUCOption(gconf);
     }
  
     /* First item is the length of the subsequent data */
     memcpy(&len, gucstate, sizeof(len));
  
     srcptr += sizeof(len);
     srcend = srcptr + len;
  
     /* If the GUC value check fails, we want errors to show useful context. */
     error_context_callback.callback = guc_restore_error_context_callback;
     error_context_callback.previous = error_context_stack;
     error_context_callback.arg = NULL;
     error_context_stack = &error_context_callback;
  
     /* Restore all the listed GUCs. */
     while (srcptr < srcend)
     {
         int         result;
         char       *error_context_name_and_value[2];
  
         varname = read_gucstate(&srcptr, srcend);
         varvalue = read_gucstate(&srcptr, srcend);
         varsourcefile = read_gucstate(&srcptr, srcend);
         if (varsourcefile[0])
             read_gucstate_binary(&srcptr, srcend,
                                  &varsourceline, sizeof(varsourceline));
         else
             varsourceline = 0;
         read_gucstate_binary(&srcptr, srcend,
                              &varsource, sizeof(varsource));
         read_gucstate_binary(&srcptr, srcend,
                              &varscontext, sizeof(varscontext));
  
         error_context_name_and_value[0] = varname;
         error_context_name_and_value[1] = varvalue;
         error_context_callback.arg = &error_context_name_and_value[0];
         result = set_config_option(varname, varvalue, varscontext, varsource,
                                    GUC_ACTION_SET, true, ERROR, true);
         if (result <= 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INTERNAL_ERROR),
                      errmsg("parameter \"%s\" could not be set", varname)));
         if (varsourcefile[0])
             set_config_sourcefile(varname, varsourcefile, varsourceline);
         error_context_callback.arg = NULL;
     }
  
     error_context_stack = error_context_callback.previous;
 }

References ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, can_skip_gucvar(), ereport, errcode(), errmsg(), ERROR, error_context_stack, config_generic::extra, free, GUC_ACTION_SET, guc_restore_error_context_callback(), guc_variables, i, InitializeOneGUCOption(), config_generic::last_reported, len, num_guc_variables, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, ErrorContextCallback::previous, read_gucstate(), read_gucstate_binary(), config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_string::reset_val, set_config_option(), set_config_sourcefile(), config_generic::sourcefile, config_generic::stack, config_string::variable, and config_generic::vartype.

Referenced by ParallelWorkerMain().

◆ SelectConfigFiles()

bool SelectConfigFiles	(	const char *	userDoption,
		const char *	progname
	)

Definition at line 6088 of file guc.c.

 {
     char       *configdir;
     char       *fname;
     struct stat stat_buf;
  
     /* configdir is -D option, or $PGDATA if no -D */
     if (userDoption)
         configdir = make_absolute_path(userDoption);
     else
         configdir = make_absolute_path(getenv("PGDATA"));
  
     if (configdir && stat(configdir, &stat_buf) != 0)
     {
         write_stderr("%s: could not access directory \"%s\": %s\n",
                      progname,
                      configdir,
                      strerror(errno));
         if (errno == ENOENT)
             write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
         return false;
     }
  
     /*
      * Find the configuration file: if config_file was specified on the
      * command line, use it, else use configdir/postgresql.conf.  In any case
      * ensure the result is an absolute path, so that it will be interpreted
      * the same way by future backends.
      */
     if (ConfigFileName)
         fname = make_absolute_path(ConfigFileName);
     else if (configdir)
     {
         fname = guc_malloc(FATAL,
                            strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
         sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
     }
     else
     {
         write_stderr("%s does not know where to find the server configuration file.\n"
                      "You must specify the --config-file or -D invocation "
                      "option or set the PGDATA environment variable.\n",
                      progname);
         return false;
     }
  
     /*
      * Set the ConfigFileName GUC variable to its final value, ensuring that
      * it can't be overridden later.
      */
     SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
     free(fname);
  
     /*
      * Now read the config file for the first time.
      */
     if (stat(ConfigFileName, &stat_buf) != 0)
     {
         write_stderr("%s: could not access the server configuration file \"%s\": %s\n",
                      progname, ConfigFileName, strerror(errno));
         free(configdir);
         return false;
     }
  
     /*
      * Read the configuration file for the first time.  This time only the
      * data_directory parameter is picked up to determine the data directory,
      * so that we can read the PG_AUTOCONF_FILENAME file next time.
      */
     ProcessConfigFile(PGC_POSTMASTER);
  
     /*
      * If the data_directory GUC variable has been set, use that as DataDir;
      * otherwise use configdir if set; else punt.
      *
      * Note: SetDataDir will copy and absolute-ize its argument, so we don't
      * have to.
      */
     if (data_directory)
         SetDataDir(data_directory);
     else if (configdir)
         SetDataDir(configdir);
     else
     {
         write_stderr("%s does not know where to find the database system data.\n"
                      "This can be specified as \"data_directory\" in \"%s\", "
                      "or by the -D invocation option, or by the "
                      "PGDATA environment variable.\n",
                      progname, ConfigFileName);
         return false;
     }
  
     /*
      * Reflect the final DataDir value back into the data_directory GUC var.
      * (If you are wondering why we don't just make them a single variable,
      * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
      * child backends specially.  XXX is that still true?  Given that we now
      * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
      * DataDir in advance.)
      */
     SetConfigOption("data_directory", DataDir, PGC_POSTMASTER, PGC_S_OVERRIDE);
  
     /*
      * Now read the config file a second time, allowing any settings in the
      * PG_AUTOCONF_FILENAME file to take effect.  (This is pretty ugly, but
      * since we have to determine the DataDir before we can find the autoconf
      * file, the alternatives seem worse.)
      */
     ProcessConfigFile(PGC_POSTMASTER);
  
     /*
      * If timezone_abbreviations wasn't set in the configuration file, install
      * the default value.  We do it this way because we can't safely install a
      * "real" value until my_exec_path is set, which may not have happened
      * when InitializeGUCOptions runs, so the bootstrap default value cannot
      * be the real desired default.
      */
     pg_timezone_abbrev_initialize();
  
     /*
      * Figure out where pg_hba.conf is, and make sure the path is absolute.
      */
     if (HbaFileName)
         fname = make_absolute_path(HbaFileName);
     else if (configdir)
     {
         fname = guc_malloc(FATAL,
                            strlen(configdir) + strlen(HBA_FILENAME) + 2);
         sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
     }
     else
     {
         write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
                      "This can be specified as \"hba_file\" in \"%s\", "
                      "or by the -D invocation option, or by the "
                      "PGDATA environment variable.\n",
                      progname, ConfigFileName);
         return false;
     }
     SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
     free(fname);
  
     /*
      * Likewise for pg_ident.conf.
      */
     if (IdentFileName)
         fname = make_absolute_path(IdentFileName);
     else if (configdir)
     {
         fname = guc_malloc(FATAL,
                            strlen(configdir) + strlen(IDENT_FILENAME) + 2);
         sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
     }
     else
     {
         write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
                      "This can be specified as \"ident_file\" in \"%s\", "
                      "or by the -D invocation option, or by the "
                      "PGDATA environment variable.\n",
                      progname, ConfigFileName);
         return false;
     }
     SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
     free(fname);
  
     free(configdir);
  
     return true;
 }

References CONFIG_FILENAME, ConfigFileName, data_directory, DataDir, FATAL, free, guc_malloc(), HBA_FILENAME, HbaFileName, IDENT_FILENAME, IdentFileName, make_absolute_path(), pg_timezone_abbrev_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, ProcessConfigFile(), progname, SetConfigOption(), SetDataDir(), sprintf, stat, strerror, userDoption, and write_stderr.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ SerializeGUCState()

void SerializeGUCState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 11074 of file guc.c.

 {
     char       *curptr;
     Size        actual_size;
     Size        bytes_left;
     int         i;
  
     /* Reserve space for saving the actual size of the guc state */
     Assert(maxsize > sizeof(actual_size));
     curptr = start_address + sizeof(actual_size);
     bytes_left = maxsize - sizeof(actual_size);
  
     for (i = 0; i < num_guc_variables; i++)
         serialize_variable(&curptr, &bytes_left, guc_variables[i]);
  
     /* Store actual size without assuming alignment of start_address. */
     actual_size = maxsize - bytes_left - sizeof(actual_size);
     memcpy(start_address, &actual_size, sizeof(actual_size));
 }

References Assert(), guc_variables, i, num_guc_variables, and serialize_variable().

Referenced by InitializeParallelDSM().

◆ set_config_option()

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

Definition at line 7558 of file guc.c.

 {
     struct config_generic *record;
     union config_var_val newval_union;
     void       *newextra = NULL;
     bool        prohibitValueChange = false;
     bool        makeDefault;
  
     if (elevel == 0)
     {
         if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
         {
             /*
              * To avoid cluttering the log, only the postmaster bleats loudly
              * about problems with the config file.
              */
             elevel = IsUnderPostmaster ? DEBUG3 : LOG;
         }
         else if (source == PGC_S_GLOBAL ||
                  source == PGC_S_DATABASE ||
                  source == PGC_S_USER ||
                  source == PGC_S_DATABASE_USER)
             elevel = WARNING;
         else
             elevel = ERROR;
     }
  
     /*
      * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
      * because the current worker will also pop the change.  We're probably
      * dealing with a function having a proconfig entry.  Only the function's
      * body should observe the change, and peer workers do not share in the
      * execution of a function call started by this worker.
      *
      * Other changes might need to affect other workers, so forbid them.
      */
     if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE)
         ereport(elevel,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot set parameters during a parallel operation")));
  
     record = find_option(name, true, false, elevel);
     if (record == NULL)
         return 0;
  
     /*
      * Check if the option can be set at this time. See guc.h for the precise
      * rules.
      */
     switch (record->context)
     {
         case PGC_INTERNAL:
             if (context != PGC_INTERNAL)
             {
                 ereport(elevel,
                         (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                          errmsg("parameter \"%s\" cannot be changed",
                                 name)));
                 return 0;
             }
             break;
         case PGC_POSTMASTER:
             if (context == PGC_SIGHUP)
             {
                 /*
                  * We are re-reading a PGC_POSTMASTER variable from
                  * postgresql.conf.  We can't change the setting, so we should
                  * give a warning if the DBA tries to change it.  However,
                  * because of variant formats, canonicalization by check
                  * hooks, etc, we can't just compare the given string directly
                  * to what's stored.  Set a flag to check below after we have
                  * the final storable value.
                  */
                 prohibitValueChange = true;
             }
             else if (context != PGC_POSTMASTER)
             {
                 ereport(elevel,
                         (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                          errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                 name)));
                 return 0;
             }
             break;
         case PGC_SIGHUP:
             if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
             {
                 ereport(elevel,
                         (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                          errmsg("parameter \"%s\" cannot be changed now",
                                 name)));
                 return 0;
             }
  
             /*
              * Hmm, the idea of the SIGHUP context is "ought to be global, but
              * can be changed after postmaster start". But there's nothing
              * that prevents a crafty administrator from sending SIGHUP
              * signals to individual backends only.
              */
             break;
         case PGC_SU_BACKEND:
             if (context == PGC_BACKEND)
             {
                 /*
                  * Check whether the current user has been granted privilege
                  * to set this GUC.
                  */
                 AclResult   aclresult;
  
                 aclresult = pg_parameter_aclcheck(name, GetUserId(), ACL_SET);
                 if (aclresult != ACLCHECK_OK)
                 {
                     /* No granted privilege */
                     ereport(elevel,
                             (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                              errmsg("permission denied to set parameter \"%s\"",
                                     name)));
                     return 0;
                 }
             }
             /* fall through to process the same as PGC_BACKEND */
             /* FALLTHROUGH */
         case PGC_BACKEND:
             if (context == PGC_SIGHUP)
             {
                 /*
                  * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
                  * the config file, we want to accept the new value in the
                  * postmaster (whence it will propagate to
                  * subsequently-started backends), but ignore it in existing
                  * backends.  This is a tad klugy, but necessary because we
                  * don't re-read the config file during backend start.
                  *
                  * In EXEC_BACKEND builds, this works differently: we load all
                  * non-default settings from the CONFIG_EXEC_PARAMS file
                  * during backend start.  In that case we must accept
                  * PGC_SIGHUP settings, so as to have the same value as if
                  * we'd forked from the postmaster.  This can also happen when
                  * using RestoreGUCState() within a background worker that
                  * needs to have the same settings as the user backend that
                  * started it. is_reload will be true when either situation
                  * applies.
                  */
                 if (IsUnderPostmaster && !is_reload)
                     return -1;
             }
             else if (context != PGC_POSTMASTER &&
                      context != PGC_BACKEND &&
                      context != PGC_SU_BACKEND &&
                      source != PGC_S_CLIENT)
             {
                 ereport(elevel,
                         (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                          errmsg("parameter \"%s\" cannot be set after connection start",
                                 name)));
                 return 0;
             }
             break;
         case PGC_SUSET:
             if (context == PGC_USERSET || context == PGC_BACKEND)
             {
                 /*
                  * Check whether the current user has been granted privilege
                  * to set this GUC.
                  */
                 AclResult   aclresult;
  
                 aclresult = pg_parameter_aclcheck(name, GetUserId(), ACL_SET);
                 if (aclresult != ACLCHECK_OK)
                 {
                     /* No granted privilege */
                     ereport(elevel,
                             (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                              errmsg("permission denied to set parameter \"%s\"",
                                     name)));
                     return 0;
                 }
             }
             break;
         case PGC_USERSET:
             /* always okay */
             break;
     }
  
     /*
      * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
      * security restriction context.  We can reject this regardless of the GUC
      * context or source, mainly because sources that it might be reasonable
      * to override for won't be seen while inside a function.
      *
      * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
      * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
      * An exception might be made if the reset value is assumed to be "safe".
      *
      * Note: this flag is currently used for "session_authorization" and
      * "role".  We need to prohibit changing these inside a local userid
      * context because when we exit it, GUC won't be notified, leaving things
      * out of sync.  (This could be fixed by forcing a new GUC nesting level,
      * but that would change behavior in possibly-undesirable ways.)  Also, we
      * prohibit changing these in a security-restricted operation because
      * otherwise RESET could be used to regain the session user's privileges.
      */
     if (record->flags & GUC_NOT_WHILE_SEC_REST)
     {
         if (InLocalUserIdChange())
         {
             /*
              * Phrasing of this error message is historical, but it's the most
              * common case.
              */
             ereport(elevel,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("cannot set parameter \"%s\" within security-definer function",
                             name)));
             return 0;
         }
         if (InSecurityRestrictedOperation())
         {
             ereport(elevel,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("cannot set parameter \"%s\" within security-restricted operation",
                             name)));
             return 0;
         }
     }
  
     /*
      * Should we set reset/stacked values?  (If so, the behavior is not
      * transactional.)  This is done either when we get a default value from
      * the database's/user's/client's default settings or when we reset a
      * value to its default.
      */
     makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
         ((value != NULL) || source == PGC_S_DEFAULT);
  
     /*
      * Ignore attempted set if overridden by previously processed setting.
      * However, if changeVal is false then plow ahead anyway since we are
      * trying to find out if the value is potentially good, not actually use
      * it. Also keep going if makeDefault is true, since we may want to set
      * the reset/stacked values even if we can't set the variable itself.
      */
     if (record->source > source)
     {
         if (changeVal && !makeDefault)
         {
             elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
                  name);
             return -1;
         }
         changeVal = false;
     }
  
     /*
      * Evaluate value and set variable.
      */
     switch (record->vartype)
     {
         case PGC_BOOL:
             {
                 struct config_bool *conf = (struct config_bool *) record;
  
 #define newval (newval_union.boolval)
  
                 if (value)
                 {
                     if (!parse_and_validate_value(record, name, value,
                                                   source, elevel,
                                                   &newval_union, &newextra))
                         return 0;
                 }
                 else if (source == PGC_S_DEFAULT)
                 {
                     newval = conf->boot_val;
                     if (!call_bool_check_hook(conf, &newval, &newextra,
                                               source, elevel))
                         return 0;
                 }
                 else
                 {
                     newval = conf->reset_val;
                     newextra = conf->reset_extra;
                     source = conf->gen.reset_source;
                     context = conf->gen.reset_scontext;
                 }
  
                 if (prohibitValueChange)
                 {
                     /* Release newextra, unless it's reset_extra */
                     if (newextra && !extra_field_used(&conf->gen, newextra))
                         free(newextra);
  
                     if (*conf->variable != newval)
                     {
                         record->status |= GUC_PENDING_RESTART;
                         ereport(elevel,
                                 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                  errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                         name)));
                         return 0;
                     }
                     record->status &= ~GUC_PENDING_RESTART;
                     return -1;
                 }
  
                 if (changeVal)
                 {
                     /* Save old value to support transaction abort */
                     if (!makeDefault)
                         push_old_value(&conf->gen, action);
  
                     if (conf->assign_hook)
                         conf->assign_hook(newval, newextra);
                     *conf->variable = newval;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     newextra);
                     conf->gen.source = source;
                     conf->gen.scontext = context;
                 }
                 if (makeDefault)
                 {
                     GucStack   *stack;
  
                     if (conf->gen.reset_source <= source)
                     {
                         conf->reset_val = newval;
                         set_extra_field(&conf->gen, &conf->reset_extra,
                                         newextra);
                         conf->gen.reset_source = source;
                         conf->gen.reset_scontext = context;
                     }
                     for (stack = conf->gen.stack; stack; stack = stack->prev)
                     {
                         if (stack->source <= source)
                         {
                             stack->prior.val.boolval = newval;
                             set_extra_field(&conf->gen, &stack->prior.extra,
                                             newextra);
                             stack->source = source;
                             stack->scontext = context;
                         }
                     }
                 }
  
                 /* Perhaps we didn't install newextra anywhere */
                 if (newextra && !extra_field_used(&conf->gen, newextra))
                     free(newextra);
                 break;
  
 #undef newval
             }
  
         case PGC_INT:
             {
                 struct config_int *conf = (struct config_int *) record;
  
 #define newval (newval_union.intval)
  
                 if (value)
                 {
                     if (!parse_and_validate_value(record, name, value,
                                                   source, elevel,
                                                   &newval_union, &newextra))
                         return 0;
                 }
                 else if (source == PGC_S_DEFAULT)
                 {
                     newval = conf->boot_val;
                     if (!call_int_check_hook(conf, &newval, &newextra,
                                              source, elevel))
                         return 0;
                 }
                 else
                 {
                     newval = conf->reset_val;
                     newextra = conf->reset_extra;
                     source = conf->gen.reset_source;
                     context = conf->gen.reset_scontext;
                 }
  
                 if (prohibitValueChange)
                 {
                     /* Release newextra, unless it's reset_extra */
                     if (newextra && !extra_field_used(&conf->gen, newextra))
                         free(newextra);
  
                     if (*conf->variable != newval)
                     {
                         record->status |= GUC_PENDING_RESTART;
                         ereport(elevel,
                                 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                  errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                         name)));
                         return 0;
                     }
                     record->status &= ~GUC_PENDING_RESTART;
                     return -1;
                 }
  
                 if (changeVal)
                 {
                     /* Save old value to support transaction abort */
                     if (!makeDefault)
                         push_old_value(&conf->gen, action);
  
                     if (conf->assign_hook)
                         conf->assign_hook(newval, newextra);
                     *conf->variable = newval;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     newextra);
                     conf->gen.source = source;
                     conf->gen.scontext = context;
                 }
                 if (makeDefault)
                 {
                     GucStack   *stack;
  
                     if (conf->gen.reset_source <= source)
                     {
                         conf->reset_val = newval;
                         set_extra_field(&conf->gen, &conf->reset_extra,
                                         newextra);
                         conf->gen.reset_source = source;
                         conf->gen.reset_scontext = context;
                     }
                     for (stack = conf->gen.stack; stack; stack = stack->prev)
                     {
                         if (stack->source <= source)
                         {
                             stack->prior.val.intval = newval;
                             set_extra_field(&conf->gen, &stack->prior.extra,
                                             newextra);
                             stack->source = source;
                             stack->scontext = context;
                         }
                     }
                 }
  
                 /* Perhaps we didn't install newextra anywhere */
                 if (newextra && !extra_field_used(&conf->gen, newextra))
                     free(newextra);
                 break;
  
 #undef newval
             }
  
         case PGC_REAL:
             {
                 struct config_real *conf = (struct config_real *) record;
  
 #define newval (newval_union.realval)
  
                 if (value)
                 {
                     if (!parse_and_validate_value(record, name, value,
                                                   source, elevel,
                                                   &newval_union, &newextra))
                         return 0;
                 }
                 else if (source == PGC_S_DEFAULT)
                 {
                     newval = conf->boot_val;
                     if (!call_real_check_hook(conf, &newval, &newextra,
                                               source, elevel))
                         return 0;
                 }
                 else
                 {
                     newval = conf->reset_val;
                     newextra = conf->reset_extra;
                     source = conf->gen.reset_source;
                     context = conf->gen.reset_scontext;
                 }
  
                 if (prohibitValueChange)
                 {
                     /* Release newextra, unless it's reset_extra */
                     if (newextra && !extra_field_used(&conf->gen, newextra))
                         free(newextra);
  
                     if (*conf->variable != newval)
                     {
                         record->status |= GUC_PENDING_RESTART;
                         ereport(elevel,
                                 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                  errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                         name)));
                         return 0;
                     }
                     record->status &= ~GUC_PENDING_RESTART;
                     return -1;
                 }
  
                 if (changeVal)
                 {
                     /* Save old value to support transaction abort */
                     if (!makeDefault)
                         push_old_value(&conf->gen, action);
  
                     if (conf->assign_hook)
                         conf->assign_hook(newval, newextra);
                     *conf->variable = newval;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     newextra);
                     conf->gen.source = source;
                     conf->gen.scontext = context;
                 }
                 if (makeDefault)
                 {
                     GucStack   *stack;
  
                     if (conf->gen.reset_source <= source)
                     {
                         conf->reset_val = newval;
                         set_extra_field(&conf->gen, &conf->reset_extra,
                                         newextra);
                         conf->gen.reset_source = source;
                         conf->gen.reset_scontext = context;
                     }
                     for (stack = conf->gen.stack; stack; stack = stack->prev)
                     {
                         if (stack->source <= source)
                         {
                             stack->prior.val.realval = newval;
                             set_extra_field(&conf->gen, &stack->prior.extra,
                                             newextra);
                             stack->source = source;
                             stack->scontext = context;
                         }
                     }
                 }
  
                 /* Perhaps we didn't install newextra anywhere */
                 if (newextra && !extra_field_used(&conf->gen, newextra))
                     free(newextra);
                 break;
  
 #undef newval
             }
  
         case PGC_STRING:
             {
                 struct config_string *conf = (struct config_string *) record;
  
 #define newval (newval_union.stringval)
  
                 if (value)
                 {
                     if (!parse_and_validate_value(record, name, value,
                                                   source, elevel,
                                                   &newval_union, &newextra))
                         return 0;
                 }
                 else if (source == PGC_S_DEFAULT)
                 {
                     /* non-NULL boot_val must always get strdup'd */
                     if (conf->boot_val != NULL)
                     {
                         newval = guc_strdup(elevel, conf->boot_val);
                         if (newval == NULL)
                             return 0;
                     }
                     else
                         newval = NULL;
  
                     if (!call_string_check_hook(conf, &newval, &newextra,
                                                 source, elevel))
                     {
                         free(newval);
                         return 0;
                     }
                 }
                 else
                 {
                     /*
                      * strdup not needed, since reset_val is already under
                      * guc.c's control
                      */
                     newval = conf->reset_val;
                     newextra = conf->reset_extra;
                     source = conf->gen.reset_source;
                     context = conf->gen.reset_scontext;
                 }
  
                 if (prohibitValueChange)
                 {
                     bool        newval_different;
  
                     /* newval shouldn't be NULL, so we're a bit sloppy here */
                     newval_different = (*conf->variable == NULL ||
                                         newval == NULL ||
                                         strcmp(*conf->variable, newval) != 0);
  
                     /* Release newval, unless it's reset_val */
                     if (newval && !string_field_used(conf, newval))
                         free(newval);
                     /* Release newextra, unless it's reset_extra */
                     if (newextra && !extra_field_used(&conf->gen, newextra))
                         free(newextra);
  
                     if (newval_different)
                     {
                         record->status |= GUC_PENDING_RESTART;
                         ereport(elevel,
                                 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                  errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                         name)));
                         return 0;
                     }
                     record->status &= ~GUC_PENDING_RESTART;
                     return -1;
                 }
  
                 if (changeVal)
                 {
                     /* Save old value to support transaction abort */
                     if (!makeDefault)
                         push_old_value(&conf->gen, action);
  
                     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);
                     conf->gen.source = source;
                     conf->gen.scontext = context;
                 }
  
                 if (makeDefault)
                 {
                     GucStack   *stack;
  
                     if (conf->gen.reset_source <= source)
                     {
                         set_string_field(conf, &conf->reset_val, newval);
                         set_extra_field(&conf->gen, &conf->reset_extra,
                                         newextra);
                         conf->gen.reset_source = source;
                         conf->gen.reset_scontext = context;
                     }
                     for (stack = conf->gen.stack; stack; stack = stack->prev)
                     {
                         if (stack->source <= source)
                         {
                             set_string_field(conf, &stack->prior.val.stringval,
                                              newval);
                             set_extra_field(&conf->gen, &stack->prior.extra,
                                             newextra);
                             stack->source = source;
                             stack->scontext = context;
                         }
                     }
                 }
  
                 /* Perhaps we didn't install newval anywhere */
                 if (newval && !string_field_used(conf, newval))
                     free(newval);
                 /* Perhaps we didn't install newextra anywhere */
                 if (newextra && !extra_field_used(&conf->gen, newextra))
                     free(newextra);
                 break;
  
 #undef newval
             }
  
         case PGC_ENUM:
             {
                 struct config_enum *conf = (struct config_enum *) record;
  
 #define newval (newval_union.enumval)
  
                 if (value)
                 {
                     if (!parse_and_validate_value(record, name, value,
                                                   source, elevel,
                                                   &newval_union, &newextra))
                         return 0;
                 }
                 else if (source == PGC_S_DEFAULT)
                 {
                     newval = conf->boot_val;
                     if (!call_enum_check_hook(conf, &newval, &newextra,
                                               source, elevel))
                         return 0;
                 }
                 else
                 {
                     newval = conf->reset_val;
                     newextra = conf->reset_extra;
                     source = conf->gen.reset_source;
                     context = conf->gen.reset_scontext;
                 }
  
                 if (prohibitValueChange)
                 {
                     /* Release newextra, unless it's reset_extra */
                     if (newextra && !extra_field_used(&conf->gen, newextra))
                         free(newextra);
  
                     if (*conf->variable != newval)
                     {
                         record->status |= GUC_PENDING_RESTART;
                         ereport(elevel,
                                 (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
                                  errmsg("parameter \"%s\" cannot be changed without restarting the server",
                                         name)));
                         return 0;
                     }
                     record->status &= ~GUC_PENDING_RESTART;
                     return -1;
                 }
  
                 if (changeVal)
                 {
                     /* Save old value to support transaction abort */
                     if (!makeDefault)
                         push_old_value(&conf->gen, action);
  
                     if (conf->assign_hook)
                         conf->assign_hook(newval, newextra);
                     *conf->variable = newval;
                     set_extra_field(&conf->gen, &conf->gen.extra,
                                     newextra);
                     conf->gen.source = source;
                     conf->gen.scontext = context;
                 }
                 if (makeDefault)
                 {
                     GucStack   *stack;
  
                     if (conf->gen.reset_source <= source)
                     {
                         conf->reset_val = newval;
                         set_extra_field(&conf->gen, &conf->reset_extra,
                                         newextra);
                         conf->gen.reset_source = source;
                         conf->gen.reset_scontext = context;
                     }
                     for (stack = conf->gen.stack; stack; stack = stack->prev)
                     {
                         if (stack->source <= source)
                         {
                             stack->prior.val.enumval = newval;
                             set_extra_field(&conf->gen, &stack->prior.extra,
                                             newextra);
                             stack->source = source;
                             stack->scontext = context;
                         }
                     }
                 }
  
                 /* Perhaps we didn't install newextra anywhere */
                 if (newextra && !extra_field_used(&conf->gen, newextra))
                     free(newextra);
                 break;
  
 #undef newval
             }
     }
  
     if (changeVal && (record->flags & GUC_REPORT))
     {
         record->status |= GUC_NEEDS_REPORT;
         report_needed = true;
     }
  
     return changeVal ? 1 : -1;
 }

References ACL_SET, ACLCHECK_OK, generate_unaccent_rules::action, config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_var_val::boolval, config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), call_string_check_hook(), config_generic::context, DEBUG3, elog, config_var_val::enumval, ereport, errcode(), errmsg(), ERROR, config_var_value::extra, config_generic::extra, extra_field_used(), find_option(), config_generic::flags, free, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GetUserId(), GUC_ACTION_SAVE, GUC_NEEDS_REPORT, GUC_NOT_WHILE_SEC_REST, GUC_PENDING_RESTART, GUC_REPORT, guc_strdup(), InLocalUserIdChange(), InSecurityRestrictedOperation(), config_var_val::intval, IsInParallelMode(), IsUnderPostmaster, LOG, name, newval, parse_and_validate_value(), pg_parameter_aclcheck(), PGC_BACKEND, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_INTERNAL, PGC_POSTMASTER, PGC_REAL, PGC_S_CLIENT, PGC_S_DATABASE, PGC_S_DATABASE_USER, PGC_S_DEFAULT, PGC_S_FILE, PGC_S_GLOBAL, PGC_S_OVERRIDE, PGC_S_USER, PGC_SIGHUP, PGC_STRING, PGC_SU_BACKEND, PGC_SUSET, PGC_USERSET, guc_stack::prev, guc_stack::prior, push_old_value(), config_var_val::realval, report_needed, config_bool::reset_extra, config_int::reset_extra, config_real::reset_extra, config_string::reset_extra, config_enum::reset_extra, config_generic::reset_scontext, config_generic::reset_source, config_bool::reset_val, config_int::reset_val,

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ EmitWarningsOnPlaceholders

◆ GUC_check_errdetail

◆ GUC_check_errhint

◆ GUC_check_errmsg

◆ GUC_CUSTOM_PLACEHOLDER

◆ GUC_DISALLOW_IN_AUTO_FILE

◆ GUC_DISALLOW_IN_FILE

◆ GUC_EXPLAIN

◆ GUC_IS_NAME

◆ GUC_LIST_INPUT

◆ GUC_LIST_QUOTE

◆ GUC_NO_RESET_ALL

◆ GUC_NO_SHOW_ALL

◆ GUC_NOT_IN_SAMPLE

◆ GUC_NOT_WHILE_SEC_REST

◆ GUC_QUALIFIER_SEPARATOR

◆ GUC_REPORT

◆ GUC_RUNTIME_COMPUTED

◆ GUC_SUPERUSER_ONLY

◆ GUC_UNIT

◆ 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

◆ MAX_KILOBYTES

◆ PG_AUTOCONF_FILENAME

Typedef Documentation

◆ ConfigVariable

◆ GucBoolAssignHook

◆ GucBoolCheckHook

◆ GucEnumAssignHook

◆ GucEnumCheckHook

◆ GucIntAssignHook

◆ GucIntCheckHook

◆ GucRealAssignHook

◆ GucRealCheckHook

◆ GucShowHook

◆ GucStringAssignHook

◆ GucStringCheckHook

Enumeration Type Documentation

◆ GucAction

◆ GucContext

◆ GucSource

Function Documentation

◆ AlterSystemSetConfigFile()

◆ assign_recovery_prefetch()

◆ assign_search_path()

◆ assign_temp_tablespaces()

◆ assign_xlog_sync_method()

◆ AtEOXact_GUC()

◆ AtStart_GUC()

◆ BeginReportingGUCOptions()

◆ check_default_tablespace()

◆ check_GUC_name_for_parameter_acl()

◆ check_recovery_prefetch()

◆ check_search_path()

◆ check_temp_tablespaces()

◆ check_wal_buffers()

◆ convert_GUC_name_for_parameter_acl()

◆ DeescapeQuotedString()

◆ DefineCustomBoolVariable()

◆ DefineCustomEnumVariable()

◆ DefineCustomIntVariable()

◆ DefineCustomRealVariable()

◆ DefineCustomStringVariable()

◆ EstimateGUCStateSpace()

◆ ExecSetVariableStmt()