PostgreSQL Source Code  git master
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
guc.h File Reference
#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:

Go to the source code of 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   0x000001 /* input can be list format */
 
#define GUC_LIST_QUOTE   0x000002 /* double-quote list elements */
 
#define GUC_NO_SHOW_ALL   0x000004 /* exclude from SHOW ALL */
 
#define GUC_NO_RESET   0x000008 /* disallow RESET and SAVE */
 
#define GUC_NO_RESET_ALL   0x000010 /* exclude from RESET ALL */
 
#define GUC_EXPLAIN   0x000020 /* include in EXPLAIN */
 
#define GUC_REPORT   0x000040 /* auto-report changes to client */
 
#define GUC_NOT_IN_SAMPLE   0x000080 /* not in postgresql.conf.sample */
 
#define GUC_DISALLOW_IN_FILE   0x000100 /* can't set in postgresql.conf */
 
#define GUC_CUSTOM_PLACEHOLDER   0x000200 /* placeholder for custom variable */
 
#define GUC_SUPERUSER_ONLY   0x000400 /* show only to superusers */
 
#define GUC_IS_NAME   0x000800 /* limit string to NAMEDATALEN-1 */
 
#define GUC_NOT_WHILE_SEC_REST   0x001000 /* can't set if security restricted */
 
#define GUC_DISALLOW_IN_AUTO_FILE    0x002000 /* can't set in PG_AUTOCONF_FILENAME */
 
#define GUC_RUNTIME_COMPUTED   0x004000 /* delay processing in 'postgres -C' */
 
#define GUC_ALLOW_IN_PARALLEL   0x008000 /* allow setting in parallel mode */
 
#define GUC_UNIT_KB   0x01000000 /* value is in kilobytes */
 
#define GUC_UNIT_BLOCKS   0x02000000 /* value is in blocks */
 
#define GUC_UNIT_XBLOCKS   0x03000000 /* value is in xlog blocks */
 
#define GUC_UNIT_MB   0x04000000 /* value is in megabytes */
 
#define GUC_UNIT_BYTE   0x05000000 /* value is in bytes */
 
#define GUC_UNIT_MEMORY   0x0F000000 /* mask for size-related units */
 
#define GUC_UNIT_MS   0x10000000 /* value is in milliseconds */
 
#define GUC_UNIT_S   0x20000000 /* value is in seconds */
 
#define GUC_UNIT_MIN   0x30000000 /* value is in minutes */
 
#define GUC_UNIT_TIME   0x70000000 /* mask for time-related units */
 
#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 struct config_generic config_handle
 
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) pg_attribute_nonnull(1
 
void 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) pg_attribute_nonnull(1
 
void void 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) pg_attribute_nonnull(1
 
void void void 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) pg_attribute_nonnull(1
 
void void void void 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) pg_attribute_nonnull(1
 
void void void void void 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)
 
void check_GUC_name_for_parameter_acl (const char *name)
 
void InitializeGUCOptions (void)
 
bool SelectConfigFiles (const char *userDoption, const char *progname)
 
void ResetAllOptions (void)
 
void AtStart_GUC (void)
 
int NewGUCNestLevel (void)
 
void RestrictSearchPath (void)
 
void AtEOXact_GUC (bool isCommit, int nestLevel)
 
void BeginReportingGUCOptions (void)
 
void ReportChangedGUCOptions (void)
 
void ParseLongOption (const char *string, char **name, char **value)
 
const char * get_config_unit_name (int flags)
 
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)
 
int set_config_option_ext (const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
 
int set_config_with_handle (const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
 
config_handle * get_config_handle (const char *name)
 
void AlterSystemSetConfigFile (AlterSystemStmt *altersysstmt)
 
char * GetConfigOptionByName (const char *name, const char **varname, bool missing_ok)
 
void TransformGUCArray (ArrayType *array, List **names, List **values)
 
void ProcessGUCArray (ArrayType *array, GucContext context, GucSource source, GucAction action)
 
ArrayType * GUCArrayAdd (ArrayType *array, const char *name, const char *value)
 
ArrayType * GUCArrayDelete (ArrayType *array, const char *name)
 
ArrayType * GUCArrayReset (ArrayType *array)
 
void * guc_malloc (int elevel, size_t size)
 
pg_nodiscard void * guc_realloc (int elevel, void *old, size_t size)
 
char * guc_strdup (int elevel, const char *src)
 
void guc_free (void *ptr)
 
Size EstimateGUCStateSpace (void)
 
void SerializeGUCState (Size maxsize, char *start_address)
 
void RestoreGUCState (void *gucstate)
 
void ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)
 
char * ExtractSetVariableArgs (VariableSetStmt *stmt)
 
void SetPGVariable (const char *name, List *args, bool is_local)
 
void GetPGVariable (const char *name, DestReceiver *dest)
 
TupleDesc GetPGVariableResultDesc (const char *name)
 
void GUC_check_errcode (int sqlerrcode)
 

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 char * event_source
 
PGDLLIMPORT bool check_function_bodies
 
PGDLLIMPORT bool current_role_is_superuser
 
PGDLLIMPORT bool AllowAlterSystem
 
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 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 * role_string
 
PGDLLIMPORT bool in_hot_standby_guc
 
PGDLLIMPORT bool trace_sort
 
PGDLLIMPORT const struct config_enum_entry archive_mode_options []
 
PGDLLIMPORT const struct config_enum_entry dynamic_shared_memory_options []
 
PGDLLIMPORT const struct config_enum_entry recovery_target_action_options []
 
PGDLLIMPORT const struct config_enum_entry wal_level_options []
 
PGDLLIMPORT const struct config_enum_entry wal_sync_method_options []
 
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 390 of file guc.h.

◆ GUC_ALLOW_IN_PARALLEL

#define GUC_ALLOW_IN_PARALLEL   0x008000 /* allow setting in parallel mode */

Definition at line 226 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:1645
format_elog_string
char * format_elog_string(const char *fmt,...)
Definition: elog.c:1654
TEXTDOMAIN
#define TEXTDOMAIN
Definition: elog.h:152

Definition at line 476 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 480 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 472 of file guc.h.

◆ GUC_CUSTOM_PLACEHOLDER

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

Definition at line 219 of file guc.h.

◆ GUC_DISALLOW_IN_AUTO_FILE

#define GUC_DISALLOW_IN_AUTO_FILE    0x002000 /* can't set in PG_AUTOCONF_FILENAME */

Definition at line 223 of file guc.h.

◆ GUC_DISALLOW_IN_FILE

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

Definition at line 218 of file guc.h.

◆ GUC_EXPLAIN

#define GUC_EXPLAIN   0x000020 /* include in EXPLAIN */

Definition at line 215 of file guc.h.

◆ GUC_IS_NAME

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

Definition at line 221 of file guc.h.

◆ GUC_LIST_INPUT

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

Definition at line 210 of file guc.h.

◆ GUC_LIST_QUOTE

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

Definition at line 211 of file guc.h.

◆ GUC_NO_RESET

#define GUC_NO_RESET   0x000008 /* disallow RESET and SAVE */

Definition at line 213 of file guc.h.

◆ GUC_NO_RESET_ALL

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

Definition at line 214 of file guc.h.

◆ GUC_NO_SHOW_ALL

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

Definition at line 212 of file guc.h.

◆ GUC_NOT_IN_SAMPLE

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

Definition at line 217 of file guc.h.

◆ GUC_NOT_WHILE_SEC_REST

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

Definition at line 222 of file guc.h.

◆ GUC_QUALIFIER_SEPARATOR

#define GUC_QUALIFIER_SEPARATOR   '.'

Definition at line 204 of file guc.h.

◆ GUC_REPORT

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

Definition at line 216 of file guc.h.

◆ GUC_RUNTIME_COMPUTED

#define GUC_RUNTIME_COMPUTED   0x004000 /* delay processing in 'postgres -C' */

Definition at line 225 of file guc.h.

◆ GUC_SUPERUSER_ONLY

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

Definition at line 220 of file guc.h.

◆ GUC_UNIT

#define GUC_UNIT   (GUC_UNIT_MEMORY | GUC_UNIT_TIME)

Definition at line 240 of file guc.h.

◆ GUC_UNIT_BLOCKS

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

Definition at line 229 of file guc.h.

◆ GUC_UNIT_BYTE

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

Definition at line 232 of file guc.h.

◆ GUC_UNIT_KB

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

Definition at line 228 of file guc.h.

◆ GUC_UNIT_MB

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

Definition at line 231 of file guc.h.

◆ GUC_UNIT_MEMORY

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

Definition at line 233 of file guc.h.

◆ GUC_UNIT_MIN

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

Definition at line 237 of file guc.h.

◆ GUC_UNIT_MS

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

Definition at line 235 of file guc.h.

◆ GUC_UNIT_S

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

Definition at line 236 of file guc.h.

◆ GUC_UNIT_TIME

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

Definition at line 238 of file guc.h.

◆ GUC_UNIT_XBLOCKS

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

Definition at line 230 of file guc.h.

◆ MAX_KILOBYTES

#define MAX_KILOBYTES   (INT_MAX / 1024)

Definition at line 25 of file guc.h.

◆ PG_AUTOCONF_FILENAME

#define PG_AUTOCONF_FILENAME   "postgresql.auto.conf"

Definition at line 33 of file guc.h.

Typedef Documentation

◆ config_handle

typedef struct config_generic config_handle

Definition at line 1 of file guc.h.

◆ ConfigVariable

typedef struct ConfigVariable ConfigVariable

◆ GucBoolAssignHook

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

Definition at line 185 of file guc.h.

◆ GucBoolCheckHook

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

Definition at line 179 of file guc.h.

◆ GucEnumAssignHook

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

Definition at line 189 of file guc.h.

◆ GucEnumCheckHook

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

Definition at line 183 of file guc.h.

◆ GucIntAssignHook

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

Definition at line 186 of file guc.h.

◆ GucIntCheckHook

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

Definition at line 180 of file guc.h.

◆ GucRealAssignHook

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

Definition at line 187 of file guc.h.

◆ GucRealCheckHook

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

Definition at line 181 of file guc.h.

◆ GucShowHook

typedef const char*(* GucShowHook) (void)

Definition at line 191 of file guc.h.

◆ GucStringAssignHook

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

Definition at line 188 of file guc.h.

◆ GucStringCheckHook

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

Definition at line 182 of file guc.h.

Enumeration Type Documentation

◆ GucAction

enum GucAction
Enumerator
GUC_ACTION_SET 
GUC_ACTION_LOCAL 
GUC_ACTION_SAVE 

Definition at line 196 of file guc.h.

197 {
198  /* Types of set_config_option actions */
199  GUC_ACTION_SET, /* regular SET command */
200  GUC_ACTION_LOCAL, /* SET LOCAL command */
201  GUC_ACTION_SAVE, /* function SET option, or temp assignment */
202 } GucAction;
GucAction
GucAction
Definition: guc.h:197
GUC_ACTION_SAVE
@ GUC_ACTION_SAVE
Definition: guc.h:201
GUC_ACTION_SET
@ GUC_ACTION_SET
Definition: guc.h:199
GUC_ACTION_LOCAL
@ GUC_ACTION_LOCAL
Definition: guc.h:200

◆ GucContext

enum GucContext
Enumerator
PGC_INTERNAL 
PGC_POSTMASTER 
PGC_SIGHUP 
PGC_SU_BACKEND 
PGC_BACKEND 
PGC_SUSET 
PGC_USERSET 

Definition at line 67 of file guc.h.

68 {
69  PGC_INTERNAL,
70  PGC_POSTMASTER,
71  PGC_SIGHUP,
72  PGC_SU_BACKEND,
73  PGC_BACKEND,
74  PGC_SUSET,
75  PGC_USERSET,
76 } GucContext;
GucContext
GucContext
Definition: guc.h:68
PGC_SUSET
@ PGC_SUSET
Definition: guc.h:74
PGC_INTERNAL
@ PGC_INTERNAL
Definition: guc.h:69
PGC_USERSET
@ PGC_USERSET
Definition: guc.h:75
PGC_SU_BACKEND
@ PGC_SU_BACKEND
Definition: guc.h:72
PGC_POSTMASTER
@ PGC_POSTMASTER
Definition: guc.h:70
PGC_SIGHUP
@ PGC_SIGHUP
Definition: guc.h:71
PGC_BACKEND
@ PGC_BACKEND
Definition: guc.h:73

◆ 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 107 of file guc.h.

108 {
109  PGC_S_DEFAULT, /* hard-wired default ("boot_val") */
110  PGC_S_DYNAMIC_DEFAULT, /* default computed during initialization */
111  PGC_S_ENV_VAR, /* postmaster environment variable */
112  PGC_S_FILE, /* postgresql.conf */
113  PGC_S_ARGV, /* postmaster command line */
114  PGC_S_GLOBAL, /* global in-database setting */
115  PGC_S_DATABASE, /* per-database setting */
116  PGC_S_USER, /* per-user setting */
117  PGC_S_DATABASE_USER, /* per-user-and-database setting */
118  PGC_S_CLIENT, /* from client connection request */
119  PGC_S_OVERRIDE, /* special case to forcibly set default */
120  PGC_S_INTERACTIVE, /* dividing line for error reporting */
121  PGC_S_TEST, /* test per-database or per-user setting */
122  PGC_S_SESSION, /* SET command */
123 } GucSource;
GucSource
GucSource
Definition: guc.h:108
PGC_S_DEFAULT
@ PGC_S_DEFAULT
Definition: guc.h:109
PGC_S_DYNAMIC_DEFAULT
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
PGC_S_FILE
@ PGC_S_FILE
Definition: guc.h:112
PGC_S_GLOBAL
@ PGC_S_GLOBAL
Definition: guc.h:114
PGC_S_DATABASE
@ PGC_S_DATABASE
Definition: guc.h:115
PGC_S_OVERRIDE
@ PGC_S_OVERRIDE
Definition: guc.h:119
PGC_S_ARGV
@ PGC_S_ARGV
Definition: guc.h:113
PGC_S_SESSION
@ PGC_S_SESSION
Definition: guc.h:122
PGC_S_CLIENT
@ PGC_S_CLIENT
Definition: guc.h:118
PGC_S_DATABASE_USER
@ PGC_S_DATABASE_USER
Definition: guc.h:117
PGC_S_ENV_VAR
@ PGC_S_ENV_VAR
Definition: guc.h:111
PGC_S_USER
@ PGC_S_USER
Definition: guc.h:116
PGC_S_TEST
@ PGC_S_TEST
Definition: guc.h:121
PGC_S_INTERACTIVE
@ PGC_S_INTERACTIVE
Definition: guc.h:120

Function Documentation

◆ AlterSystemSetConfigFile()

void AlterSystemSetConfigFile ( AlterSystemStmt *  altersysstmt)

Definition at line 4566 of file guc.c.

4567 {
4568  char *name;
4569  char *value;
4570  bool resetall = false;
4571  ConfigVariable *head = NULL;
4572  ConfigVariable *tail = NULL;
4573  volatile int Tmpfd;
4574  char AutoConfFileName[MAXPGPATH];
4575  char AutoConfTmpFileName[MAXPGPATH];
4576 
4577  /*
4578  * Extract statement arguments
4579  */
4580  name = altersysstmt->setstmt->name;
4581 
4582  if (!AllowAlterSystem)
4583  ereport(ERROR,
4584  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4585  errmsg("ALTER SYSTEM is not allowed in this environment")));
4586 
4587  switch (altersysstmt->setstmt->kind)
4588  {
4589  case VAR_SET_VALUE:
4590  value = ExtractSetVariableArgs(altersysstmt->setstmt);
4591  break;
4592 
4593  case VAR_SET_DEFAULT:
4594  case VAR_RESET:
4595  value = NULL;
4596  break;
4597 
4598  case VAR_RESET_ALL:
4599  value = NULL;
4600  resetall = true;
4601  break;
4602 
4603  default:
4604  elog(ERROR, "unrecognized alter system stmt type: %d",
4605  altersysstmt->setstmt->kind);
4606  break;
4607  }
4608 
4609  /*
4610  * Check permission to run ALTER SYSTEM on the target variable
4611  */
4612  if (!superuser())
4613  {
4614  if (resetall)
4615  ereport(ERROR,
4616  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4617  errmsg("permission denied to perform ALTER SYSTEM RESET ALL")));
4618  else
4619  {
4620  AclResult aclresult;
4621 
4622  aclresult = pg_parameter_aclcheck(name, GetUserId(),
4623  ACL_ALTER_SYSTEM);
4624  if (aclresult != ACLCHECK_OK)
4625  ereport(ERROR,
4626  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4627  errmsg("permission denied to set parameter \"%s\"",
4628  name)));
4629  }
4630  }
4631 
4632  /*
4633  * Unless it's RESET_ALL, validate the target variable and value
4634  */
4635  if (!resetall)
4636  {
4637  struct config_generic *record;
4638 
4639  /* We don't want to create a placeholder if there's not one already */
4640  record = find_option(name, false, true, DEBUG5);
4641  if (record != NULL)
4642  {
4643  /*
4644  * Don't allow parameters that can't be set in configuration files
4645  * to be set in PG_AUTOCONF_FILENAME file.
4646  */
4647  if ((record->context == PGC_INTERNAL) ||
4648  (record->flags & GUC_DISALLOW_IN_FILE) ||
4649  (record->flags & GUC_DISALLOW_IN_AUTO_FILE))
4650  ereport(ERROR,
4651  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4652  errmsg("parameter \"%s\" cannot be changed",
4653  name)));
4654 
4655  /*
4656  * If a value is specified, verify that it's sane.
4657  */
4658  if (value)
4659  {
4660  union config_var_val newval;
4661  void *newextra = NULL;
4662 
4663  if (!parse_and_validate_value(record, name, value,
4664  PGC_S_FILE, ERROR,
4665  &newval, &newextra))
4666  ereport(ERROR,
4667  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4668  errmsg("invalid value for parameter \"%s\": \"%s\"",
4669  name, value)));
4670 
4671  if (record->vartype == PGC_STRING && newval.stringval != NULL)
4672  guc_free(newval.stringval);
4673  guc_free(newextra);
4674  }
4675  }
4676  else
4677  {
4678  /*
4679  * Variable not known; check we'd be allowed to create it. (We
4680  * cannot validate the value, but that's fine. A non-core GUC in
4681  * the config file cannot cause postmaster start to fail, so we
4682  * don't have to be too tense about possibly installing a bad
4683  * value.)
4684  */
4685  (void) assignable_custom_variable_name(name, false, ERROR);
4686  }
4687 
4688  /*
4689  * We must also reject values containing newlines, because the grammar
4690  * for config files doesn't support embedded newlines in string
4691  * literals.
4692  */
4693  if (value && strchr(value, '\n'))
4694  ereport(ERROR,
4695  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4696  errmsg("parameter value for ALTER SYSTEM must not contain a newline")));
4697  }
4698 
4699  /*
4700  * PG_AUTOCONF_FILENAME and its corresponding temporary file are always in
4701  * the data directory, so we can reference them by simple relative paths.
4702  */
4703  snprintf(AutoConfFileName, sizeof(AutoConfFileName), "%s",
4704  PG_AUTOCONF_FILENAME);
4705  snprintf(AutoConfTmpFileName, sizeof(AutoConfTmpFileName), "%s.%s",
4706  AutoConfFileName,
4707  "tmp");
4708 
4709  /*
4710  * Only one backend is allowed to operate on PG_AUTOCONF_FILENAME at a
4711  * time. Use AutoFileLock to ensure that. We must hold the lock while
4712  * reading the old file contents.
4713  */
4714  LWLockAcquire(AutoFileLock, LW_EXCLUSIVE);
4715 
4716  /*
4717  * If we're going to reset everything, then no need to open or parse the
4718  * old file. We'll just write out an empty list.
4719  */
4720  if (!resetall)
4721  {
4722  struct stat st;
4723 
4724  if (stat(AutoConfFileName, &st) == 0)
4725  {
4726  /* open old file PG_AUTOCONF_FILENAME */
4727  FILE *infile;
4728 
4729  infile = AllocateFile(AutoConfFileName, "r");
4730  if (infile == NULL)
4731  ereport(ERROR,
4732  (errcode_for_file_access(),
4733  errmsg("could not open file \"%s\": %m",
4734  AutoConfFileName)));
4735 
4736  /* parse it */
4737  if (!ParseConfigFp(infile, AutoConfFileName, CONF_FILE_START_DEPTH,
4738  LOG, &head, &tail))
4739  ereport(ERROR,
4740  (errcode(ERRCODE_CONFIG_FILE_ERROR),
4741  errmsg("could not parse contents of file \"%s\"",
4742  AutoConfFileName)));
4743 
4744  FreeFile(infile);
4745  }
4746 
4747  /*
4748  * Now, replace any existing entry with the new value, or add it if
4749  * not present.
4750  */
4751  replace_auto_config_value(&head, &tail, name, value);
4752  }
4753 
4754  /*
4755  * Invoke the post-alter hook for setting this GUC variable. GUCs
4756  * typically do not have corresponding entries in pg_parameter_acl, so we
4757  * call the hook using the name rather than a potentially-non-existent
4758  * OID. Nonetheless, we pass ParameterAclRelationId so that this call
4759  * context can be distinguished from others. (Note that "name" will be
4760  * NULL in the RESET ALL case.)
4761  *
4762  * We do this here rather than at the end, because ALTER SYSTEM is not
4763  * transactional. If the hook aborts our transaction, it will be cleaner
4764  * to do so before we touch any files.
4765  */
4766  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, name,
4767  ACL_ALTER_SYSTEM,
4768  altersysstmt->setstmt->kind,
4769  false);
4770 
4771  /*
4772  * To ensure crash safety, first write the new file data to a temp file,
4773  * then atomically rename it into place.
4774  *
4775  * If there is a temp file left over due to a previous crash, it's okay to
4776  * truncate and reuse it.
4777  */
4778  Tmpfd = BasicOpenFile(AutoConfTmpFileName,
4779  O_CREAT | O_RDWR | O_TRUNC);
4780  if (Tmpfd < 0)
4781  ereport(ERROR,
4782  (errcode_for_file_access(),
4783  errmsg("could not open file \"%s\": %m",
4784  AutoConfTmpFileName)));
4785 
4786  /*
4787  * Use a TRY block to clean up the file if we fail. Since we need a TRY
4788  * block anyway, OK to use BasicOpenFile rather than OpenTransientFile.
4789  */
4790  PG_TRY();
4791  {
4792  /* Write and sync the new contents to the temporary file */
4793  write_auto_conf_file(Tmpfd, AutoConfTmpFileName, head);
4794 
4795  /* Close before renaming; may be required on some platforms */
4796  close(Tmpfd);
4797  Tmpfd = -1;
4798 
4799  /*
4800  * As the rename is atomic operation, if any problem occurs after this
4801  * at worst it can lose the parameters set by last ALTER SYSTEM
4802  * command.
4803  */
4804  durable_rename(AutoConfTmpFileName, AutoConfFileName, ERROR);
4805  }
4806  PG_CATCH();
4807  {
4808  /* Close file first, else unlink might fail on some platforms */
4809  if (Tmpfd >= 0)
4810  close(Tmpfd);
4811 
4812  /* Unlink, but ignore any error */
4813  (void) unlink(AutoConfTmpFileName);
4814 
4815  PG_RE_THROW();
4816  }
4817  PG_END_TRY();
4818 
4819  FreeConfigVariables(head);
4820 
4821  LWLockRelease(AutoFileLock);
4822 }
AclResult
AclResult
Definition: acl.h:182
ACLCHECK_OK
@ ACLCHECK_OK
Definition: acl.h:183
pg_parameter_aclcheck
AclResult pg_parameter_aclcheck(const char *name, Oid roleid, AclMode mode)
Definition: aclchk.c:4114
CONF_FILE_START_DEPTH
#define CONF_FILE_START_DEPTH
Definition: conffiles.h:17
errcode_for_file_access
int errcode_for_file_access(void)
Definition: elog.c:876
errcode
int errcode(int sqlerrcode)
Definition: elog.c:853
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1070
LOG
#define LOG
Definition: elog.h:31
PG_RE_THROW
#define PG_RE_THROW()
Definition: elog.h:412
PG_TRY
#define PG_TRY(...)
Definition: elog.h:371
PG_END_TRY
#define PG_END_TRY(...)
Definition: elog.h:396
ERROR
#define ERROR
Definition: elog.h:39
PG_CATCH
#define PG_CATCH(...)
Definition: elog.h:381
elog
#define elog(elevel,...)
Definition: elog.h:225
ereport
#define ereport(elevel,...)
Definition: elog.h:149
DEBUG5
#define DEBUG5
Definition: elog.h:26
AllocateFile
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2606
durable_rename
int durable_rename(const char *oldfile, const char *newfile, int elevel)
Definition: fd.c:782
BasicOpenFile
int BasicOpenFile(const char *fileName, int fileFlags)
Definition: fd.c:1087
FreeFile
int FreeFile(FILE *file)
Definition: fd.c:2804
assignable_custom_variable_name
static bool assignable_custom_variable_name(const char *name, bool skip_errors, int elevel)
Definition: guc.c:1120
find_option
struct config_generic * find_option(const char *name, bool create_placeholders, bool skip_errors, int elevel)
Definition: guc.c:1234
parse_and_validate_value
static bool parse_and_validate_value(struct config_generic *record, const char *name, const char *value, GucSource source, int elevel, union config_var_val *newval, void **newextra)
Definition: guc.c:3129
guc_free
void guc_free(void *ptr)
Definition: guc.c:688
write_auto_conf_file
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head)
Definition: guc.c:4428
newval
#define newval
replace_auto_config_value
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p, const char *name, const char *value)
Definition: guc.c:4496
PG_AUTOCONF_FILENAME
#define PG_AUTOCONF_FILENAME
Definition: guc.h:33
FreeConfigVariables
void FreeConfigVariables(ConfigVariable *list)
ParseConfigFp
bool ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
GUC_DISALLOW_IN_FILE
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:218
GUC_DISALLOW_IN_AUTO_FILE
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:223
ExtractSetVariableArgs
char * ExtractSetVariableArgs(VariableSetStmt *stmt)
Definition: guc_funcs.c:167
AllowAlterSystem
bool AllowAlterSystem
Definition: guc_tables.c:489
PGC_STRING
@ PGC_STRING
Definition: guc_tables.h:28
value
static struct @157 value
close
#define close(a)
Definition: win32.h:12
LWLockAcquire
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
LWLockRelease
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
LW_EXCLUSIVE
@ LW_EXCLUSIVE
Definition: lwlock.h:114
GetUserId
Oid GetUserId(void)
Definition: miscinit.c:514
InvokeObjectPostAlterHookArgStr
#define InvokeObjectPostAlterHookArgStr(classId, objectName, subId, auxiliaryId, is_internal)
Definition: objectaccess.h:247
VAR_SET_DEFAULT
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2610
VAR_RESET
@ VAR_RESET
Definition: parsenodes.h:2613
VAR_SET_VALUE
@ VAR_SET_VALUE
Definition: parsenodes.h:2609
VAR_RESET_ALL
@ VAR_RESET_ALL
Definition: parsenodes.h:2614
ACL_ALTER_SYSTEM
#define ACL_ALTER_SYSTEM
Definition: parsenodes.h:89
MAXPGPATH
#define MAXPGPATH
Definition: pg_config_manual.h:100
snprintf
#define snprintf
Definition: port.h:238
AlterSystemStmt::setstmt
VariableSetStmt * setstmt
Definition: parsenodes.h:3818
VariableSetStmt::kind
VariableSetKind kind
Definition: parsenodes.h:2620
config_generic
Definition: guc_tables.h:154
config_generic::context
GucContext context
Definition: guc_tables.h:157
config_generic::flags
int flags
Definition: guc_tables.h:161
config_generic::vartype
enum config_type vartype
Definition: guc_tables.h:163
superuser
bool superuser(void)
Definition: superuser.c:46
config_var_val
Definition: guc_tables.h:33
name
const char * name
Definition: wait_event_funcs.c:28
stat
#define stat
Definition: win32_port.h:284
infile
static void infile(const char *name)
Definition: zic.c:1243

References ACL_ALTER_SYSTEM, ACLCHECK_OK, AllocateFile(), AllowAlterSystem, assignable_custom_variable_name(), BasicOpenFile(), close, CONF_FILE_START_DEPTH, config_generic::context, DEBUG5, durable_rename(), elog, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, ExtractSetVariableArgs(), find_option(), config_generic::flags, FreeConfigVariables(), FreeFile(), GetUserId(), GUC_DISALLOW_IN_AUTO_FILE, GUC_DISALLOW_IN_FILE, guc_free(), 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().

◆ AtEOXact_GUC()

void AtEOXact_GUC ( bool  isCommit,
int  nestLevel 
)

Definition at line 2261 of file guc.c.

2262 {
2263  slist_mutable_iter iter;
2264 
2265  /*
2266  * Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
2267  * abort, if there is a failure during transaction start before
2268  * AtStart_GUC is called.
2269  */
2270  Assert(nestLevel > 0 &&
2271  (nestLevel <= GUCNestLevel ||
2272  (nestLevel == GUCNestLevel + 1 && !isCommit)));
2273 
2274  /* We need only process GUCs having nonempty stacks */
2275  slist_foreach_modify(iter, &guc_stack_list)
2276  {
2277  struct config_generic *gconf = slist_container(struct config_generic,
2278  stack_link, iter.cur);
2279  GucStack *stack;
2280 
2281  /*
2282  * Process and pop each stack entry within the nest level. To simplify
2283  * fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
2284  * we allow failure exit from code that uses a local nest level to be
2285  * recovered at the surrounding transaction or subtransaction abort;
2286  * so there could be more than one stack entry to pop.
2287  */
2288  while ((stack = gconf->stack) != NULL &&
2289  stack->nest_level >= nestLevel)
2290  {
2291  GucStack *prev = stack->prev;
2292  bool restorePrior = false;
2293  bool restoreMasked = false;
2294  bool changed;
2295 
2296  /*
2297  * In this next bit, if we don't set either restorePrior or
2298  * restoreMasked, we must "discard" any unwanted fields of the
2299  * stack entries to avoid leaking memory. If we do set one of
2300  * those flags, unused fields will be cleaned up after restoring.
2301  */
2302  if (!isCommit) /* if abort, always restore prior value */
2303  restorePrior = true;
2304  else if (stack->state == GUC_SAVE)
2305  restorePrior = true;
2306  else if (stack->nest_level == 1)
2307  {
2308  /* transaction commit */
2309  if (stack->state == GUC_SET_LOCAL)
2310  restoreMasked = true;
2311  else if (stack->state == GUC_SET)
2312  {
2313  /* we keep the current active value */
2314  discard_stack_value(gconf, &stack->prior);
2315  }
2316  else /* must be GUC_LOCAL */
2317  restorePrior = true;
2318  }
2319  else if (prev == NULL ||
2320  prev->nest_level < stack->nest_level - 1)
2321  {
2322  /* decrement entry's level and do not pop it */
2323  stack->nest_level--;
2324  continue;
2325  }
2326  else
2327  {
2328  /*
2329  * We have to merge this stack entry into prev. See README for
2330  * discussion of this bit.
2331  */
2332  switch (stack->state)
2333  {
2334  case GUC_SAVE:
2335  Assert(false); /* can't get here */
2336  break;
2337 
2338  case GUC_SET:
2339  /* next level always becomes SET */
2340  discard_stack_value(gconf, &stack->prior);
2341  if (prev->state == GUC_SET_LOCAL)
2342  discard_stack_value(gconf, &prev->masked);
2343  prev->state = GUC_SET;
2344  break;
2345 
2346  case GUC_LOCAL:
2347  if (prev->state == GUC_SET)
2348  {
2349  /* LOCAL migrates down */
2350  prev->masked_scontext = stack->scontext;
2351  prev->masked_srole = stack->srole;
2352  prev->masked = stack->prior;
2353  prev->state = GUC_SET_LOCAL;
2354  }
2355  else
2356  {
2357  /* else just forget this stack level */
2358  discard_stack_value(gconf, &stack->prior);
2359  }
2360  break;
2361 
2362  case GUC_SET_LOCAL:
2363  /* prior state at this level no longer wanted */
2364  discard_stack_value(gconf, &stack->prior);
2365  /* copy down the masked state */
2366  prev->masked_scontext = stack->masked_scontext;
2367  prev->masked_srole = stack->masked_srole;
2368  if (prev->state == GUC_SET_LOCAL)
2369  discard_stack_value(gconf, &prev->masked);
2370  prev->masked = stack->masked;
2371  prev->state = GUC_SET_LOCAL;
2372  break;
2373  }
2374  }
2375 
2376  changed = false;
2377 
2378  if (restorePrior || restoreMasked)
2379  {
2380  /* Perform appropriate restoration of the stacked value */
2381  config_var_value newvalue;
2382  GucSource newsource;
2383  GucContext newscontext;
2384  Oid newsrole;
2385 
2386  if (restoreMasked)
2387  {
2388  newvalue = stack->masked;
2389  newsource = PGC_S_SESSION;
2390  newscontext = stack->masked_scontext;
2391  newsrole = stack->masked_srole;
2392  }
2393  else
2394  {
2395  newvalue = stack->prior;
2396  newsource = stack->source;
2397  newscontext = stack->scontext;
2398  newsrole = stack->srole;
2399  }
2400 
2401  switch (gconf->vartype)
2402  {
2403  case PGC_BOOL:
2404  {
2405  struct config_bool *conf = (struct config_bool *) gconf;
2406  bool newval = newvalue.val.boolval;
2407  void *newextra = newvalue.extra;
2408 
2409  if (*conf->variable != newval ||
2410  conf->gen.extra != newextra)
2411  {
2412  if (conf->assign_hook)
2413  conf->assign_hook(newval, newextra);
2414  *conf->variable = newval;
2415  set_extra_field(&conf->gen, &conf->gen.extra,
2416  newextra);
2417  changed = true;
2418  }
2419  break;
2420  }
2421  case PGC_INT:
2422  {
2423  struct config_int *conf = (struct config_int *) gconf;
2424  int newval = newvalue.val.intval;
2425  void *newextra = newvalue.extra;
2426 
2427  if (*conf->variable != newval ||
2428  conf->gen.extra != newextra)
2429  {
2430  if (conf->assign_hook)
2431  conf->assign_hook(newval, newextra);
2432  *conf->variable = newval;
2433  set_extra_field(&conf->gen, &conf->gen.extra,
2434  newextra);
2435  changed = true;
2436  }
2437  break;
2438  }
2439  case PGC_REAL:
2440  {
2441  struct config_real *conf = (struct config_real *) gconf;
2442  double newval = newvalue.val.realval;
2443  void *newextra = newvalue.extra;
2444 
2445  if (*conf->variable != newval ||
2446  conf->gen.extra != newextra)
2447  {
2448  if (conf->assign_hook)
2449  conf->assign_hook(newval, newextra);
2450  *conf->variable = newval;
2451  set_extra_field(&conf->gen, &conf->gen.extra,
2452  newextra);
2453  changed = true;
2454  }
2455  break;
2456  }
2457  case PGC_STRING:
2458  {
2459  struct config_string *conf = (struct config_string *) gconf;
2460  char *newval = newvalue.val.stringval;
2461  void *newextra = newvalue.extra;
2462 
2463  if (*conf->variable != newval ||
2464  conf->gen.extra != newextra)
2465  {
2466  if (conf->assign_hook)
2467  conf->assign_hook(newval, newextra);
2468  set_string_field(conf, conf->variable, newval);
2469  set_extra_field(&conf->gen, &conf->gen.extra,
2470  newextra);
2471  changed = true;
2472  }
2473 
2474  /*
2475  * Release stacked values if not used anymore. We
2476  * could use discard_stack_value() here, but since
2477  * we have type-specific code anyway, might as
2478  * well inline it.
2479  */
2480  set_string_field(conf, &stack->prior.val.stringval, NULL);
2481  set_string_field(conf, &stack->masked.val.stringval, NULL);
2482  break;
2483  }
2484  case PGC_ENUM:
2485  {
2486  struct config_enum *conf = (struct config_enum *) gconf;
2487  int newval = newvalue.val.enumval;
2488  void *newextra = newvalue.extra;
2489 
2490  if (*conf->variable != newval ||
2491  conf->gen.extra != newextra)
2492  {
2493  if (conf->assign_hook)
2494  conf->assign_hook(newval, newextra);
2495  *conf->variable = newval;
2496  set_extra_field(&conf->gen, &conf->gen.extra,
2497  newextra);
2498  changed = true;
2499  }
2500  break;
2501  }
2502  }
2503 
2504  /*
2505  * Release stacked extra values if not used anymore.
2506  */
2507  set_extra_field(gconf, &(stack->prior.extra), NULL);
2508  set_extra_field(gconf, &(stack->masked.extra), NULL);
2509 
2510  /* And restore source information */
2511  set_guc_source(gconf, newsource);
2512  gconf->scontext = newscontext;
2513  gconf->srole = newsrole;
2514  }
2515 
2516  /*
2517  * Pop the GUC's state stack; if it's now empty, remove the GUC
2518  * from guc_stack_list.
2519  */
2520  gconf->stack = prev;
2521  if (prev == NULL)
2522  slist_delete_current(&iter);
2523  pfree(stack);
2524 
2525  /* Report new value if we changed it */
2526  if (changed && (gconf->flags & GUC_REPORT) &&
2527  !(gconf->status & GUC_NEEDS_REPORT))
2528  {
2529  gconf->status |= GUC_NEEDS_REPORT;
2530  slist_push_head(&guc_report_list, &gconf->report_link);
2531  }
2532  } /* end of stack-popping loop */
2533  }
2534 
2535  /* Update nesting level */
2536  GUCNestLevel = nestLevel - 1;
2537 }
Assert
#define Assert(condition)
Definition: c.h:858
guc_report_list
static slist_head guc_report_list
Definition: guc.c:225
set_string_field
static void set_string_field(struct config_string *conf, char **field, char *newval)
Definition: guc.c:730
GUCNestLevel
static int GUCNestLevel
Definition: guc.c:230
discard_stack_value
static void discard_stack_value(struct config_generic *gconf, config_var_value *val)
Definition: guc.c:845
guc_stack_list
static slist_head guc_stack_list
Definition: guc.c:223
set_guc_source
static void set_guc_source(struct config_generic *gconf, GucSource newsource)
Definition: guc.c:2110
set_extra_field
static void set_extra_field(struct config_generic *gconf, void **field, void *newval)
Definition: guc.c:791
GUC_REPORT
#define GUC_REPORT
Definition: guc.h:216
GUC_SET_LOCAL
@ GUC_SET_LOCAL
Definition: guc_tables.h:114
GUC_SET
@ GUC_SET
Definition: guc_tables.h:112
GUC_SAVE
@ GUC_SAVE
Definition: guc_tables.h:111
GUC_LOCAL
@ GUC_LOCAL
Definition: guc_tables.h:113
GUC_NEEDS_REPORT
#define GUC_NEEDS_REPORT
Definition: guc_tables.h:193
PGC_BOOL
@ PGC_BOOL
Definition: guc_tables.h:25
PGC_ENUM
@ PGC_ENUM
Definition: guc_tables.h:29
PGC_REAL
@ PGC_REAL
Definition: guc_tables.h:27
PGC_INT
@ PGC_INT
Definition: guc_tables.h:26
slist_delete_current
static void slist_delete_current(slist_mutable_iter *iter)
Definition: ilist.h:1084
slist_foreach_modify
#define slist_foreach_modify(iter, lhead)
Definition: ilist.h:1148
slist_push_head
static void slist_push_head(slist_head *head, slist_node *node)
Definition: ilist.h:1006
slist_container
#define slist_container(type, membername, ptr)
Definition: ilist.h:1106
pfree
void pfree(void *pointer)
Definition: mcxt.c:1521
Oid
unsigned int Oid
Definition: postgres_ext.h:31
config_bool
Definition: guc_tables.h:199
config_bool::gen
struct config_generic gen
Definition: guc_tables.h:200
config_bool::variable
bool * variable
Definition: guc_tables.h:202
config_bool::assign_hook
GucBoolAssignHook assign_hook
Definition: guc_tables.h:205
config_enum
Definition: guc_tables.h:269
config_enum::variable
int * variable
Definition: guc_tables.h:272
config_enum::assign_hook
GucEnumAssignHook assign_hook
Definition: guc_tables.h:276
config_enum::gen
struct config_generic gen
Definition: guc_tables.h:270
config_generic::status
int status
Definition: guc_tables.h:164
config_generic::scontext
GucContext scontext
Definition: guc_tables.h:167
config_generic::stack_link
slist_node stack_link
Definition: guc_tables.h:175
config_generic::srole
Oid srole
Definition: guc_tables.h:169
config_generic::stack
GucStack * stack
Definition: guc_tables.h:171
config_generic::extra
void * extra
Definition: guc_tables.h:172
config_generic::report_link
slist_node report_link
Definition: guc_tables.h:177
config_int
Definition: guc_tables.h:213
config_int::assign_hook
GucIntAssignHook assign_hook
Definition: guc_tables.h:221
config_int::variable
int * variable
Definition: guc_tables.h:216
config_int::gen
struct config_generic gen
Definition: guc_tables.h:214
config_real
Definition: guc_tables.h:229
config_real::assign_hook
GucRealAssignHook assign_hook
Definition: guc_tables.h:237
config_real::variable
double * variable
Definition: guc_tables.h:232
config_real::gen
struct config_generic gen
Definition: guc_tables.h:230
config_string
Definition: guc_tables.h:255
config_string::gen
struct config_generic gen
Definition: guc_tables.h:256
config_string::assign_hook
GucStringAssignHook assign_hook
Definition: guc_tables.h:261
config_string::variable
char ** variable
Definition: guc_tables.h:258
config_var_value
Definition: guc_tables.h:46
config_var_value::val
union config_var_val val
Definition: guc_tables.h:47
config_var_value::extra
void * extra
Definition: guc_tables.h:48
guc_stack
Definition: guc_tables.h:118
guc_stack::prev
struct guc_stack * prev
Definition: guc_tables.h:119
guc_stack::masked_srole
Oid masked_srole
Definition: guc_tables.h:127
guc_stack::nest_level
int nest_level
Definition: guc_tables.h:120
guc_stack::masked
config_var_value masked
Definition: guc_tables.h:129
guc_stack::prior
config_var_value prior
Definition: guc_tables.h:128
guc_stack::srole
Oid srole
Definition: guc_tables.h:126
guc_stack::scontext
GucContext scontext
Definition: guc_tables.h:124
guc_stack::state
GucStackState state
Definition: guc_tables.h:121
guc_stack::source
GucSource source
Definition: guc_tables.h:122
guc_stack::masked_scontext
GucContext masked_scontext
Definition: guc_tables.h:125
slist_mutable_iter
Definition: ilist.h:273
slist_mutable_iter::cur
slist_node * cur
Definition: ilist.h:274
config_var_val::boolval
bool boolval
Definition: guc_tables.h:34
config_var_val::realval
double realval
Definition: guc_tables.h:36
config_var_val::stringval
char * stringval
Definition: guc_tables.h:37
config_var_val::intval
int intval
Definition: guc_tables.h:35
config_var_val::enumval
int enumval
Definition: guc_tables.h:38

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, slist_mutable_iter::cur, discard_stack_value(), config_var_val::enumval, config_var_value::extra, config_generic::extra, config_generic::flags, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_LOCAL, GUC_NEEDS_REPORT, GUC_REPORT, guc_report_list, GUC_SAVE, GUC_SET, GUC_SET_LOCAL, guc_stack_list, GUCNestLevel, config_var_val::intval, guc_stack::masked, guc_stack::masked_scontext, guc_stack::masked_srole, guc_stack::nest_level, newval, pfree(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_SESSION, PGC_STRING, guc_stack::prev, guc_stack::prior, config_var_val::realval, config_generic::report_link, guc_stack::scontext, config_generic::scontext, set_extra_field(), set_guc_source(), set_string_field(), slist_container, slist_delete_current(), slist_foreach_modify, slist_push_head(), guc_stack::source, guc_stack::srole, config_generic::srole, config_generic::stack, config_generic::stack_link, 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(), ComputeIndexAttrs(), CreateSchemaCommand(), DefineIndex(), do_analyze_rel(), execute_extension_script(), fmgr_security_definer(), index_build(), index_concurrently_build(), PrepareTransaction(), ProcedureCreate(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), reset_transmission_modes(), restoreLocalGucs(), RestoreUserContext(), RI_Initial_Check(), RI_PartitionRemove_Check(), vacuum_rel(), and validate_index().

◆ AtStart_GUC()

void AtStart_GUC ( void  )

Definition at line 2214 of file guc.c.

2215 {
2216  /*
2217  * The nest level should be 0 between transactions; if it isn't, somebody
2218  * didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
2219  * throw a warning but make no other effort to clean up.
2220  */
2221  if (GUCNestLevel != 0)
2222  elog(WARNING, "GUC nest level = %d at transaction start",
2223  GUCNestLevel);
2224  GUCNestLevel = 1;
2225 }
WARNING
#define WARNING
Definition: elog.h:36

References elog, GUCNestLevel, and WARNING.

Referenced by StartTransaction().

◆ BeginReportingGUCOptions()

void BeginReportingGUCOptions ( void  )

Definition at line 2545 of file guc.c.

2546 {
2547  HASH_SEQ_STATUS status;
2548  GUCHashEntry *hentry;
2549 
2550  /*
2551  * Don't do anything unless talking to an interactive frontend.
2552  */
2553  if (whereToSendOutput != DestRemote)
2554  return;
2555 
2556  reporting_enabled = true;
2557 
2558  /*
2559  * Hack for in_hot_standby: set the GUC value true if appropriate. This
2560  * is kind of an ugly place to do it, but there's few better options.
2561  *
2562  * (This could be out of date by the time we actually send it, in which
2563  * case the next ReportChangedGUCOptions call will send a duplicate
2564  * report.)
2565  */
2566  if (RecoveryInProgress())
2567  SetConfigOption("in_hot_standby", "true",
2568  PGC_INTERNAL, PGC_S_OVERRIDE);
2569 
2570  /* Transmit initial values of interesting variables */
2571  hash_seq_init(&status, guc_hashtab);
2572  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
2573  {
2574  struct config_generic *conf = hentry->gucvar;
2575 
2576  if (conf->flags & GUC_REPORT)
2577  ReportGUCOption(conf);
2578  }
2579 }
DestRemote
@ DestRemote
Definition: dest.h:89
hash_seq_search
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1420
hash_seq_init
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1385
ReportGUCOption
static void ReportGUCOption(struct config_generic *record)
Definition: guc.c:2633
SetConfigOption
void SetConfigOption(const char *name, const char *value, GucContext context, GucSource source)
Definition: guc.c:4291
guc_hashtab
static HTAB * guc_hashtab
Definition: guc.c:211
reporting_enabled
static bool reporting_enabled
Definition: guc.c:228
whereToSendOutput
CommandDest whereToSendOutput
Definition: postgres.c:91
GUCHashEntry::gucvar
struct config_generic * gucvar
Definition: guc.c:208
HASH_SEQ_STATUS
Definition: hsearch.h:121
RecoveryInProgress
bool RecoveryInProgress(void)
Definition: xlog.c:6333

References DestRemote, config_generic::flags, guc_hashtab, GUC_REPORT, GUCHashEntry::gucvar, hash_seq_init(), hash_seq_search(), PGC_INTERNAL, PGC_S_OVERRIDE, RecoveryInProgress(), ReportGUCOption(), reporting_enabled, SetConfigOption(), and whereToSendOutput.

Referenced by PostgresMain().

◆ check_GUC_name_for_parameter_acl()

void check_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1409 of file guc.c.

1410 {
1411  /* OK if the GUC exists. */
1412  if (find_option(name, false, true, DEBUG5) != NULL)
1413  return;
1414  /* Otherwise, it'd better be a valid custom GUC name. */
1415  (void) assignable_custom_variable_name(name, false, ERROR);
1416 }

References assignable_custom_variable_name(), DEBUG5, ERROR, find_option(), and name.

Referenced by ParameterAclCreate().

◆ convert_GUC_name_for_parameter_acl()

char* convert_GUC_name_for_parameter_acl ( const char *  name)

Definition at line 1373 of file guc.c.

1374 {
1375  char *result;
1376 
1377  /* Apply old-GUC-name mapping. */
1378  for (int i = 0; map_old_guc_names[i] != NULL; i += 2)
1379  {
1380  if (guc_name_compare(name, map_old_guc_names[i]) == 0)
1381  {
1382  name = map_old_guc_names[i + 1];
1383  break;
1384  }
1385  }
1386 
1387  /* Apply case-folding that matches guc_name_compare(). */
1388  result = pstrdup(name);
1389  for (char *ptr = result; *ptr != '\0'; ptr++)
1390  {
1391  char ch = *ptr;
1392 
1393  if (ch >= 'A' && ch <= 'Z')
1394  {
1395  ch += 'a' - 'A';
1396  *ptr = ch;
1397  }
1398  }
1399 
1400  return result;
1401 }
map_old_guc_names
static const char *const map_old_guc_names[]
Definition: guc.c:190
guc_name_compare
int guc_name_compare(const char *namea, const char *nameb)
Definition: guc.c:1299
i
int i
Definition: isn.c:73
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1696

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 
)

◆ DefineCustomEnumVariable()

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

◆ DefineCustomIntVariable()

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

◆ DefineCustomRealVariable()

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

◆ DefineCustomStringVariable()

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

◆ EstimateGUCStateSpace()

Size EstimateGUCStateSpace ( void  )

Definition at line 5913 of file guc.c.

5914 {
5915  Size size;
5916  dlist_iter iter;
5917 
5918  /* Add space reqd for saving the data size of the guc state */
5919  size = sizeof(Size);
5920 
5921  /*
5922  * Add up the space needed for each GUC variable.
5923  *
5924  * We need only process non-default GUCs.
5925  */
5926  dlist_foreach(iter, &guc_nondef_list)
5927  {
5928  struct config_generic *gconf = dlist_container(struct config_generic,
5929  nondef_link, iter.cur);
5930 
5931  size = add_size(size, estimate_variable_size(gconf));
5932  }
5933 
5934  return size;
5935 }
Size
size_t Size
Definition: c.h:605
guc_nondef_list
static dlist_head guc_nondef_list
Definition: guc.c:221
estimate_variable_size
static Size estimate_variable_size(struct config_generic *gconf)
Definition: guc.c:5813
dlist_foreach
#define dlist_foreach(iter, lhead)
Definition: ilist.h:623
dlist_container
#define dlist_container(type, membername, ptr)
Definition: ilist.h:593
add_size
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
size
static pg_noinline void Size size
Definition: slab.c:607
config_generic::nondef_link
dlist_node nondef_link
Definition: guc_tables.h:173
dlist_iter
Definition: ilist.h:178
dlist_iter::cur
dlist_node * cur
Definition: ilist.h:179

References add_size(), dlist_iter::cur, dlist_container, dlist_foreach, estimate_variable_size(), guc_nondef_list, config_generic::nondef_link, and size.

Referenced by InitializeParallelDSM().

◆ ExecSetVariableStmt()

void ExecSetVariableStmt ( VariableSetStmt *  stmt,
bool  isTopLevel 
)

Definition at line 43 of file guc_funcs.c.

44 {
45  GucAction action = stmt->is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET;
46 
47  /*
48  * Workers synchronize these parameters at the start of the parallel
49  * operation; then, we block SET during the operation.
50  */
51  if (IsInParallelMode())
52  ereport(ERROR,
53  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
54  errmsg("cannot set parameters during a parallel operation")));
55 
56  switch (stmt->kind)
57  {
58  case VAR_SET_VALUE:
59  case VAR_SET_CURRENT:
60  if (stmt->is_local)
61  WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
62  (void) set_config_option(stmt->name,
63  ExtractSetVariableArgs(stmt),
64  (superuser() ? PGC_SUSET : PGC_USERSET),
65  PGC_S_SESSION,
66  action, true, 0, false);
67  break;
68  case VAR_SET_MULTI:
69 
70  /*
71  * Special-case SQL syntaxes. The TRANSACTION and SESSION
72  * CHARACTERISTICS cases effectively set more than one variable
73  * per statement. TRANSACTION SNAPSHOT only takes one argument,
74  * but we put it here anyway since it's a special case and not
75  * related to any GUC variable.
76  */
77  if (strcmp(stmt->name, "TRANSACTION") == 0)
78  {
79  ListCell *head;
80 
81  WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
82 
83  foreach(head, stmt->args)
84  {
85  DefElem *item = (DefElem *) lfirst(head);
86 
87  if (strcmp(item->defname, "transaction_isolation") == 0)
88  SetPGVariable("transaction_isolation",
89  list_make1(item->arg), stmt->is_local);
90  else if (strcmp(item->defname, "transaction_read_only") == 0)
91  SetPGVariable("transaction_read_only",
92  list_make1(item->arg), stmt->is_local);
93  else if (strcmp(item->defname, "transaction_deferrable") == 0)
94  SetPGVariable("transaction_deferrable",
95  list_make1(item->arg), stmt->is_local);
96  else
97  elog(ERROR, "unexpected SET TRANSACTION element: %s",
98  item->defname);
99  }
100  }
101  else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0)
102  {
103  ListCell *head;
104 
105  foreach(head, stmt->args)
106  {
107  DefElem *item = (DefElem *) lfirst(head);
108 
109  if (strcmp(item->defname, "transaction_isolation") == 0)
110  SetPGVariable("default_transaction_isolation",
111  list_make1(item->arg), stmt->is_local);
112  else if (strcmp(item->defname, "transaction_read_only") == 0)
113  SetPGVariable("default_transaction_read_only",
114  list_make1(item->arg), stmt->is_local);
115  else if (strcmp(item->defname, "transaction_deferrable") == 0)
116  SetPGVariable("default_transaction_deferrable",
117  list_make1(item->arg), stmt->is_local);
118  else
119  elog(ERROR, "unexpected SET SESSION element: %s",
120  item->defname);
121  }
122  }
123  else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
124  {
125  A_Const *con = linitial_node(A_Const, stmt->args);
126 
127  if (stmt->is_local)
128  ereport(ERROR,
129  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
130  errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));
131 
132  WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
133  ImportSnapshot(strVal(&con->val));
134  }
135  else
136  elog(ERROR, "unexpected SET MULTI element: %s",
137  stmt->name);
138  break;
139  case VAR_SET_DEFAULT:
140  if (stmt->is_local)
141  WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
142  /* fall through */
143  case VAR_RESET:
144  (void) set_config_option(stmt->name,
145  NULL,
146  (superuser() ? PGC_SUSET : PGC_USERSET),
147  PGC_S_SESSION,
148  action, true, 0, false);
149  break;
150  case VAR_RESET_ALL:
151  ResetAllOptions();
152  break;
153  }
154 
155  /* Invoke the post-alter hook for setting this GUC variable, by name. */
156  InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, stmt->name,
157  ACL_SET, stmt->kind, false);
158 }
ResetAllOptions
void ResetAllOptions(void)
Definition: guc.c:2002
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: guc.c:3342
SetPGVariable
void SetPGVariable(const char *name, List *args, bool is_local)
Definition: guc_funcs.c:315
stmt
#define stmt
Definition: indent_codes.h:59
generate_unaccent_rules.action
action
Definition: generate_unaccent_rules.py:287
ACL_SET
#define ACL_SET
Definition: parsenodes.h:88
VAR_SET_MULTI
@ VAR_SET_MULTI
Definition: parsenodes.h:2612
VAR_SET_CURRENT
@ VAR_SET_CURRENT
Definition: parsenodes.h:2611
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
linitial_node
#define linitial_node(type, l)
Definition: pg_list.h:181
list_make1
#define list_make1(x1)
Definition: pg_list.h:212
ImportSnapshot
void ImportSnapshot(const char *idstr)
Definition: snapmgr.c:1367
A_Const
Definition: parsenodes.h:360
A_Const::val
union ValUnion val
Definition: parsenodes.h:364
DefElem::defname
char * defname
Definition: parsenodes.h:817
DefElem::arg
Node * arg
Definition: parsenodes.h:818
strVal
#define strVal(v)
Definition: value.h:82
WarnNoTransactionBlock
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3700
IsInParallelMode
bool IsInParallelMode(void)
Definition: xact.c:1088

References ACL_SET, generate_unaccent_rules::action, DefElem::arg, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, ExtractSetVariableArgs(), GUC_ACTION_LOCAL, GUC_ACTION_SET, ImportSnapshot(), InvokeObjectPostAlterHookArgStr, IsInParallelMode(), lfirst, linitial_node, list_make1, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, ResetAllOptions(), set_config_option(), SetPGVariable(), stmt, 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 167 of file guc_funcs.c.

168 {
169  switch (stmt->kind)
170  {
171  case VAR_SET_VALUE:
172  return flatten_set_variable_args(stmt->name, stmt->args);
173  case VAR_SET_CURRENT:
174  return GetConfigOptionByName(stmt->name, NULL, false);
175  default:
176  return NULL;
177  }
178 }
GetConfigOptionByName
char * GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
Definition: guc.c:5391
flatten_set_variable_args
static char * flatten_set_variable_args(const char *name, List *args)
Definition: guc_funcs.c:192

References flatten_set_variable_args(), GetConfigOptionByName(), stmt, 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().

◆ get_config_handle()

config_handle* get_config_handle ( const char *  name)

Definition at line 4243 of file guc.c.

4244 {
4245  struct config_generic *gen = find_option(name, false, false, 0);
4246 
4247  if (gen && ((gen->flags & GUC_CUSTOM_PLACEHOLDER) == 0))
4248  return gen;
4249 
4250  return NULL;
4251 }
GUC_CUSTOM_PLACEHOLDER
#define GUC_CUSTOM_PLACEHOLDER
Definition: guc.h:219

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

Referenced by fmgr_security_definer().

◆ get_config_unit_name()

const char* get_config_unit_name ( int  flags)

Definition at line 2813 of file guc.c.

2814 {
2815  switch (flags & GUC_UNIT)
2816  {
2817  case 0:
2818  return NULL; /* GUC has no units */
2819  case GUC_UNIT_BYTE:
2820  return "B";
2821  case GUC_UNIT_KB:
2822  return "kB";
2823  case GUC_UNIT_MB:
2824  return "MB";
2825  case GUC_UNIT_BLOCKS:
2826  {
2827  static char bbuf[8];
2828 
2829  /* initialize if first time through */
2830  if (bbuf[0] == '\0')
2831  snprintf(bbuf, sizeof(bbuf), "%dkB", BLCKSZ / 1024);
2832  return bbuf;
2833  }
2834  case GUC_UNIT_XBLOCKS:
2835  {
2836  static char xbuf[8];
2837 
2838  /* initialize if first time through */
2839  if (xbuf[0] == '\0')
2840  snprintf(xbuf, sizeof(xbuf), "%dkB", XLOG_BLCKSZ / 1024);
2841  return xbuf;
2842  }
2843  case GUC_UNIT_MS:
2844  return "ms";
2845  case GUC_UNIT_S:
2846  return "s";
2847  case GUC_UNIT_MIN:
2848  return "min";
2849  default:
2850  elog(ERROR, "unrecognized GUC units value: %d",
2851  flags & GUC_UNIT);
2852  return NULL;
2853  }
2854 }
GUC_UNIT_MB
#define GUC_UNIT_MB
Definition: guc.h:231
GUC_UNIT
#define GUC_UNIT
Definition: guc.h:240
GUC_UNIT_MS
#define GUC_UNIT_MS
Definition: guc.h:235
GUC_UNIT_BLOCKS
#define GUC_UNIT_BLOCKS
Definition: guc.h:229
GUC_UNIT_XBLOCKS
#define GUC_UNIT_XBLOCKS
Definition: guc.h:230
GUC_UNIT_BYTE
#define GUC_UNIT_BYTE
Definition: guc.h:232
GUC_UNIT_S
#define GUC_UNIT_S
Definition: guc.h:236
GUC_UNIT_KB
#define GUC_UNIT_KB
Definition: guc.h:228
GUC_UNIT_MIN
#define GUC_UNIT_MIN
Definition: guc.h:237

References elog, ERROR, config_generic::flags, GUC_UNIT, GUC_UNIT_BLOCKS, GUC_UNIT_BYTE, GUC_UNIT_KB, GUC_UNIT_MB, GUC_UNIT_MIN, GUC_UNIT_MS, GUC_UNIT_S, GUC_UNIT_XBLOCKS, and snprintf.

Referenced by GetConfigOptionValues(), and parse_and_validate_value().

◆ GetConfigOption()

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

Definition at line 4314 of file guc.c.

4315 {
4316  struct config_generic *record;
4317  static char buffer[256];
4318 
4319  record = find_option(name, false, missing_ok, ERROR);
4320  if (record == NULL)
4321  return NULL;
4322  if (restrict_privileged &&
4323  !ConfigOptionIsVisible(record))
4324  ereport(ERROR,
4325  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4326  errmsg("permission denied to examine \"%s\"", name),
4327  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4328  "pg_read_all_settings")));
4329 
4330  switch (record->vartype)
4331  {
4332  case PGC_BOOL:
4333  return *((struct config_bool *) record)->variable ? "on" : "off";
4334 
4335  case PGC_INT:
4336  snprintf(buffer, sizeof(buffer), "%d",
4337  *((struct config_int *) record)->variable);
4338  return buffer;
4339 
4340  case PGC_REAL:
4341  snprintf(buffer, sizeof(buffer), "%g",
4342  *((struct config_real *) record)->variable);
4343  return buffer;
4344 
4345  case PGC_STRING:
4346  return *((struct config_string *) record)->variable ?
4347  *((struct config_string *) record)->variable : "";
4348 
4349  case PGC_ENUM:
4350  return config_enum_lookup_by_value((struct config_enum *) record,
4351  *((struct config_enum *) record)->variable);
4352  }
4353  return NULL;
4354 }
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:1203
config_enum_lookup_by_value
const char * config_enum_lookup_by_value(struct config_enum *record, int val)
Definition: guc.c:3022
ConfigOptionIsVisible
bool ConfigOptionIsVisible(struct config_generic *conf)
Definition: guc_funcs.c:581

References config_enum_lookup_by_value(), ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_option(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, snprintf, and config_generic::vartype.

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

◆ GetConfigOptionByName()

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

Definition at line 5391 of file guc.c.

5392 {
5393  struct config_generic *record;
5394 
5395  record = find_option(name, false, missing_ok, ERROR);
5396  if (record == NULL)
5397  {
5398  if (varname)
5399  *varname = NULL;
5400  return NULL;
5401  }
5402 
5403  if (!ConfigOptionIsVisible(record))
5404  ereport(ERROR,
5405  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5406  errmsg("permission denied to examine \"%s\"", name),
5407  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
5408  "pg_read_all_settings")));
5409 
5410  if (varname)
5411  *varname = record->name;
5412 
5413  return ShowGUCOption(record, true);
5414 }
ShowGUCOption
char * ShowGUCOption(struct config_generic *record, bool use_units)
Definition: guc.c:5424
config_generic::name
const char * name
Definition: guc_tables.h:156

References ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_option(), name, config_generic::name, and ShowGUCOption().

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

◆ GetConfigOptionFlags()

int GetConfigOptionFlags ( const char *  name,
bool  missing_ok 
)

Definition at line 4411 of file guc.c.

4412 {
4413  struct config_generic *record;
4414 
4415  record = find_option(name, false, missing_ok, ERROR);
4416  if (record == NULL)
4417  return 0;
4418  return record->flags;
4419 }

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

4365 {
4366  struct config_generic *record;
4367  static char buffer[256];
4368 
4369  record = find_option(name, false, false, ERROR);
4370  Assert(record != NULL);
4371  if (!ConfigOptionIsVisible(record))
4372  ereport(ERROR,
4373  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4374  errmsg("permission denied to examine \"%s\"", name),
4375  errdetail("Only roles with privileges of the \"%s\" role may examine this parameter.",
4376  "pg_read_all_settings")));
4377 
4378  switch (record->vartype)
4379  {
4380  case PGC_BOOL:
4381  return ((struct config_bool *) record)->reset_val ? "on" : "off";
4382 
4383  case PGC_INT:
4384  snprintf(buffer, sizeof(buffer), "%d",
4385  ((struct config_int *) record)->reset_val);
4386  return buffer;
4387 
4388  case PGC_REAL:
4389  snprintf(buffer, sizeof(buffer), "%g",
4390  ((struct config_real *) record)->reset_val);
4391  return buffer;
4392 
4393  case PGC_STRING:
4394  return ((struct config_string *) record)->reset_val ?
4395  ((struct config_string *) record)->reset_val : "";
4396 
4397  case PGC_ENUM:
4398  return config_enum_lookup_by_value((struct config_enum *) record,
4399  ((struct config_enum *) record)->reset_val);
4400  }
4401  return NULL;
4402 }
config_string::reset_val
char * reset_val
Definition: guc_tables.h:264

References Assert, config_enum_lookup_by_value(), ConfigOptionIsVisible(), ereport, errcode(), errdetail(), errmsg(), ERROR, find_option(), name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, config_string::reset_val, snprintf, and config_generic::vartype.

Referenced by check_datestyle().

◆ GetPGVariable()

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

Definition at line 382 of file guc_funcs.c.

383 {
384  if (guc_name_compare(name, "all") == 0)
385  ShowAllGUCConfig(dest);
386  else
387  ShowGUCConfigOption(name, dest);
388 }
ShowGUCConfigOption
static void ShowGUCConfigOption(const char *name, DestReceiver *dest)
Definition: guc_funcs.c:428
ShowAllGUCConfig
static void ShowAllGUCConfig(DestReceiver *dest)
Definition: guc_funcs.c:456
generate_unaccent_rules.dest
dest
Definition: generate_unaccent_rules.py:285

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 394 of file guc_funcs.c.

395 {
396  TupleDesc tupdesc;
397 
398  if (guc_name_compare(name, "all") == 0)
399  {
400  /* need a tuple descriptor representing three TEXT columns */
401  tupdesc = CreateTemplateTupleDesc(3);
402  TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
403  TEXTOID, -1, 0);
404  TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
405  TEXTOID, -1, 0);
406  TupleDescInitEntry(tupdesc, (AttrNumber) 3, "description",
407  TEXTOID, -1, 0);
408  }
409  else
410  {
411  const char *varname;
412 
413  /* Get the canonical spelling of name */
414  (void) GetConfigOptionByName(name, &varname, false);
415 
416  /* need a tuple descriptor representing a single TEXT column */
417  tupdesc = CreateTemplateTupleDesc(1);
418  TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
419  TEXTOID, -1, 0);
420  }
421  return tupdesc;
422 }
AttrNumber
int16 AttrNumber
Definition: attnum.h:21
CreateTemplateTupleDesc
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:67
TupleDescInitEntry
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:651

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

Referenced by UtilityTupleDescriptor().

◆ GUC_check_errcode()

void GUC_check_errcode ( int  sqlerrcode)

Definition at line 6750 of file guc.c.

6751 {
6752  GUC_check_errcode_value = sqlerrcode;
6753 }
GUC_check_errcode_value
static int GUC_check_errcode_value
Definition: guc.c:76

References GUC_check_errcode_value.

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

◆ guc_free()

void guc_free ( void *  ptr)

Definition at line 688 of file guc.c.

689 {
690  /*
691  * Historically, GUC-related code has relied heavily on the ability to do
692  * free(NULL), so we allow that here even though pfree() doesn't.
693  */
694  if (ptr != NULL)
695  {
696  /* This is to help catch old code that malloc's GUC data. */
697  Assert(GetMemoryChunkContext(ptr) == GUCMemoryContext);
698  pfree(ptr);
699  }
700 }
GUCMemoryContext
static MemoryContext GUCMemoryContext
Definition: guc.c:198
GetMemoryChunkContext
MemoryContext GetMemoryChunkContext(void *pointer)
Definition: mcxt.c:707

References Assert, GetMemoryChunkContext(), GUCMemoryContext, and pfree().

Referenced by add_placeholder_variable(), AlterSystemSetConfigFile(), call_string_check_hook(), check_client_encoding(), check_datestyle(), check_default_text_search_config(), define_custom_variable(), parse_and_validate_value(), ReportGUCOption(), RestoreGUCState(), SelectConfigFiles(), set_config_sourcefile(), set_config_with_handle(), set_extra_field(), and set_string_field().

◆ guc_malloc()

void* guc_malloc ( int  elevel,
size_t  size 
)

Definition at line 637 of file guc.c.

638 {
639  void *data;
640 
641  data = MemoryContextAllocExtended(GUCMemoryContext, size,
642  MCXT_ALLOC_NO_OOM);
643  if (unlikely(data == NULL))
644  ereport(elevel,
645  (errcode(ERRCODE_OUT_OF_MEMORY),
646  errmsg("out of memory")));
647  return data;
648 }
unlikely
#define unlikely(x)
Definition: c.h:311
MCXT_ALLOC_NO_OOM
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:17
MemoryContextAllocExtended
void * MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
Definition: mcxt.c:1238
data
const void * data
Definition: pg_crc32c_sse42.c:23

References data, ereport, errcode(), errmsg(), GUCMemoryContext, MCXT_ALLOC_NO_OOM, MemoryContextAllocExtended(), size, and unlikely.

Referenced by add_placeholder_variable(), check_backtrace_functions(), check_client_encoding(), check_createrole_self_grant(), check_datestyle(), check_debug_io_direct(), check_log_destination(), check_log_timezone(), check_random_seed(), check_recovery_target_lsn(), check_recovery_target_timeline(), check_recovery_target_xid(), check_restrict_nonsystem_relation_kind(), check_role(), check_session_authorization(), check_synchronized_standby_slots(), check_synchronous_standby_names(), check_temp_tablespaces(), check_timezone(), check_wal_consistency_checking(), ConvertTimeZoneAbbrevs(), guc_strdup(), init_custom_variable(), plpgsql_extra_checks_check_hook(), and SelectConfigFiles().

◆ guc_realloc()

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

Definition at line 651 of file guc.c.

652 {
653  void *data;
654 
655  if (old != NULL)
656  {
657  /* This is to help catch old code that malloc's GUC data. */
658  Assert(GetMemoryChunkContext(old) == GUCMemoryContext);
659  data = repalloc_extended(old, size,
660  MCXT_ALLOC_NO_OOM);
661  }
662  else
663  {
664  /* Like realloc(3), but not like repalloc(), we allow old == NULL. */
665  data = MemoryContextAllocExtended(GUCMemoryContext, size,
666  MCXT_ALLOC_NO_OOM);
667  }
668  if (unlikely(data == NULL))
669  ereport(elevel,
670  (errcode(ERRCODE_OUT_OF_MEMORY),
671  errmsg("out of memory")));
672  return data;
673 }
repalloc_extended
void * repalloc_extended(void *pointer, Size size, int flags)
Definition: mcxt.c:1582

References Assert, data, ereport, errcode(), errmsg(), GetMemoryChunkContext(), GUCMemoryContext, MCXT_ALLOC_NO_OOM, MemoryContextAllocExtended(), repalloc_extended(), size, and unlikely.

◆ guc_strdup()

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

Definition at line 676 of file guc.c.

677 {
678  char *data;
679  size_t len = strlen(src) + 1;
680 
681  data = guc_malloc(elevel, len);
682  if (likely(data != NULL))
683  memcpy(data, src, len);
684  return data;
685 }
likely
#define likely(x)
Definition: c.h:310
guc_malloc
void * guc_malloc(int elevel, size_t size)
Definition: guc.c:637
len
const void size_t len
Definition: pg_crc32c_sse42.c:24

References data, guc_malloc(), len, and likely.

Referenced by add_placeholder_variable(), check_application_name(), check_client_encoding(), check_cluster_name(), check_datestyle(), check_default_text_search_config(), init_custom_variable(), InitializeOneGUCOption(), parse_and_validate_value(), ReportGUCOption(), set_config_sourcefile(), and set_config_with_handle().

◆ GUCArrayAdd()

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

Definition at line 6453 of file guc.c.

6454 {
6455  struct config_generic *record;
6456  Datum datum;
6457  char *newval;
6458  ArrayType *a;
6459 
6460  Assert(name);
6461  Assert(value);
6462 
6463  /* test if the option is valid and we're allowed to set it */
6464  (void) validate_option_array_item(name, value, false);
6465 
6466  /* normalize name (converts obsolete GUC names to modern spellings) */
6467  record = find_option(name, false, true, WARNING);
6468  if (record)
6469  name = record->name;
6470 
6471  /* build new item for array */
6472  newval = psprintf("%s=%s", name, value);
6473  datum = CStringGetTextDatum(newval);
6474 
6475  if (array)
6476  {
6477  int index;
6478  bool isnull;
6479  int i;
6480 
6481  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6482  Assert(ARR_NDIM(array) == 1);
6483  Assert(ARR_LBOUND(array)[0] == 1);
6484 
6485  index = ARR_DIMS(array)[0] + 1; /* add after end */
6486 
6487  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6488  {
6489  Datum d;
6490  char *current;
6491 
6492  d = array_ref(array, 1, &i,
6493  -1 /* varlenarray */ ,
6494  -1 /* TEXT's typlen */ ,
6495  false /* TEXT's typbyval */ ,
6496  TYPALIGN_INT /* TEXT's typalign */ ,
6497  &isnull);
6498  if (isnull)
6499  continue;
6500  current = TextDatumGetCString(d);
6501 
6502  /* check for match up through and including '=' */
6503  if (strncmp(current, newval, strlen(name) + 1) == 0)
6504  {
6505  index = i;
6506  break;
6507  }
6508  }
6509 
6510  a = array_set(array, 1, &index,
6511  datum,
6512  false,
6513  -1 /* varlena array */ ,
6514  -1 /* TEXT's typlen */ ,
6515  false /* TEXT's typbyval */ ,
6516  TYPALIGN_INT /* TEXT's typalign */ );
6517  }
6518  else
6519  a = construct_array_builtin(&datum, 1, TEXTOID);
6520 
6521  return a;
6522 }
ARR_NDIM
#define ARR_NDIM(a)
Definition: array.h:290
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:292
ARR_DIMS
#define ARR_DIMS(a)
Definition: array.h:294
ARR_LBOUND
#define ARR_LBOUND(a)
Definition: array.h:296
construct_array_builtin
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3381
array_set
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3163
array_ref
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3146
CStringGetTextDatum
#define CStringGetTextDatum(s)
Definition: builtins.h:97
TextDatumGetCString
#define TextDatumGetCString(d)
Definition: builtins.h:98
validate_option_array_item
static bool validate_option_array_item(const char *name, const char *value, bool skipIfNoPermissions)
Definition: guc.c:6673
a
int a
Definition: isn.c:69
Datum
uintptr_t Datum
Definition: postgres.h:64
psprintf
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
index
Definition: type.h:95

References a, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), array_set(), Assert, construct_array_builtin(), 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 6531 of file guc.c.

6532 {
6533  struct config_generic *record;
6534  ArrayType *newarray;
6535  int i;
6536  int index;
6537 
6538  Assert(name);
6539 
6540  /* test if the option is valid and we're allowed to set it */
6541  (void) validate_option_array_item(name, NULL, false);
6542 
6543  /* normalize name (converts obsolete GUC names to modern spellings) */
6544  record = find_option(name, false, true, WARNING);
6545  if (record)
6546  name = record->name;
6547 
6548  /* if array is currently null, then surely nothing to delete */
6549  if (!array)
6550  return NULL;
6551 
6552  newarray = NULL;
6553  index = 1;
6554 
6555  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6556  {
6557  Datum d;
6558  char *val;
6559  bool isnull;
6560 
6561  d = array_ref(array, 1, &i,
6562  -1 /* varlenarray */ ,
6563  -1 /* TEXT's typlen */ ,
6564  false /* TEXT's typbyval */ ,
6565  TYPALIGN_INT /* TEXT's typalign */ ,
6566  &isnull);
6567  if (isnull)
6568  continue;
6569  val = TextDatumGetCString(d);
6570 
6571  /* ignore entry if it's what we want to delete */
6572  if (strncmp(val, name, strlen(name)) == 0
6573  && val[strlen(name)] == '=')
6574  continue;
6575 
6576  /* else add it to the output array */
6577  if (newarray)
6578  newarray = array_set(newarray, 1, &index,
6579  d,
6580  false,
6581  -1 /* varlenarray */ ,
6582  -1 /* TEXT's typlen */ ,
6583  false /* TEXT's typbyval */ ,
6584  TYPALIGN_INT /* TEXT's typalign */ );
6585  else
6586  newarray = construct_array_builtin(&d, 1, TEXTOID);
6587 
6588  index++;
6589  }
6590 
6591  return newarray;
6592 }
val
long val
Definition: informix.c:689

References ARR_DIMS, array_ref(), array_set(), Assert, construct_array_builtin(), 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 6601 of file guc.c.

6602 {
6603  ArrayType *newarray;
6604  int i;
6605  int index;
6606 
6607  /* if array is currently null, nothing to do */
6608  if (!array)
6609  return NULL;
6610 
6611  /* if we're superuser, we can delete everything, so just do it */
6612  if (superuser())
6613  return NULL;
6614 
6615  newarray = NULL;
6616  index = 1;
6617 
6618  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6619  {
6620  Datum d;
6621  char *val;
6622  char *eqsgn;
6623  bool isnull;
6624 
6625  d = array_ref(array, 1, &i,
6626  -1 /* varlenarray */ ,
6627  -1 /* TEXT's typlen */ ,
6628  false /* TEXT's typbyval */ ,
6629  TYPALIGN_INT /* TEXT's typalign */ ,
6630  &isnull);
6631  if (isnull)
6632  continue;
6633  val = TextDatumGetCString(d);
6634 
6635  eqsgn = strchr(val, '=');
6636  *eqsgn = '\0';
6637 
6638  /* skip if we have permission to delete it */
6639  if (validate_option_array_item(val, NULL, true))
6640  continue;
6641 
6642  /* else add it to the output array */
6643  if (newarray)
6644  newarray = array_set(newarray, 1, &index,
6645  d,
6646  false,
6647  -1 /* varlenarray */ ,
6648  -1 /* TEXT's typlen */ ,
6649  false /* TEXT's typbyval */ ,
6650  TYPALIGN_INT /* TEXT's typalign */ );
6651  else
6652  newarray = construct_array_builtin(&d, 1, TEXTOID);
6653 
6654  index++;
6655  pfree(val);
6656  }
6657 
6658  return newarray;
6659 }

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

Referenced by AlterSetting().

◆ InitializeGUCOptions()

void InitializeGUCOptions ( void  )

Definition at line 1529 of file guc.c.

1530 {
1531  HASH_SEQ_STATUS status;
1532  GUCHashEntry *hentry;
1533 
1534  /*
1535  * Before log_line_prefix could possibly receive a nonempty setting, make
1536  * sure that timezone processing is minimally alive (see elog.c).
1537  */
1538  pg_timezone_initialize();
1539 
1540  /*
1541  * Create GUCMemoryContext and build hash table of all GUC variables.
1542  */
1543  build_guc_variables();
1544 
1545  /*
1546  * Load all variables with their compiled-in defaults, and initialize
1547  * status fields as needed.
1548  */
1549  hash_seq_init(&status, guc_hashtab);
1550  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
1551  {
1552  /* Check mapping between initial and default value */
1553  Assert(check_GUC_init(hentry->gucvar));
1554 
1555  InitializeOneGUCOption(hentry->gucvar);
1556  }
1557 
1558  reporting_enabled = false;
1559 
1560  /*
1561  * Prevent any attempt to override the transaction modes from
1562  * non-interactive sources.
1563  */
1564  SetConfigOption("transaction_isolation", "read committed",
1565  PGC_POSTMASTER, PGC_S_OVERRIDE);
1566  SetConfigOption("transaction_read_only", "no",
1567  PGC_POSTMASTER, PGC_S_OVERRIDE);
1568  SetConfigOption("transaction_deferrable", "no",
1569  PGC_POSTMASTER, PGC_S_OVERRIDE);
1570 
1571  /*
1572  * For historical reasons, some GUC parameters can receive defaults from
1573  * environment variables. Process those settings.
1574  */
1575  InitializeGUCOptionsFromEnvironment();
1576 }
InitializeOneGUCOption
static void InitializeOneGUCOption(struct config_generic *gconf)
Definition: guc.c:1643
build_guc_variables
void build_guc_variables(void)
Definition: guc.c:902
InitializeGUCOptionsFromEnvironment
static void InitializeGUCOptionsFromEnvironment(void)
Definition: guc.c:1588
pg_timezone_initialize
void pg_timezone_initialize(void)
Definition: pgtz.c:361

References Assert, build_guc_variables(), guc_hashtab, GUCHashEntry::gucvar, hash_seq_init(), hash_seq_search(), InitializeGUCOptionsFromEnvironment(), InitializeOneGUCOption(), pg_timezone_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, reporting_enabled, and SetConfigOption().

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

◆ MarkGUCPrefixReserved()

void void void void void void MarkGUCPrefixReserved ( const char *  className)

Definition at line 5238 of file guc.c.

5239 {
5240  int classLen = strlen(className);
5241  HASH_SEQ_STATUS status;
5242  GUCHashEntry *hentry;
5243  MemoryContext oldcontext;
5244 
5245  /*
5246  * Check for existing placeholders. We must actually remove invalid
5247  * placeholders, else future parallel worker startups will fail. (We
5248  * don't bother trying to free associated memory, since this shouldn't
5249  * happen often.)
5250  */
5251  hash_seq_init(&status, guc_hashtab);
5252  while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
5253  {
5254  struct config_generic *var = hentry->gucvar;
5255 
5256  if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
5257  strncmp(className, var->name, classLen) == 0 &&
5258  var->name[classLen] == GUC_QUALIFIER_SEPARATOR)
5259  {
5260  ereport(WARNING,
5261  (errcode(ERRCODE_INVALID_NAME),
5262  errmsg("invalid configuration parameter name \"%s\", removing it",
5263  var->name),
5264  errdetail("\"%s\" is now a reserved prefix.",
5265  className)));
5266  /* Remove it from the hash table */
5267  hash_search(guc_hashtab,
5268  &var->name,
5269  HASH_REMOVE,
5270  NULL);
5271  /* Remove it from any lists it's in, too */
5272  RemoveGUCFromLists(var);
5273  }
5274  }
5275 
5276  /* And remember the name so we can prevent future mistakes. */
5277  oldcontext = MemoryContextSwitchTo(GUCMemoryContext);
5278  reserved_class_prefix = lappend(reserved_class_prefix, pstrdup(className));
5279  MemoryContextSwitchTo(oldcontext);
5280 }
hash_search
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
RemoveGUCFromLists
static void RemoveGUCFromLists(struct config_generic *gconf)
Definition: guc.c:1760
reserved_class_prefix
static List * reserved_class_prefix
Definition: guc.c:78
GUC_QUALIFIER_SEPARATOR
#define GUC_QUALIFIER_SEPARATOR
Definition: guc.h:204
HASH_REMOVE
@ HASH_REMOVE
Definition: hsearch.h:115
lappend
List * lappend(List *list, void *datum)
Definition: list.c:339
MemoryContextSwitchTo
MemoryContextSwitchTo(old_ctx)

References ereport, errcode(), errdetail(), errmsg(), config_generic::flags, GUC_CUSTOM_PLACEHOLDER, guc_hashtab, GUC_QUALIFIER_SEPARATOR, GUCMemoryContext, GUCHashEntry::gucvar, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), lappend(), MemoryContextSwitchTo(), config_generic::name, pstrdup(), RemoveGUCFromLists(), reserved_class_prefix, and WARNING.

Referenced by _PG_init().

◆ NewGUCNestLevel()

int NewGUCNestLevel ( void  )

Definition at line 2234 of file guc.c.

2235 {
2236  return ++GUCNestLevel;
2237 }

References GUCNestLevel.

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

◆ parse_int()

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

Definition at line 2870 of file guc.c.

2871 {
2872  /*
2873  * We assume here that double is wide enough to represent any integer
2874  * value with adequate precision.
2875  */
2876  double val;
2877  char *endptr;
2878 
2879  /* To suppress compiler warnings, always set output params */
2880  if (result)
2881  *result = 0;
2882  if (hintmsg)
2883  *hintmsg = NULL;
2884 
2885  /*
2886  * Try to parse as an integer (allowing octal or hex input). If the
2887  * conversion stops at a decimal point or 'e', or overflows, re-parse as
2888  * float. This should work fine as long as we have no unit names starting
2889  * with 'e'. If we ever do, the test could be extended to check for a
2890  * sign or digit after 'e', but for now that's unnecessary.
2891  */
2892  errno = 0;
2893  val = strtol(value, &endptr, 0);
2894  if (*endptr == '.' || *endptr == 'e' || *endptr == 'E' ||
2895  errno == ERANGE)
2896  {
2897  errno = 0;
2898  val = strtod(value, &endptr);
2899  }
2900 
2901  if (endptr == value || errno == ERANGE)
2902  return false; /* no HINT for these cases */
2903 
2904  /* reject NaN (infinities will fail range check below) */
2905  if (isnan(val))
2906  return false; /* treat same as syntax error; no HINT */
2907 
2908  /* allow whitespace between number and unit */
2909  while (isspace((unsigned char) *endptr))
2910  endptr++;
2911 
2912  /* Handle possible unit */
2913  if (*endptr != '\0')
2914  {
2915  if ((flags & GUC_UNIT) == 0)
2916  return false; /* this setting does not accept a unit */
2917 
2918  if (!convert_to_base_unit(val,
2919  endptr, (flags & GUC_UNIT),
2920  &val))
2921  {
2922  /* invalid unit, or garbage after the unit; set hint and fail. */
2923  if (hintmsg)
2924  {
2925  if (flags & GUC_UNIT_MEMORY)
2926  *hintmsg = memory_units_hint;
2927  else
2928  *hintmsg = time_units_hint;
2929  }
2930  return false;
2931  }
2932  }
2933 
2934  /* Round to int, then check for overflow */
2935  val = rint(val);
2936 
2937  if (val > INT_MAX || val < INT_MIN)
2938  {
2939  if (hintmsg)
2940  *hintmsg = gettext_noop("Value exceeds integer range.");
2941  return false;
2942  }
2943 
2944  if (result)
2945  *result = (int) val;
2946  return true;
2947 }
gettext_noop
#define gettext_noop(x)
Definition: c.h:1196
convert_to_base_unit
static bool convert_to_base_unit(double value, const char *unit, int base_unit, double *base_value)
Definition: guc.c:2670
memory_units_hint
static const char *const memory_units_hint
Definition: guc.c:119
time_units_hint
static const char *const time_units_hint
Definition: guc.c:156
GUC_UNIT_MEMORY
#define GUC_UNIT_MEMORY
Definition: guc.h:233

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(), ExecVacuum(), 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 2960 of file guc.c.

2961 {
2962  double val;
2963  char *endptr;
2964 
2965  /* To suppress compiler warnings, always set output params */
2966  if (result)
2967  *result = 0;
2968  if (hintmsg)
2969  *hintmsg = NULL;
2970 
2971  errno = 0;
2972  val = strtod(value, &endptr);
2973 
2974  if (endptr == value || errno == ERANGE)
2975  return false; /* no HINT for these cases */
2976 
2977  /* reject NaN (infinities will fail range checks later) */
2978  if (isnan(val))
2979  return false; /* treat same as syntax error; no HINT */
2980 
2981  /* allow whitespace between number and unit */
2982  while (isspace((unsigned char) *endptr))
2983  endptr++;
2984 
2985  /* Handle possible unit */
2986  if (*endptr != '\0')
2987  {
2988  if ((flags & GUC_UNIT) == 0)
2989  return false; /* this setting does not accept a unit */
2990 
2991  if (!convert_to_base_unit(val,
2992  endptr, (flags & GUC_UNIT),
2993  &val))
2994  {
2995  /* invalid unit, or garbage after the unit; set hint and fail. */
2996  if (hintmsg)
2997  {
2998  if (flags & GUC_UNIT_MEMORY)
2999  *hintmsg = memory_units_hint;
3000  else
3001  *hintmsg = time_units_hint;
3002  }
3003  return false;
3004  }
3005  }
3006 
3007  if (result)
3008  *result = val;
3009  return true;
3010 }

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 
)

Referenced by ProcessConfigFileInternal().

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

6328 {
6329  size_t equal_pos;
6330  char *cp;
6331 
6332  Assert(string);
6333  Assert(name);
6334  Assert(value);
6335 
6336  equal_pos = strcspn(string, "=");
6337 
6338  if (string[equal_pos] == '=')
6339  {
6340  *name = palloc(equal_pos + 1);
6341  strlcpy(*name, string, equal_pos + 1);
6342 
6343  *value = pstrdup(&string[equal_pos + 1]);
6344  }
6345  else
6346  {
6347  /* no equal sign in string */
6348  *name = pstrdup(string);
6349  *value = NULL;
6350  }
6351 
6352  for (cp = *name; *cp; cp++)
6353  if (*cp == '-')
6354  *cp = '_';
6355 }
palloc
void * palloc(Size size)
Definition: mcxt.c:1317
strlcpy
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

References Assert, name, palloc(), pstrdup(), strlcpy(), and value.

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

◆ ProcessConfigFile()

void ProcessConfigFile ( GucContext  context)

Referenced by ApplyLauncherMain(), autoprewarm_main(), CheckpointWriteDelay(), do_autovacuum(), HandleAutoVacLauncherInterrupts(), HandleCheckpointerInterrupts(), HandleMainLoopInterrupts(), HandlePgArchInterrupts(), HandleWalSummarizerInterrupts(), LogicalRepApplyLoop(), PostgresMain(), process_pm_reload_request(), ProcessParallelApplyInterrupts(), ProcessPendingWrites(), SelectConfigFiles(), slotsync_reread_config(), StartupRereadConfig(), SysLoggerMain(), vacuum_delay_point(), WaitForStandbyConfirmation(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), and worker_spi_main().

◆ ProcessGUCArray()

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

Definition at line 6421 of file guc.c.

6423 {
6424  List *gucNames;
6425  List *gucValues;
6426  ListCell *lc1;
6427  ListCell *lc2;
6428 
6429  TransformGUCArray(array, &gucNames, &gucValues);
6430  forboth(lc1, gucNames, lc2, gucValues)
6431  {
6432  char *name = lfirst(lc1);
6433  char *value = lfirst(lc2);
6434 
6435  (void) set_config_option(name, value,
6436  context, source,
6437  action, true, 0, false);
6438 
6439  pfree(name);
6440  pfree(value);
6441  }
6442 
6443  list_free(gucNames);
6444  list_free(gucValues);
6445 }
TransformGUCArray
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6364
list_free
void list_free(List *list)
Definition: list.c:1546
forboth
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
source
static rewind_source * source
Definition: pg_rewind.c:89
context
tree context
Definition: radixtree.h:1835
List
Definition: pg_list.h:54

References generate_unaccent_rules::action, context, forboth, lfirst, list_free(), name, pfree(), set_config_option(), source, TransformGUCArray(), and value.

Referenced by ApplySetting(), and ProcedureCreate().

◆ ReportChangedGUCOptions()

void ReportChangedGUCOptions ( void  )

Definition at line 2595 of file guc.c.

2596 {
2597  slist_mutable_iter iter;
2598 
2599  /* Quick exit if not (yet) enabled */
2600  if (!reporting_enabled)
2601  return;
2602 
2603  /*
2604  * Since in_hot_standby isn't actually changed by normal GUC actions, we
2605  * need a hack to check whether a new value needs to be reported to the
2606  * client. For speed, we rely on the assumption that it can never
2607  * transition from false to true.
2608  */
2609  if (in_hot_standby_guc && !RecoveryInProgress())
2610  SetConfigOption("in_hot_standby", "false",
2611  PGC_INTERNAL, PGC_S_OVERRIDE);
2612 
2613  /* Transmit new values of interesting variables */
2614  slist_foreach_modify(iter, &guc_report_list)
2615  {
2616  struct config_generic *conf = slist_container(struct config_generic,
2617  report_link, iter.cur);
2618 
2619  Assert((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT));
2620  ReportGUCOption(conf);
2621  conf->status &= ~GUC_NEEDS_REPORT;
2622  slist_delete_current(&iter);
2623  }
2624 }
in_hot_standby_guc
bool in_hot_standby_guc
Definition: guc_tables.c:622

References Assert, slist_mutable_iter::cur, config_generic::flags, GUC_NEEDS_REPORT, GUC_REPORT, guc_report_list, in_hot_standby_guc, PGC_INTERNAL, PGC_S_OVERRIDE, RecoveryInProgress(), config_generic::report_link, ReportGUCOption(), reporting_enabled, SetConfigOption(), slist_container, slist_delete_current(), slist_foreach_modify, and config_generic::status.

Referenced by PostgresMain().

◆ ResetAllOptions()

void ResetAllOptions ( void  )

Definition at line 2002 of file guc.c.

2003 {
2004  dlist_mutable_iter iter;
2005 
2006  /* We need only consider GUCs not already at PGC_S_DEFAULT */
2007  dlist_foreach_modify(iter, &guc_nondef_list)
2008  {
2009  struct config_generic *gconf = dlist_container(struct config_generic,
2010  nondef_link, iter.cur);
2011 
2012  /* Don't reset non-SET-able values */
2013  if (gconf->context != PGC_SUSET &&
2014  gconf->context != PGC_USERSET)
2015  continue;
2016  /* Don't reset if special exclusion from RESET ALL */
2017  if (gconf->flags & GUC_NO_RESET_ALL)
2018  continue;
2019  /* No need to reset if wasn't SET */
2020  if (gconf->source <= PGC_S_OVERRIDE)
2021  continue;
2022 
2023  /* Save old value to support transaction abort */
2024  push_old_value(gconf, GUC_ACTION_SET);
2025 
2026  switch (gconf->vartype)
2027  {
2028  case PGC_BOOL:
2029  {
2030  struct config_bool *conf = (struct config_bool *) gconf;
2031 
2032  if (conf->assign_hook)
2033  conf->assign_hook(conf->reset_val,
2034  conf->reset_extra);
2035  *conf->variable = conf->reset_val;
2036  set_extra_field(&conf->gen, &conf->gen.extra,
2037  conf->reset_extra);
2038  break;
2039  }
2040  case PGC_INT:
2041  {
2042  struct config_int *conf = (struct config_int *) gconf;
2043 
2044  if (conf->assign_hook)
2045  conf->assign_hook(conf->reset_val,
2046  conf->reset_extra);
2047  *conf->variable = conf->reset_val;
2048  set_extra_field(&conf->gen, &conf->gen.extra,
2049  conf->reset_extra);
2050  break;
2051  }
2052  case PGC_REAL:
2053  {
2054  struct config_real *conf = (struct config_real *) gconf;
2055 
2056  if (conf->assign_hook)
2057  conf->assign_hook(conf->reset_val,
2058  conf->reset_extra);
2059  *conf->variable = conf->reset_val;
2060  set_extra_field(&conf->gen, &conf->gen.extra,
2061  conf->reset_extra);
2062  break;
2063  }
2064  case PGC_STRING:
2065  {
2066  struct config_string *conf = (struct config_string *) gconf;
2067 
2068  if (conf->assign_hook)
2069  conf->assign_hook(conf->reset_val,
2070  conf->reset_extra);
2071  set_string_field(conf, conf->variable, conf->reset_val);
2072  set_extra_field(&conf->gen, &conf->gen.extra,
2073  conf->reset_extra);
2074  break;
2075  }
2076  case PGC_ENUM:
2077  {
2078  struct config_enum *conf = (struct config_enum *) gconf;
2079 
2080  if (conf->assign_hook)
2081  conf->assign_hook(conf->reset_val,
2082  conf->reset_extra);
2083  *conf->variable = conf->reset_val;
2084  set_extra_field(&conf->gen, &conf->gen.extra,
2085  conf->reset_extra);
2086  break;
2087  }
2088  }
2089 
2090  set_guc_source(gconf, gconf->reset_source);
2091  gconf->scontext = gconf->reset_scontext;
2092  gconf->srole = gconf->reset_srole;
2093 
2094  if ((gconf->flags & GUC_REPORT) && !(gconf->status & GUC_NEEDS_REPORT))
2095  {
2096  gconf->status |= GUC_NEEDS_REPORT;
2097  slist_push_head(&guc_report_list, &gconf->report_link);
2098  }
2099  }
2100 }
push_old_value
static void push_old_value(struct config_generic *gconf, GucAction action)
Definition: guc.c:2133
GUC_NO_RESET_ALL
#define GUC_NO_RESET_ALL
Definition: guc.h:214
dlist_foreach_modify
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:640
config_bool::reset_extra
void * reset_extra
Definition: guc_tables.h:209
config_bool::reset_val
bool reset_val
Definition: guc_tables.h:208
config_enum::reset_val
int reset_val
Definition: guc_tables.h:279
config_enum::reset_extra
void * reset_extra
Definition: guc_tables.h:280
config_generic::reset_scontext
GucContext reset_scontext
Definition: guc_tables.h:168
config_generic::reset_srole
Oid reset_srole
Definition: guc_tables.h:170
config_generic::source
GucSource source
Definition: guc_tables.h:165
config_generic::reset_source
GucSource reset_source
Definition: guc_tables.h:166
config_int::reset_extra
void * reset_extra
Definition: guc_tables.h:225
config_int::reset_val
int reset_val
Definition: guc_tables.h:224
config_real::reset_extra
void * reset_extra
Definition: guc_tables.h:241
config_real::reset_val
double reset_val
Definition: guc_tables.h:240
config_string::reset_extra
void * reset_extra
Definition: guc_tables.h:265
dlist_mutable_iter
Definition: ilist.h:199
dlist_mutable_iter::cur
dlist_node * cur
Definition: ilist.h:200

References config_bool::assign_hook, config_int::assign_hook, config_real::assign_hook, config_string::assign_hook, config_enum::assign_hook, config_generic::context, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, 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_nondef_list, GUC_REPORT, guc_report_list, config_generic::nondef_link, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_OVERRIDE, PGC_STRING, PGC_SUSET, PGC_USERSET, push_old_value(), config_generic::report_link, 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_generic::reset_srole, 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_guc_source(), set_string_field(), slist_push_head(), config_generic::source, config_generic::srole, 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 6158 of file guc.c.

6159 {
6160  char *varname,
6161  *varvalue,
6162  *varsourcefile;
6163  int varsourceline;
6164  GucSource varsource;
6165  GucContext varscontext;
6166  Oid varsrole;
6167  char *srcptr = (char *) gucstate;
6168  char *srcend;
6169  Size len;
6170  dlist_mutable_iter iter;
6171  ErrorContextCallback error_context_callback;
6172 
6173  /*
6174  * First, ensure that all potentially-shippable GUCs are reset to their
6175  * default values. We must not touch those GUCs that the leader will
6176  * never ship, while there is no need to touch those that are shippable
6177  * but already have their default values. Thus, this ends up being the
6178  * same test that SerializeGUCState uses, even though the sets of
6179  * variables involved may well be different since the leader's set of
6180  * variables-not-at-default-values can differ from the set that are
6181  * not-default in this freshly started worker.
6182  *
6183  * Once we have set all the potentially-shippable GUCs to default values,
6184  * restoring the GUCs that the leader sent (because they had non-default
6185  * values over there) leads us to exactly the set of GUC values that the
6186  * leader has. This is true even though the worker may have initially
6187  * absorbed postgresql.conf settings that the leader hasn't yet seen, or
6188  * ALTER USER/DATABASE SET settings that were established after the leader
6189  * started.
6190  *
6191  * Note that ensuring all the potential target GUCs are at PGC_S_DEFAULT
6192  * also ensures that set_config_option won't refuse to set them because of
6193  * source-priority comparisons.
6194  */
6195  dlist_foreach_modify(iter, &guc_nondef_list)
6196  {
6197  struct config_generic *gconf = dlist_container(struct config_generic,
6198  nondef_link, iter.cur);
6199 
6200  /* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
6201  if (can_skip_gucvar(gconf))
6202  continue;
6203 
6204  /*
6205  * We can use InitializeOneGUCOption to reset the GUC to default, but
6206  * first we must free any existing subsidiary data to avoid leaking
6207  * memory. The stack must be empty, but we have to clean up all other
6208  * fields. Beware that there might be duplicate value or "extra"
6209  * pointers. We also have to be sure to take it out of any lists it's
6210  * in.
6211  */
6212  Assert(gconf->stack == NULL);
6213  guc_free(gconf->extra);
6214  guc_free(gconf->last_reported);
6215  guc_free(gconf->sourcefile);
6216  switch (gconf->vartype)
6217  {
6218  case PGC_BOOL:
6219  {
6220  struct config_bool *conf = (struct config_bool *) gconf;
6221 
6222  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6223  guc_free(conf->reset_extra);
6224  break;
6225  }
6226  case PGC_INT:
6227  {
6228  struct config_int *conf = (struct config_int *) gconf;
6229 
6230  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6231  guc_free(conf->reset_extra);
6232  break;
6233  }
6234  case PGC_REAL:
6235  {
6236  struct config_real *conf = (struct config_real *) gconf;
6237 
6238  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6239  guc_free(conf->reset_extra);
6240  break;
6241  }
6242  case PGC_STRING:
6243  {
6244  struct config_string *conf = (struct config_string *) gconf;
6245 
6246  guc_free(*conf->variable);
6247  if (conf->reset_val && conf->reset_val != *conf->variable)
6248  guc_free(conf->reset_val);
6249  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6250  guc_free(conf->reset_extra);
6251  break;
6252  }
6253  case PGC_ENUM:
6254  {
6255  struct config_enum *conf = (struct config_enum *) gconf;
6256 
6257  if (conf->reset_extra && conf->reset_extra != gconf->extra)
6258  guc_free(conf->reset_extra);
6259  break;
6260  }
6261  }
6262  /* Remove it from any lists it's in. */
6263  RemoveGUCFromLists(gconf);
6264  /* Now we can reset the struct to PGS_S_DEFAULT state. */
6265  InitializeOneGUCOption(gconf);
6266  }
6267 
6268  /* First item is the length of the subsequent data */
6269  memcpy(&len, gucstate, sizeof(len));
6270 
6271  srcptr += sizeof(len);
6272  srcend = srcptr + len;
6273 
6274  /* If the GUC value check fails, we want errors to show useful context. */
6275  error_context_callback.callback = guc_restore_error_context_callback;
6276  error_context_callback.previous = error_context_stack;
6277  error_context_callback.arg = NULL;
6278  error_context_stack = &error_context_callback;
6279 
6280  /* Restore all the listed GUCs. */
6281  while (srcptr < srcend)
6282  {
6283  int result;
6284  char *error_context_name_and_value[2];
6285 
6286  varname = read_gucstate(&srcptr, srcend);
6287  varvalue = read_gucstate(&srcptr, srcend);
6288  varsourcefile = read_gucstate(&srcptr, srcend);
6289  if (varsourcefile[0])
6290  read_gucstate_binary(&srcptr, srcend,
6291  &varsourceline, sizeof(varsourceline));
6292  else
6293  varsourceline = 0;
6294  read_gucstate_binary(&srcptr, srcend,
6295  &varsource, sizeof(varsource));
6296  read_gucstate_binary(&srcptr, srcend,
6297  &varscontext, sizeof(varscontext));
6298  read_gucstate_binary(&srcptr, srcend,
6299  &varsrole, sizeof(varsrole));
6300 
6301  error_context_name_and_value[0] = varname;
6302  error_context_name_and_value[1] = varvalue;
6303  error_context_callback.arg = &error_context_name_and_value[0];
6304  result = set_config_option_ext(varname, varvalue,
6305  varscontext, varsource, varsrole,
6306  GUC_ACTION_SET, true, ERROR, true);
6307  if (result <= 0)
6308  ereport(ERROR,
6309  (errcode(ERRCODE_INTERNAL_ERROR),
6310  errmsg("parameter \"%s\" could not be set", varname)));
6311  if (varsourcefile[0])
6312  set_config_sourcefile(varname, varsourcefile, varsourceline);
6313  error_context_callback.arg = NULL;
6314  }
6315 
6316  error_context_stack = error_context_callback.previous;
6317 }
error_context_stack
ErrorContextCallback * error_context_stack
Definition: elog.c:94
guc_restore_error_context_callback
static void guc_restore_error_context_callback(void *arg)
Definition: guc.c:6136
set_config_option_ext
int set_config_option_ext(const char *name, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3382
set_config_sourcefile
static void set_config_sourcefile(const char *name, char *sourcefile, int sourceline)
Definition: guc.c:4258
read_gucstate
static char * read_gucstate(char **srcptr, char *srcend)
Definition: guc.c:6099
can_skip_gucvar
static bool can_skip_gucvar(struct config_generic *gconf)
Definition: guc.c:5773
read_gucstate_binary
static void read_gucstate_binary(char **srcptr, char *srcend, void *dest, Size size)
Definition: guc.c:6122
ErrorContextCallback::previous
struct ErrorContextCallback * previous
Definition: elog.h:296
ErrorContextCallback::callback
void(* callback)(void *arg)
Definition: elog.h:297
config_generic::last_reported
char * last_reported
Definition: guc_tables.h:179
config_generic::sourcefile
char * sourcefile
Definition: guc_tables.h:181

References ErrorContextCallback::arg, Assert, ErrorContextCallback::callback, can_skip_gucvar(), dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, ereport, errcode(), errmsg(), ERROR, error_context_stack, config_generic::extra, GUC_ACTION_SET, guc_free(), guc_nondef_list, guc_restore_error_context_callback(), InitializeOneGUCOption(), config_generic::last_reported, len, config_generic::nondef_link, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, ErrorContextCallback::previous, read_gucstate(), read_gucstate_binary(), RemoveGUCFromLists(), 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_ext(), set_config_sourcefile(), config_generic::sourcefile, config_generic::stack, config_string::variable, and config_generic::vartype.

Referenced by ParallelWorkerMain().

◆ RestrictSearchPath()

void RestrictSearchPath ( void  )

Definition at line 2245 of file guc.c.

2246 {
2247  if (!IsBootstrapProcessingMode())
2248  set_config_option("search_path", GUC_SAFE_SEARCH_PATH, PGC_USERSET,
2249  PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false);
2250 }
GUC_SAFE_SEARCH_PATH
#define GUC_SAFE_SEARCH_PATH
Definition: guc.c:74
IsBootstrapProcessingMode
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:451

References GUC_ACTION_SAVE, GUC_SAFE_SEARCH_PATH, IsBootstrapProcessingMode, PGC_S_SESSION, PGC_USERSET, and set_config_option().

Referenced by brin_summarize_range(), bt_index_check_internal(), cluster_rel(), ComputeIndexAttrs(), DefineIndex(), do_analyze_rel(), index_build(), index_concurrently_build(), RefreshMatViewByOid(), reindex_index(), ReindexRelationConcurrently(), vacuum_rel(), and validate_index().

◆ SelectConfigFiles()

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

Definition at line 1783 of file guc.c.

1784 {
1785  char *configdir;
1786  char *fname;
1787  bool fname_is_malloced;
1788  struct stat stat_buf;
1789  struct config_string *data_directory_rec;
1790 
1791  /* configdir is -D option, or $PGDATA if no -D */
1792  if (userDoption)
1793  configdir = make_absolute_path(userDoption);
1794  else
1795  configdir = make_absolute_path(getenv("PGDATA"));
1796 
1797  if (configdir && stat(configdir, &stat_buf) != 0)
1798  {
1799  write_stderr("%s: could not access directory \"%s\": %m\n",
1800  progname,
1801  configdir);
1802  if (errno == ENOENT)
1803  write_stderr("Run initdb or pg_basebackup to initialize a PostgreSQL data directory.\n");
1804  return false;
1805  }
1806 
1807  /*
1808  * Find the configuration file: if config_file was specified on the
1809  * command line, use it, else use configdir/postgresql.conf. In any case
1810  * ensure the result is an absolute path, so that it will be interpreted
1811  * the same way by future backends.
1812  */
1813  if (ConfigFileName)
1814  {
1815  fname = make_absolute_path(ConfigFileName);
1816  fname_is_malloced = true;
1817  }
1818  else if (configdir)
1819  {
1820  fname = guc_malloc(FATAL,
1821  strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
1822  sprintf(fname, "%s/%s", configdir, CONFIG_FILENAME);
1823  fname_is_malloced = false;
1824  }
1825  else
1826  {
1827  write_stderr("%s does not know where to find the server configuration file.\n"
1828  "You must specify the --config-file or -D invocation "
1829  "option or set the PGDATA environment variable.\n",
1830  progname);
1831  return false;
1832  }
1833 
1834  /*
1835  * Set the ConfigFileName GUC variable to its final value, ensuring that
1836  * it can't be overridden later.
1837  */
1838  SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1839 
1840  if (fname_is_malloced)
1841  free(fname);
1842  else
1843  guc_free(fname);
1844 
1845  /*
1846  * Now read the config file for the first time.
1847  */
1848  if (stat(ConfigFileName, &stat_buf) != 0)
1849  {
1850  write_stderr("%s: could not access the server configuration file \"%s\": %m\n",
1851  progname, ConfigFileName);
1852  free(configdir);
1853  return false;
1854  }
1855 
1856  /*
1857  * Read the configuration file for the first time. This time only the
1858  * data_directory parameter is picked up to determine the data directory,
1859  * so that we can read the PG_AUTOCONF_FILENAME file next time.
1860  */
1861  ProcessConfigFile(PGC_POSTMASTER);
1862 
1863  /*
1864  * If the data_directory GUC variable has been set, use that as DataDir;
1865  * otherwise use configdir if set; else punt.
1866  *
1867  * Note: SetDataDir will copy and absolute-ize its argument, so we don't
1868  * have to.
1869  */
1870  data_directory_rec = (struct config_string *)
1871  find_option("data_directory", false, false, PANIC);
1872  if (*data_directory_rec->variable)
1873  SetDataDir(*data_directory_rec->variable);
1874  else if (configdir)
1875  SetDataDir(configdir);
1876  else
1877  {
1878  write_stderr("%s does not know where to find the database system data.\n"
1879  "This can be specified as \"data_directory\" in \"%s\", "
1880  "or by the -D invocation option, or by the "
1881  "PGDATA environment variable.\n",
1882  progname, ConfigFileName);
1883  return false;
1884  }
1885 
1886  /*
1887  * Reflect the final DataDir value back into the data_directory GUC var.
1888  * (If you are wondering why we don't just make them a single variable,
1889  * it's because the EXEC_BACKEND case needs DataDir to be transmitted to
1890  * child backends specially. XXX is that still true? Given that we now
1891  * chdir to DataDir, EXEC_BACKEND can read the config file without knowing
1892  * DataDir in advance.)
1893  */
1894  SetConfigOption("data_directory", DataDir, PGC_POSTMASTER, PGC_S_OVERRIDE);
1895 
1896  /*
1897  * Now read the config file a second time, allowing any settings in the
1898  * PG_AUTOCONF_FILENAME file to take effect. (This is pretty ugly, but
1899  * since we have to determine the DataDir before we can find the autoconf
1900  * file, the alternatives seem worse.)
1901  */
1902  ProcessConfigFile(PGC_POSTMASTER);
1903 
1904  /*
1905  * If timezone_abbreviations wasn't set in the configuration file, install
1906  * the default value. We do it this way because we can't safely install a
1907  * "real" value until my_exec_path is set, which may not have happened
1908  * when InitializeGUCOptions runs, so the bootstrap default value cannot
1909  * be the real desired default.
1910  */
1911  pg_timezone_abbrev_initialize();
1912 
1913  /*
1914  * Figure out where pg_hba.conf is, and make sure the path is absolute.
1915  */
1916  if (HbaFileName)
1917  {
1918  fname = make_absolute_path(HbaFileName);
1919  fname_is_malloced = true;
1920  }
1921  else if (configdir)
1922  {
1923  fname = guc_malloc(FATAL,
1924  strlen(configdir) + strlen(HBA_FILENAME) + 2);
1925  sprintf(fname, "%s/%s", configdir, HBA_FILENAME);
1926  fname_is_malloced = false;
1927  }
1928  else
1929  {
1930  write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
1931  "This can be specified as \"hba_file\" in \"%s\", "
1932  "or by the -D invocation option, or by the "
1933  "PGDATA environment variable.\n",
1934  progname, ConfigFileName);
1935  return false;
1936  }
1937  SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1938 
1939  if (fname_is_malloced)
1940  free(fname);
1941  else
1942  guc_free(fname);
1943 
1944  /*
1945  * Likewise for pg_ident.conf.
1946  */
1947  if (IdentFileName)
1948  {
1949  fname = make_absolute_path(IdentFileName);
1950  fname_is_malloced = true;
1951  }
1952  else if (configdir)
1953  {
1954  fname = guc_malloc(FATAL,
1955  strlen(configdir) + strlen(IDENT_FILENAME) + 2);
1956  sprintf(fname, "%s/%s", configdir, IDENT_FILENAME);
1957  fname_is_malloced = false;
1958  }
1959  else
1960  {
1961  write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
1962  "This can be specified as \"ident_file\" in \"%s\", "
1963  "or by the -D invocation option, or by the "
1964  "PGDATA environment variable.\n",
1965  progname, ConfigFileName);
1966  return false;
1967  }
1968  SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
1969 
1970  if (fname_is_malloced)
1971  free(fname);
1972  else
1973  guc_free(fname);
1974 
1975  free(configdir);
1976 
1977  return true;
1978 }
write_stderr
#define write_stderr(str)
Definition: parallel.c:184
FATAL
#define FATAL
Definition: elog.h:41
PANIC
#define PANIC
Definition: elog.h:42
DataDir
char * DataDir
Definition: globals.c:70
pg_timezone_abbrev_initialize
static void pg_timezone_abbrev_initialize(void)
Definition: guc.c:1991
IDENT_FILENAME
#define IDENT_FILENAME
Definition: guc.c:57
HBA_FILENAME
#define HBA_FILENAME
Definition: guc.c:56
CONFIG_FILENAME
#define CONFIG_FILENAME
Definition: guc.c:55
ProcessConfigFile
void ProcessConfigFile(GucContext context)
HbaFileName
char * HbaFileName
Definition: guc_tables.c:539
ConfigFileName
char * ConfigFileName
Definition: guc_tables.c:538
IdentFileName
char * IdentFileName
Definition: guc_tables.c:540
free
#define free(a)
Definition: header.h:65
progname
const char * progname
Definition: main.c:44
SetDataDir
void SetDataDir(const char *dir)
Definition: miscinit.c:434
make_absolute_path
char * make_absolute_path(const char *path)
Definition: path.c:730
sprintf
#define sprintf
Definition: port.h:240
userDoption
static const char * userDoption
Definition: postgres.c:165

References CONFIG_FILENAME, ConfigFileName, DataDir, FATAL, find_option(), free, guc_free(), guc_malloc(), HBA_FILENAME, HbaFileName, IDENT_FILENAME, IdentFileName, make_absolute_path(), PANIC, pg_timezone_abbrev_initialize(), PGC_POSTMASTER, PGC_S_OVERRIDE, ProcessConfigFile(), progname, SetConfigOption(), SetDataDir(), sprintf, stat, userDoption, config_string::variable, and write_stderr.

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

◆ SerializeGUCState()

void SerializeGUCState ( Size  maxsize,
char *  start_address 
)

Definition at line 6066 of file guc.c.

6067 {
6068  char *curptr;
6069  Size actual_size;
6070  Size bytes_left;
6071  dlist_iter iter;
6072 
6073  /* Reserve space for saving the actual size of the guc state */
6074  Assert(maxsize > sizeof(actual_size));
6075  curptr = start_address + sizeof(actual_size);
6076  bytes_left = maxsize - sizeof(actual_size);
6077 
6078  /* We need only consider GUCs with source not PGC_S_DEFAULT */
6079  dlist_foreach(iter, &guc_nondef_list)
6080  {
6081  struct config_generic *gconf = dlist_container(struct config_generic,
6082  nondef_link, iter.cur);
6083 
6084  serialize_variable(&curptr, &bytes_left, gconf);
6085  }
6086 
6087  /* Store actual size without assuming alignment of start_address. */
6088  actual_size = maxsize - bytes_left - sizeof(actual_size);
6089  memcpy(start_address, &actual_size, sizeof(actual_size));
6090 }
serialize_variable
static void serialize_variable(char **destptr, Size *maxbytes, struct config_generic *gconf)
Definition: guc.c:5989

References Assert, dlist_iter::cur, dlist_container, dlist_foreach, guc_nondef_list, config_generic::nondef_link, 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 3342 of file guc.c.

3346 {
3347  Oid srole;
3348 
3349  /*
3350  * Non-interactive sources should be treated as having all privileges,
3351  * except for PGC_S_CLIENT. Note in particular that this is true for
3352  * pg_db_role_setting sources (PGC_S_GLOBAL etc): we assume a suitable
3353  * privilege check was done when the pg_db_role_setting entry was made.
3354  */
3355  if (source >= PGC_S_INTERACTIVE || source == PGC_S_CLIENT)
3356  srole = GetUserId();
3357  else
3358  srole = BOOTSTRAP_SUPERUSERID;
3359 
3360  return set_config_with_handle(name, NULL, value,
3361  context, source, srole,
3362  action, changeVal, elevel,
3363  is_reload);
3364 }
set_config_with_handle
int set_config_with_handle(const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3405

References generate_unaccent_rules::action, context, GetUserId(), name, PGC_S_CLIENT, PGC_S_INTERACTIVE, set_config_with_handle(), source, and value.

Referenced by applyRemoteGucs(), CreateSchemaCommand(), DefineIndex(), ExecSetVariableStmt(), execute_extension_script(), parse_subscription_options(), ProcessConfigFileInternal(), ProcessGUCArray(), RestrictSearchPath(), RI_Initial_Check(), RI_PartitionRemove_Check(), set_config_by_name(), set_transmission_modes(), SetConfigOption(), SetPGVariable(), and validate_option_array_item().

◆ set_config_option_ext()

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

Definition at line 3382 of file guc.c.

3386 {
3387  return set_config_with_handle(name, NULL, value,
3388  context, source, srole,
3389  action, changeVal, elevel,
3390  is_reload);
3391 }

References generate_unaccent_rules::action, context, name, set_config_with_handle(), source, and value.

Referenced by define_custom_variable(), execute_extension_script(), InitializeWalConsistencyChecking(), reapply_stacked_values(), and RestoreGUCState().

◆ set_config_with_handle()

int set_config_with_handle ( const char *  name,
config_handle *  handle,
const char *  value,
GucContext  context,
GucSource  source,
Oid  srole,
GucAction  action,
bool  changeVal,
int  elevel,
bool  is_reload 
)

Definition at line 3405 of file guc.c.

3410 {
3411  struct config_generic *record;
3412  union config_var_val newval_union;
3413  void *newextra = NULL;
3414  bool prohibitValueChange = false;
3415  bool makeDefault;
3416 
3417  if (elevel == 0)
3418  {
3419  if (source == PGC_S_DEFAULT || source == PGC_S_FILE)
3420  {
3421  /*
3422  * To avoid cluttering the log, only the postmaster bleats loudly
3423  * about problems with the config file.
3424  */
3425  elevel = IsUnderPostmaster ? DEBUG3 : LOG;
3426  }
3427  else if (source == PGC_S_GLOBAL ||
3428  source == PGC_S_DATABASE ||
3429  source == PGC_S_USER ||
3430  source == PGC_S_DATABASE_USER)
3431  elevel = WARNING;
3432  else
3433  elevel = ERROR;
3434  }
3435 
3436  /* if handle is specified, no need to look up option */
3437  if (!handle)
3438  {
3439  record = find_option(name, true, false, elevel);
3440  if (record == NULL)
3441  return 0;
3442  }
3443  else
3444  record = handle;
3445 
3446  /*
3447  * GUC_ACTION_SAVE changes are acceptable during a parallel operation,
3448  * because the current worker will also pop the change. We're probably
3449  * dealing with a function having a proconfig entry. Only the function's
3450  * body should observe the change, and peer workers do not share in the
3451  * execution of a function call started by this worker.
3452  *
3453  * Also allow normal setting if the GUC is marked GUC_ALLOW_IN_PARALLEL.
3454  *
3455  * Other changes might need to affect other workers, so forbid them.
3456  */
3457  if (IsInParallelMode() && changeVal && action != GUC_ACTION_SAVE &&
3458  (record->flags & GUC_ALLOW_IN_PARALLEL) == 0)
3459  {
3460  ereport(elevel,
3461  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
3462  errmsg("parameter \"%s\" cannot be set during a parallel operation",
3463  name)));
3464  return 0;
3465  }
3466 
3467  /*
3468  * Check if the option can be set at this time. See guc.h for the precise
3469  * rules.
3470  */
3471  switch (record->context)
3472  {
3473  case PGC_INTERNAL:
3474  if (context != PGC_INTERNAL)
3475  {
3476  ereport(elevel,
3477  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3478  errmsg("parameter \"%s\" cannot be changed",
3479  name)));
3480  return 0;
3481  }
3482  break;
3483  case PGC_POSTMASTER:
3484  if (context == PGC_SIGHUP)
3485  {
3486  /*
3487  * We are re-reading a PGC_POSTMASTER variable from
3488  * postgresql.conf. We can't change the setting, so we should
3489  * give a warning if the DBA tries to change it. However,
3490  * because of variant formats, canonicalization by check
3491  * hooks, etc, we can't just compare the given string directly
3492  * to what's stored. Set a flag to check below after we have
3493  * the final storable value.
3494  */
3495  prohibitValueChange = true;
3496  }
3497  else if (context != PGC_POSTMASTER)
3498  {
3499  ereport(elevel,
3500  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3501  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3502  name)));
3503  return 0;
3504  }
3505  break;
3506  case PGC_SIGHUP:
3507  if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
3508  {
3509  ereport(elevel,
3510  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3511  errmsg("parameter \"%s\" cannot be changed now",
3512  name)));
3513  return 0;
3514  }
3515 
3516  /*
3517  * Hmm, the idea of the SIGHUP context is "ought to be global, but
3518  * can be changed after postmaster start". But there's nothing
3519  * that prevents a crafty administrator from sending SIGHUP
3520  * signals to individual backends only.
3521  */
3522  break;
3523  case PGC_SU_BACKEND:
3524  if (context == PGC_BACKEND)
3525  {
3526  /*
3527  * Check whether the requesting user has been granted
3528  * privilege to set this GUC.
3529  */
3530  AclResult aclresult;
3531 
3532  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3533  if (aclresult != ACLCHECK_OK)
3534  {
3535  /* No granted privilege */
3536  ereport(elevel,
3537  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3538  errmsg("permission denied to set parameter \"%s\"",
3539  name)));
3540  return 0;
3541  }
3542  }
3543  /* fall through to process the same as PGC_BACKEND */
3544  /* FALLTHROUGH */
3545  case PGC_BACKEND:
3546  if (context == PGC_SIGHUP)
3547  {
3548  /*
3549  * If a PGC_BACKEND or PGC_SU_BACKEND parameter is changed in
3550  * the config file, we want to accept the new value in the
3551  * postmaster (whence it will propagate to
3552  * subsequently-started backends), but ignore it in existing
3553  * backends. This is a tad klugy, but necessary because we
3554  * don't re-read the config file during backend start.
3555  *
3556  * However, if changeVal is false then plow ahead anyway since
3557  * we are trying to find out if the value is potentially good,
3558  * not actually use it.
3559  *
3560  * In EXEC_BACKEND builds, this works differently: we load all
3561  * non-default settings from the CONFIG_EXEC_PARAMS file
3562  * during backend start. In that case we must accept
3563  * PGC_SIGHUP settings, so as to have the same value as if
3564  * we'd forked from the postmaster. This can also happen when
3565  * using RestoreGUCState() within a background worker that
3566  * needs to have the same settings as the user backend that
3567  * started it. is_reload will be true when either situation
3568  * applies.
3569  */
3570  if (IsUnderPostmaster && changeVal && !is_reload)
3571  return -1;
3572  }
3573  else if (context != PGC_POSTMASTER &&
3574  context != PGC_BACKEND &&
3575  context != PGC_SU_BACKEND &&
3576  source != PGC_S_CLIENT)
3577  {
3578  ereport(elevel,
3579  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3580  errmsg("parameter \"%s\" cannot be set after connection start",
3581  name)));
3582  return 0;
3583  }
3584  break;
3585  case PGC_SUSET:
3586  if (context == PGC_USERSET || context == PGC_BACKEND)
3587  {
3588  /*
3589  * Check whether the requesting user has been granted
3590  * privilege to set this GUC.
3591  */
3592  AclResult aclresult;
3593 
3594  aclresult = pg_parameter_aclcheck(name, srole, ACL_SET);
3595  if (aclresult != ACLCHECK_OK)
3596  {
3597  /* No granted privilege */
3598  ereport(elevel,
3599  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3600  errmsg("permission denied to set parameter \"%s\"",
3601  name)));
3602  return 0;
3603  }
3604  }
3605  break;
3606  case PGC_USERSET:
3607  /* always okay */
3608  break;
3609  }
3610 
3611  /*
3612  * Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
3613  * security restriction context. We can reject this regardless of the GUC
3614  * context or source, mainly because sources that it might be reasonable
3615  * to override for won't be seen while inside a function.
3616  *
3617  * Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
3618  * GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
3619  * An exception might be made if the reset value is assumed to be "safe".
3620  *
3621  * Note: this flag is currently used for "session_authorization" and
3622  * "role". We need to prohibit changing these inside a local userid
3623  * context because when we exit it, GUC won't be notified, leaving things
3624  * out of sync. (This could be fixed by forcing a new GUC nesting level,
3625  * but that would change behavior in possibly-undesirable ways.) Also, we
3626  * prohibit changing these in a security-restricted operation because
3627  * otherwise RESET could be used to regain the session user's privileges.
3628  */
3629  if (record->flags & GUC_NOT_WHILE_SEC_REST)
3630  {
3631  if (InLocalUserIdChange())
3632  {
3633  /*
3634  * Phrasing of this error message is historical, but it's the most
3635  * common case.
3636  */
3637  ereport(elevel,
3638  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3639  errmsg("cannot set parameter \"%s\" within security-definer function",
3640  name)));
3641  return 0;
3642  }
3643  if (InSecurityRestrictedOperation())
3644  {
3645  ereport(elevel,
3646  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
3647  errmsg("cannot set parameter \"%s\" within security-restricted operation",
3648  name)));
3649  return 0;
3650  }
3651  }
3652 
3653  /* Disallow resetting and saving GUC_NO_RESET values */
3654  if (record->flags & GUC_NO_RESET)
3655  {
3656  if (value == NULL)
3657  {
3658  ereport(elevel,
3659  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3660  errmsg("parameter \"%s\" cannot be reset", name)));
3661  return 0;
3662  }
3663  if (action == GUC_ACTION_SAVE)
3664  {
3665  ereport(elevel,
3666  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3667  errmsg("parameter \"%s\" cannot be set locally in functions",
3668  name)));
3669  return 0;
3670  }
3671  }
3672 
3673  /*
3674  * Should we set reset/stacked values? (If so, the behavior is not
3675  * transactional.) This is done either when we get a default value from
3676  * the database's/user's/client's default settings or when we reset a
3677  * value to its default.
3678  */
3679  makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
3680  ((value != NULL) || source == PGC_S_DEFAULT);
3681 
3682  /*
3683  * Ignore attempted set if overridden by previously processed setting.
3684  * However, if changeVal is false then plow ahead anyway since we are
3685  * trying to find out if the value is potentially good, not actually use
3686  * it. Also keep going if makeDefault is true, since we may want to set
3687  * the reset/stacked values even if we can't set the variable itself.
3688  */
3689  if (record->source > source)
3690  {
3691  if (changeVal && !makeDefault)
3692  {
3693  elog(DEBUG3, "\"%s\": setting ignored because previous source is higher priority",
3694  name);
3695  return -1;
3696  }
3697  changeVal = false;
3698  }
3699 
3700  /*
3701  * Evaluate value and set variable.
3702  */
3703  switch (record->vartype)
3704  {
3705  case PGC_BOOL:
3706  {
3707  struct config_bool *conf = (struct config_bool *) record;
3708 
3709 #define newval (newval_union.boolval)
3710 
3711  if (value)
3712  {
3713  if (!parse_and_validate_value(record, name, value,
3714  source, elevel,
3715  &newval_union, &newextra))
3716  return 0;
3717  }
3718  else if (source == PGC_S_DEFAULT)
3719  {
3720  newval = conf->boot_val;
3721  if (!call_bool_check_hook(conf, &newval, &newextra,
3722  source, elevel))
3723  return 0;
3724  }
3725  else
3726  {
3727  newval = conf->reset_val;
3728  newextra = conf->reset_extra;
3729  source = conf->gen.reset_source;
3730  context = conf->gen.reset_scontext;
3731  srole = conf->gen.reset_srole;
3732  }
3733 
3734  if (prohibitValueChange)
3735  {
3736  /* Release newextra, unless it's reset_extra */
3737  if (newextra && !extra_field_used(&conf->gen, newextra))
3738  guc_free(newextra);
3739 
3740  if (*conf->variable != newval)
3741  {
3742  record->status |= GUC_PENDING_RESTART;
3743  ereport(elevel,
3744  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3745  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3746  name)));
3747  return 0;
3748  }
3749  record->status &= ~GUC_PENDING_RESTART;
3750  return -1;
3751  }
3752 
3753  if (changeVal)
3754  {
3755  /* Save old value to support transaction abort */
3756  if (!makeDefault)
3757  push_old_value(&conf->gen, action);
3758 
3759  if (conf->assign_hook)
3760  conf->assign_hook(newval, newextra);
3761  *conf->variable = newval;
3762  set_extra_field(&conf->gen, &conf->gen.extra,
3763  newextra);
3764  set_guc_source(&conf->gen, source);
3765  conf->gen.scontext = context;
3766  conf->gen.srole = srole;
3767  }
3768  if (makeDefault)
3769  {
3770  GucStack *stack;
3771 
3772  if (conf->gen.reset_source <= source)
3773  {
3774  conf->reset_val = newval;
3775  set_extra_field(&conf->gen, &conf->reset_extra,
3776  newextra);
3777  conf->gen.reset_source = source;
3778  conf->gen.reset_scontext = context;
3779  conf->gen.reset_srole = srole;
3780  }
3781  for (stack = conf->gen.stack; stack; stack = stack->prev)
3782  {
3783  if (stack->source <= source)
3784  {
3785  stack->prior.val.boolval = newval;
3786  set_extra_field(&conf->gen, &stack->prior.extra,
3787  newextra);
3788  stack->source = source;
3789  stack->scontext = context;
3790  stack->srole = srole;
3791  }
3792  }
3793  }
3794 
3795  /* Perhaps we didn't install newextra anywhere */
3796  if (newextra && !extra_field_used(&conf->gen, newextra))
3797  guc_free(newextra);
3798  break;
3799 
3800 #undef newval
3801  }
3802 
3803  case PGC_INT:
3804  {
3805  struct config_int *conf = (struct config_int *) record;
3806 
3807 #define newval (newval_union.intval)
3808 
3809  if (value)
3810  {
3811  if (!parse_and_validate_value(record, name, value,
3812  source, elevel,
3813  &newval_union, &newextra))
3814  return 0;
3815  }
3816  else if (source == PGC_S_DEFAULT)
3817  {
3818  newval = conf->boot_val;
3819  if (!call_int_check_hook(conf, &newval, &newextra,
3820  source, elevel))
3821  return 0;
3822  }
3823  else
3824  {
3825  newval = conf->reset_val;
3826  newextra = conf->reset_extra;
3827  source = conf->gen.reset_source;
3828  context = conf->gen.reset_scontext;
3829  srole = conf->gen.reset_srole;
3830  }
3831 
3832  if (prohibitValueChange)
3833  {
3834  /* Release newextra, unless it's reset_extra */
3835  if (newextra && !extra_field_used(&conf->gen, newextra))
3836  guc_free(newextra);
3837 
3838  if (*conf->variable != newval)
3839  {
3840  record->status |= GUC_PENDING_RESTART;
3841  ereport(elevel,
3842  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3843  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3844  name)));
3845  return 0;
3846  }
3847  record->status &= ~GUC_PENDING_RESTART;
3848  return -1;
3849  }
3850 
3851  if (changeVal)
3852  {
3853  /* Save old value to support transaction abort */
3854  if (!makeDefault)
3855  push_old_value(&conf->gen, action);
3856 
3857  if (conf->assign_hook)
3858  conf->assign_hook(newval, newextra);
3859  *conf->variable = newval;
3860  set_extra_field(&conf->gen, &conf->gen.extra,
3861  newextra);
3862  set_guc_source(&conf->gen, source);
3863  conf->gen.scontext = context;
3864  conf->gen.srole = srole;
3865  }
3866  if (makeDefault)
3867  {
3868  GucStack *stack;
3869 
3870  if (conf->gen.reset_source <= source)
3871  {
3872  conf->reset_val = newval;
3873  set_extra_field(&conf->gen, &conf->reset_extra,
3874  newextra);
3875  conf->gen.reset_source = source;
3876  conf->gen.reset_scontext = context;
3877  conf->gen.reset_srole = srole;
3878  }
3879  for (stack = conf->gen.stack; stack; stack = stack->prev)
3880  {
3881  if (stack->source <= source)
3882  {
3883  stack->prior.val.intval = newval;
3884  set_extra_field(&conf->gen, &stack->prior.extra,
3885  newextra);
3886  stack->source = source;
3887  stack->scontext = context;
3888  stack->srole = srole;
3889  }
3890  }
3891  }
3892 
3893  /* Perhaps we didn't install newextra anywhere */
3894  if (newextra && !extra_field_used(&conf->gen, newextra))
3895  guc_free(newextra);
3896  break;
3897 
3898 #undef newval
3899  }
3900 
3901  case PGC_REAL:
3902  {
3903  struct config_real *conf = (struct config_real *) record;
3904 
3905 #define newval (newval_union.realval)
3906 
3907  if (value)
3908  {
3909  if (!parse_and_validate_value(record, name, value,
3910  source, elevel,
3911  &newval_union, &newextra))
3912  return 0;
3913  }
3914  else if (source == PGC_S_DEFAULT)
3915  {
3916  newval = conf->boot_val;
3917  if (!call_real_check_hook(conf, &newval, &newextra,
3918  source, elevel))
3919  return 0;
3920  }
3921  else
3922  {
3923  newval = conf->reset_val;
3924  newextra = conf->reset_extra;
3925  source = conf->gen.reset_source;
3926  context = conf->gen.reset_scontext;
3927  srole = conf->gen.reset_srole;
3928  }
3929 
3930  if (prohibitValueChange)
3931  {
3932  /* Release newextra, unless it's reset_extra */
3933  if (newextra && !extra_field_used(&conf->gen, newextra))
3934  guc_free(newextra);
3935 
3936  if (*conf->variable != newval)
3937  {
3938  record->status |= GUC_PENDING_RESTART;
3939  ereport(elevel,
3940  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
3941  errmsg("parameter \"%s\" cannot be changed without restarting the server",
3942  name)));
3943  return 0;
3944  }
3945  record->status &= ~GUC_PENDING_RESTART;
3946  return -1;
3947  }
3948 
3949  if (changeVal)
3950  {
3951  /* Save old value to support transaction abort */
3952  if (!makeDefault)
3953  push_old_value(&conf->gen, action);
3954 
3955  if (conf->assign_hook)
3956  conf->assign_hook(newval, newextra);
3957  *conf->variable = newval;
3958  set_extra_field(&conf->gen, &conf->gen.extra,
3959  newextra);
3960  set_guc_source(&conf->gen, source);
3961  conf->gen.scontext = context;
3962  conf->gen.srole = srole;
3963  }
3964  if (makeDefault)
3965  {
3966  GucStack *stack;
3967 
3968  if (conf->gen.reset_source <= source)
3969  {
3970  conf->reset_val = newval;
3971  set_extra_field(&conf->gen, &conf->reset_extra,
3972  newextra);
3973  conf->gen.reset_source = source;
3974  conf->gen.reset_scontext = context;
3975  conf->gen.reset_srole = srole;
3976  }
3977  for (stack = conf->gen.stack; stack; stack = stack->prev)
3978  {
3979  if (stack->source <= source)
3980  {
3981  stack->prior.val.realval = newval;
3982  set_extra_field(&conf->gen, &stack->prior.extra,
3983  newextra);
3984  stack->source = source;
3985  stack->scontext = context;
3986  stack->srole = srole;
3987  }
3988  }
3989  }
3990 
3991  /* Perhaps we didn't install newextra anywhere */
3992  if (newextra && !extra_field_used(&conf->gen, newextra))
3993  guc_free(newextra);
3994  break;
3995 
3996 #undef newval
3997  }
3998 
3999  case PGC_STRING:
4000  {
4001  struct config_string *conf = (struct config_string *) record;
4002 
4003 #define newval (newval_union.stringval)
4004 
4005  if (value)
4006  {
4007  if (!parse_and_validate_value(record, name, value,
4008  source, elevel,
4009  &newval_union, &newextra))
4010  return 0;
4011  }
4012  else if (source == PGC_S_DEFAULT)
4013  {
4014  /* non-NULL boot_val must always get strdup'd */
4015  if (conf->boot_val != NULL)
4016  {
4017  newval = guc_strdup(elevel, conf->boot_val);
4018  if (newval == NULL)
4019  return 0;
4020  }
4021  else
4022  newval = NULL;
4023 
4024  if (!call_string_check_hook(conf, &newval, &newextra,
4025  source, elevel))
4026  {
4027  guc_free(newval);
4028  return 0;
4029  }
4030  }
4031  else
4032  {
4033  /*
4034  * strdup not needed, since reset_val is already under
4035  * guc.c's control
4036  */
4037  newval = conf->reset_val;
4038  newextra = conf->reset_extra;
4039  source = conf->gen.reset_source;
4040  context = conf->gen.reset_scontext;
4041  srole = conf->gen.reset_srole;
4042  }
4043 
4044  if (prohibitValueChange)
4045  {
4046  bool newval_different;
4047 
4048  /* newval shouldn't be NULL, so we're a bit sloppy here */
4049  newval_different = (*conf->variable == NULL ||
4050  newval == NULL ||
4051  strcmp(*conf->variable, newval) != 0);
4052 
4053  /* Release newval, unless it's reset_val */
4054  if (newval && !string_field_used(conf, newval))
4055  guc_free(newval);
4056  /* Release newextra, unless it's reset_extra */
4057  if (newextra && !extra_field_used(&conf->gen, newextra))
4058  guc_free(newextra);
4059 
4060  if (newval_different)
4061  {
4062  record->status |= GUC_PENDING_RESTART;
4063  ereport(elevel,
4064  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4065  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4066  name)));
4067  return 0;
4068  }
4069  record->status &= ~GUC_PENDING_RESTART;
4070  return -1;
4071  }
4072 
4073  if (changeVal)
4074  {
4075  /* Save old value to support transaction abort */
4076  if (!makeDefault)
4077  push_old_value(&conf->gen, action);
4078 
4079  if (conf->assign_hook)
4080  conf->assign_hook(newval, newextra);
4081  set_string_field(conf, conf->variable, newval);
4082  set_extra_field(&conf->gen, &conf->gen.extra,
4083  newextra);
4084  set_guc_source(&conf->gen, source);
4085  conf->gen.scontext = context;
4086  conf->gen.srole = srole;
4087  }
4088 
4089  if (makeDefault)
4090  {
4091  GucStack *stack;
4092 
4093  if (conf->gen.reset_source <= source)
4094  {
4095  set_string_field(conf, &conf->reset_val, newval);
4096  set_extra_field(&conf->gen, &conf->reset_extra,
4097  newextra);
4098  conf->gen.reset_source = source;
4099  conf->gen.reset_scontext = context;
4100  conf->gen.reset_srole = srole;
4101  }
4102  for (stack = conf->gen.stack; stack; stack = stack->prev)
4103  {
4104  if (stack->source <= source)
4105  {
4106  set_string_field(conf, &stack->prior.val.stringval,
4107  newval);
4108  set_extra_field(&conf->gen, &stack->prior.extra,
4109  newextra);
4110  stack->source = source;
4111  stack->scontext = context;
4112  stack->srole = srole;
4113  }
4114  }
4115  }
4116 
4117  /* Perhaps we didn't install newval anywhere */
4118  if (newval && !string_field_used(conf, newval))
4119  guc_free(newval);
4120  /* Perhaps we didn't install newextra anywhere */
4121  if (newextra && !extra_field_used(&conf->gen, newextra))
4122  guc_free(newextra);
4123  break;
4124 
4125 #undef newval
4126  }
4127 
4128  case PGC_ENUM:
4129  {
4130  struct config_enum *conf = (struct config_enum *) record;
4131 
4132 #define newval (newval_union.enumval)
4133 
4134  if (value)
4135  {
4136  if (!parse_and_validate_value(record, name, value,
4137  source, elevel,
4138  &newval_union, &newextra))
4139  return 0;
4140  }
4141  else if (source == PGC_S_DEFAULT)
4142  {
4143  newval = conf->boot_val;
4144  if (!call_enum_check_hook(conf, &newval, &newextra,
4145  source, elevel))
4146  return 0;
4147  }
4148  else
4149  {
4150  newval = conf->reset_val;
4151  newextra = conf->reset_extra;
4152  source = conf->gen.reset_source;
4153  context = conf->gen.reset_scontext;
4154  srole = conf->gen.reset_srole;
4155  }
4156 
4157  if (prohibitValueChange)
4158  {
4159  /* Release newextra, unless it's reset_extra */
4160  if (newextra && !extra_field_used(&conf->gen, newextra))
4161  guc_free(newextra);
4162 
4163  if (*conf->variable != newval)
4164  {
4165  record->status |= GUC_PENDING_RESTART;
4166  ereport(elevel,
4167  (errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
4168  errmsg("parameter \"%s\" cannot be changed without restarting the server",
4169  name)));
4170  return 0;
4171  }
4172  record->status &= ~GUC_PENDING_RESTART;
4173  return -1;
4174  }
4175 
4176  if (changeVal)
4177  {
4178  /* Save old value to support transaction abort */
4179  if (!makeDefault)
4180  push_old_value(&conf->gen, action);
4181 
4182  if (conf->assign_hook)
4183  conf->assign_hook(newval, newextra);
4184  *conf->variable = newval;
4185  set_extra_field(&conf->gen, &conf->gen.extra,
4186  newextra);
4187  set_guc_source(&conf->gen, source);
4188  conf->gen.scontext = context;
4189  conf->gen.srole = srole;
4190  }
4191  if (makeDefault)
4192  {
4193  GucStack *stack;
4194 
4195  if (conf->gen.reset_source <= source)
4196  {
4197  conf->reset_val = newval;
4198  set_extra_field(&conf->gen, &conf->reset_extra,
4199  newextra);
4200  conf->gen.reset_source = source;
4201  conf->gen.reset_scontext = context;
4202  conf->gen.reset_srole = srole;
4203  }
4204  for (stack = conf->gen.stack; stack; stack = stack->prev)
4205  {
4206  if (stack->source <= source)
4207  {
4208  stack->prior.val.enumval = newval;
4209  set_extra_field(&conf->gen, &stack->prior.extra,
4210  newextra);
4211  stack->source = source;
4212  stack->scontext = context;
4213  stack->srole = srole;
4214  }
4215  }
4216  }
4217 
4218  /* Perhaps we didn't install newextra anywhere */
4219  if (newextra && !extra_field_used(&conf->gen, newextra))
4220  guc_free(newextra);
4221  break;
4222 
4223 #undef newval
4224  }
4225  }
4226 
4227  if (changeVal && (record->flags & GUC_REPORT) &&
4228  !(record->status & GUC_NEEDS_REPORT))
4229  {
4230  record->status |= GUC_NEEDS_REPORT;
4231  slist_push_head(&guc_report_list, &record->report_link);
4232  }
4233 
4234  return changeVal ? 1 : -1;
4235 }
DEBUG3
#define DEBUG3
Definition: elog.h:28
IsUnderPostmaster
bool IsUnderPostmaster
Definition: globals.c:119
call_string_check_hook
static bool call_string_check_hook(struct config_string *conf, char **newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6865
extra_field_used
static bool extra_field_used(struct config_generic *gconf, void *extra)
Definition: guc.c:746
call_bool_check_hook
static void static bool call_bool_check_hook(struct config_bool *conf, bool *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6763
call_int_check_hook
static bool call_int_check_hook(struct config_int *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6797
guc_strdup
char * guc_strdup(int elevel, const char *src)
Definition: guc.c:676
string_field_used
static bool string_field_used(struct config_string *conf, char *strval)
Definition: guc.c:707
call_real_check_hook
static bool call_real_check_hook(struct config_real *conf, double *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6831
call_enum_check_hook
static bool call_enum_check_hook(struct config_enum *conf, int *newval, void **extra, GucSource source, int elevel)
Definition: guc.c:6915
GUC_NO_RESET
#define GUC_NO_RESET
Definition: guc.h:213
GUC_NOT_WHILE_SEC_REST
#define GUC_NOT_WHILE_SEC_REST
Definition: guc.h:222
GUC_ALLOW_IN_PARALLEL
#define GUC_ALLOW_IN_PARALLEL
Definition: guc.h:226
GUC_PENDING_RESTART
#define GUC_PENDING_RESTART
Definition: guc_tables.h:192
InSecurityRestrictedOperation
bool InSecurityRestrictedOperation(void)
Definition: miscinit.c:662
InLocalUserIdChange
bool InLocalUserIdChange(void)
Definition: miscinit.c:653
config_bool::boot_val
bool boot_val
Definition: guc_tables.h:203
config_enum::boot_val
int boot_val
Definition: guc_tables.h:273
config_int::boot_val
int boot_val
Definition: guc_tables.h:217
config_real::boot_val
double boot_val
Definition: guc_tables.h:233
config_string::boot_val
const char * boot_val
Definition: guc_tables.h:259

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(), context, 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, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, GUC_ACTION_SAVE, GUC_ALLOW_IN_PARALLEL, guc_free(), GUC_NEEDS_REPORT, GUC_NO_RESET, GUC_NOT_WHILE_SEC_REST, GUC_PENDING_RESTART, GUC_REPORT, guc_report_list, 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, config_generic::report_link, 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_generic::reset_srole, config_bool::reset_val, config_int::reset_val, config_real::reset_val, config_string::reset_val, config_enum::reset_val, guc_stack::scontext, config_generic::scontext, set_extra_field(), set_guc_source(), set_string_field(), slist_push_head(), source, guc_stack::source, config_generic::source, guc_stack::srole, config_generic::srole, config_generic::stack, config_generic::status, string_field_used(), config_var_val::stringval, config_var_value::val, value, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, config_generic::vartype, and WARNING.

Referenced by fmgr_security_definer(), set_config_option(), and set_config_option_ext().

◆ SetConfigOption()

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

Definition at line 4291 of file guc.c.

4293 {
4294  (void) set_config_option(name, value, context, source,
4295  GUC_ACTION_SET, true, 0, false);
4296 }

References context, GUC_ACTION_SET, name, set_config_option(), source, and value.

Referenced by AutoVacWorkerMain(), BeginReportingGUCOptions(), BootstrapModeMain(), CheckMyDatabase(), CLOGShmemInit(), CommitTsShmemInit(), CreateAnonymousSegment(), InitializeGUCOptions(), InitializeGUCOptionsFromEnvironment(), InitializeLogRepWorker(), InitializeSessionUserId(), InitializeSessionUserIdStandalone(), InitializeShmemGUCs(), maybe_reread_subscription(), pg_timezone_abbrev_initialize(), PGSharedMemoryCreate(), PostmasterMain(), process_postgres_switches(), process_startup_options(), ProcessConfigFileInternal(), ReadControlFile(), ReplSlotSyncWorkerMain(), ReportChangedGUCOptions(), SelectConfigFiles(), set_debug_options(), set_limit(), set_plan_disabling_options(), SetCurrentRoleId(), SetSessionAuthorization(), SUBTRANSShmemInit(), worker_spi_main(), and XLOGShmemSize().

◆ SetPGVariable()

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

Definition at line 315 of file guc_funcs.c.

316 {
317  char *argstring = flatten_set_variable_args(name, args);
318 
319  /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
320  (void) set_config_option(name,
321  argstring,
322  (superuser() ? PGC_SUSET : PGC_USERSET),
323  PGC_S_SESSION,
324  is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
325  true, 0, false);
326 }
generate_unaccent_rules.args
args
Definition: generate_unaccent_rules.py:288

References generate_unaccent_rules::args, flatten_set_variable_args(), GUC_ACTION_LOCAL, GUC_ACTION_SET, name, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, set_config_option(), and superuser().

Referenced by DiscardAll(), ExecSetVariableStmt(), and standard_ProcessUtility().

◆ TransformGUCArray()

void TransformGUCArray ( ArrayType *  array,
List **  names,
List **  values 
)

Definition at line 6364 of file guc.c.

6365 {
6366  int i;
6367 
6368  Assert(array != NULL);
6369  Assert(ARR_ELEMTYPE(array) == TEXTOID);
6370  Assert(ARR_NDIM(array) == 1);
6371  Assert(ARR_LBOUND(array)[0] == 1);
6372 
6373  *names = NIL;
6374  *values = NIL;
6375  for (i = 1; i <= ARR_DIMS(array)[0]; i++)
6376  {
6377  Datum d;
6378  bool isnull;
6379  char *s;
6380  char *name;
6381  char *value;
6382 
6383  d = array_ref(array, 1, &i,
6384  -1 /* varlenarray */ ,
6385  -1 /* TEXT's typlen */ ,
6386  false /* TEXT's typbyval */ ,
6387  TYPALIGN_INT /* TEXT's typalign */ ,
6388  &isnull);
6389 
6390  if (isnull)
6391  continue;
6392 
6393  s = TextDatumGetCString(d);
6394 
6395  ParseLongOption(s, &name, &value);
6396  if (!value)
6397  {
6398  ereport(WARNING,
6399  (errcode(ERRCODE_SYNTAX_ERROR),
6400  errmsg("could not parse setting for parameter \"%s\"",
6401  name)));
6402  pfree(name);
6403  continue;
6404  }
6405 
6406  *names = lappend(*names, name);
6407  *values = lappend(*values, value);
6408 
6409  pfree(s);
6410  }
6411 }
values
static Datum values[MAXATTR]
Definition: bootstrap.c:150
ParseLongOption
void ParseLongOption(const char *string, char **name, char **value)
Definition: guc.c:6327
NIL
#define NIL
Definition: pg_list.h:68

References ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_ref(), Assert, ereport, errcode(), errmsg(), i, lappend(), name, NIL, ParseLongOption(), pfree(), TextDatumGetCString, value, values, and WARNING.

Referenced by fmgr_security_definer(), and ProcessGUCArray().

Variable Documentation

◆ AllowAlterSystem

PGDLLIMPORT bool AllowAlterSystem
extern

Definition at line 489 of file guc_tables.c.

Referenced by AlterSystemSetConfigFile().

◆ application_name

PGDLLIMPORT char* application_name
extern

Definition at line 543 of file guc_tables.c.

Referenced by log_status_format(), pgstat_bestart(), process_pgfdw_appname(), SyncRepGetStandbyPriority(), SyncRepInitConfig(), SyncRepReleaseWaiters(), WalSndLoop(), write_csvlog(), and write_jsonlog().

◆ archive_mode_options

PGDLLIMPORT const struct config_enum_entry archive_mode_options[]
extern

Definition at line 165 of file xlog.c.

◆ backtrace_functions

PGDLLIMPORT char* backtrace_functions
extern

Definition at line 531 of file guc_tables.c.

Referenced by errfinish().

◆ check_function_bodies

PGDLLIMPORT bool check_function_bodies
extern

Definition at line 511 of file guc_tables.c.

Referenced by execute_extension_script(), fmgr_sql_validator(), plperl_validator(), plpgsql_compile_inline(), plpgsql_validator(), plpython3_validator(), and ProcedureCreate().

◆ client_min_messages

PGDLLIMPORT int client_min_messages
extern

Definition at line 523 of file guc_tables.c.

Referenced by execute_extension_script(), and should_output_to_client().

◆ cluster_name

PGDLLIMPORT char* cluster_name
extern

Definition at line 537 of file guc_tables.c.

Referenced by init_ps_display(), pg_sync_replication_slots(), process_pgfdw_appname(), ReplSlotSyncWorkerMain(), and WalReceiverMain().

◆ ConfigFileName

PGDLLIMPORT char* ConfigFileName
extern

Definition at line 538 of file guc_tables.c.

Referenced by ProcessConfigFileInternal(), and SelectConfigFiles().

◆ current_role_is_superuser

PGDLLIMPORT bool current_role_is_superuser
extern

Definition at line 519 of file guc_tables.c.

Referenced by InitializeParallelDSM().

◆ Debug_pretty_print

PGDLLIMPORT bool Debug_pretty_print
extern

Definition at line 494 of file guc_tables.c.

Referenced by pg_plan_query(), and pg_rewrite_query().

◆ Debug_print_parse

PGDLLIMPORT bool Debug_print_parse
extern

Definition at line 492 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ Debug_print_plan

PGDLLIMPORT bool Debug_print_plan
extern

Definition at line 491 of file guc_tables.c.

Referenced by pg_plan_query().

◆ Debug_print_rewritten

PGDLLIMPORT bool Debug_print_rewritten
extern

Definition at line 493 of file guc_tables.c.

Referenced by pg_rewrite_query().

◆ dynamic_shared_memory_options

PGDLLIMPORT const struct config_enum_entry dynamic_shared_memory_options[]
extern

Definition at line 93 of file dsm_impl.c.

◆ event_source

PGDLLIMPORT char* event_source
extern

Definition at line 508 of file guc_tables.c.

◆ external_pid_file

PGDLLIMPORT char* external_pid_file
extern

Definition at line 541 of file guc_tables.c.

Referenced by PostmasterMain(), and unlink_external_pid_file().

◆ GUC_check_errdetail_string

PGDLLIMPORT char* GUC_check_errdetail_string
extern

Definition at line 82 of file guc.c.

Referenced by call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), and call_string_check_hook().

◆ GUC_check_errhint_string

PGDLLIMPORT char* GUC_check_errhint_string
extern

Definition at line 83 of file guc.c.

Referenced by call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), and call_string_check_hook().

◆ GUC_check_errmsg_string

PGDLLIMPORT char* GUC_check_errmsg_string
extern

Definition at line 81 of file guc.c.

Referenced by call_bool_check_hook(), call_enum_check_hook(), call_int_check_hook(), call_real_check_hook(), and call_string_check_hook().

◆ HbaFileName

PGDLLIMPORT char* HbaFileName
extern

Definition at line 539 of file guc_tables.c.

Referenced by fill_hba_view(), load_hba(), PerformAuthentication(), PostmasterMain(), process_pm_reload_request(), and SelectConfigFiles().

◆ IdentFileName

PGDLLIMPORT char* IdentFileName
extern

Definition at line 540 of file guc_tables.c.

Referenced by fill_ident_view(), load_ident(), process_pm_reload_request(), and SelectConfigFiles().

◆ in_hot_standby_guc

PGDLLIMPORT bool in_hot_standby_guc
extern

Definition at line 622 of file guc_tables.c.

Referenced by ReportChangedGUCOptions().

◆ log_btree_build_stats

PGDLLIMPORT bool log_btree_build_stats
extern

Definition at line 507 of file guc_tables.c.

Referenced by _bt_leader_participate_as_worker(), _bt_leafbuild(), _bt_parallel_build_main(), and btbuild().

◆ log_duration

PGDLLIMPORT bool log_duration
extern

Definition at line 490 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_executor_stats

PGDLLIMPORT bool log_executor_stats
extern

Definition at line 504 of file guc_tables.c.

Referenced by check_log_stats(), PortalRun(), and PortalRunMulti().

◆ log_min_duration_sample

PGDLLIMPORT int log_min_duration_sample
extern

Definition at line 524 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_duration_statement

PGDLLIMPORT int log_min_duration_statement
extern

Definition at line 525 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_min_error_statement

PGDLLIMPORT int log_min_error_statement
extern

Definition at line 521 of file guc_tables.c.

Referenced by check_log_of_query().

◆ log_min_messages

PGDLLIMPORT int log_min_messages
extern

Definition at line 522 of file guc_tables.c.

Referenced by execute_extension_script(), and should_output_to_server().

◆ log_parameter_max_length

PGDLLIMPORT int log_parameter_max_length
extern

Definition at line 526 of file guc_tables.c.

Referenced by errdetail_params().

◆ log_parameter_max_length_on_error

PGDLLIMPORT int log_parameter_max_length_on_error
extern

Definition at line 527 of file guc_tables.c.

Referenced by bind_param_error_callback(), and exec_bind_message().

◆ log_parser_stats

PGDLLIMPORT bool log_parser_stats
extern

Definition at line 502 of file guc_tables.c.

Referenced by check_log_stats(), pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_varparams(), pg_analyze_and_rewrite_withcb(), pg_parse_query(), and pg_rewrite_query().

◆ log_planner_stats

PGDLLIMPORT bool log_planner_stats
extern

Definition at line 503 of file guc_tables.c.

Referenced by check_log_stats(), and pg_plan_query().

◆ log_statement_sample_rate

PGDLLIMPORT double log_statement_sample_rate
extern

Definition at line 529 of file guc_tables.c.

Referenced by check_log_duration().

◆ log_statement_stats

PGDLLIMPORT bool log_statement_stats
extern

Definition at line 505 of file guc_tables.c.

Referenced by check_stage_log_stats(), exec_bind_message(), exec_execute_message(), exec_parse_message(), and exec_simple_query().

◆ log_temp_files

PGDLLIMPORT int log_temp_files
extern

Definition at line 528 of file guc_tables.c.

Referenced by ReportTemporaryFileUsage().

◆ log_xact_sample_rate

PGDLLIMPORT double log_xact_sample_rate
extern

Definition at line 530 of file guc_tables.c.

Referenced by StartTransaction().

◆ num_temp_buffers

PGDLLIMPORT int num_temp_buffers
extern

Definition at line 535 of file guc_tables.c.

Referenced by InitLocalBuffers(), and LimitAdditionalLocalPins().

◆ recovery_target_action_options

PGDLLIMPORT const struct config_enum_entry recovery_target_action_options[]
extern

Definition at line 1 of file xlogrecovery.c.

◆ role_string

PGDLLIMPORT char* role_string
extern

Definition at line 619 of file guc_tables.c.

Referenced by show_role().

◆ tcp_keepalives_count

PGDLLIMPORT int tcp_keepalives_count
extern

Definition at line 547 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_keepalives_idle

PGDLLIMPORT int tcp_keepalives_idle
extern

Definition at line 545 of file guc_tables.c.

Referenced by pq_init().

◆ tcp_keepalives_interval

PGDLLIMPORT int tcp_keepalives_interval