guc.c

Go to the documentation of this file.

/*--------------------------------------------------------------------
 * guc.c
 *
 * Support for grand unified configuration scheme, including SET
 * command, configuration file, and command line options.
 * See src/backend/utils/misc/README for more information.
 *
 *
 * Copyright (c) 2000-2022, PostgreSQL Global Development Group
 * Written by Peter Eisentraut <peter_e@gmx.net>.
 *
 * IDENTIFICATION
 *    src/backend/utils/misc/guc.c
 *
 *--------------------------------------------------------------------
 */
#include "postgres.h"
 
#include <ctype.h>
#include <float.h>
#include <math.h>
#include <limits.h>
#ifdef HAVE_POLL_H
#include <poll.h>
#endif
#ifndef WIN32
#include <sys/mman.h>
#endif
#include <sys/stat.h>
#ifdef HAVE_SYSLOG
#include <syslog.h>
#endif
#include <unistd.h>
 
#include "access/commit_ts.h"
#include "access/gin.h"
#include "access/rmgr.h"
#include "access/tableam.h"
#include "access/toast_compression.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog_internal.h"
#include "access/xlogprefetcher.h"
#include "access/xlogrecovery.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_parameter_acl.h"
#include "catalog/storage.h"
#include "commands/async.h"
#include "commands/prepare.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "commands/user.h"
#include "commands/vacuum.h"
#include "commands/variable.h"
#include "common/string.h"
#include "funcapi.h"
#include "jit/jit.h"
#include "libpq/auth.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "optimizer/cost.h"
#include "optimizer/geqo.h"
#include "optimizer/optimizer.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
#include "parser/parse_expr.h"
#include "parser/parse_type.h"
#include "parser/parser.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/bgwriter.h"
#include "postmaster/postmaster.h"
#include "postmaster/startup.h"
#include "postmaster/syslogger.h"
#include "postmaster/walwriter.h"
#include "replication/logicallauncher.h"
#include "replication/reorderbuffer.h"
#include "replication/slot.h"
#include "replication/syncrep.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/dsm_impl.h"
#include "storage/fd.h"
#include "storage/large_object.h"
#include "storage/pg_shmem.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/standby.h"
#include "tcop/tcopprot.h"
#include "tsearch/ts_cache.h"
#include "utils/acl.h"
#include "utils/backend_status.h"
#include "utils/builtins.h"
#include "utils/bytea.h"
#include "utils/float.h"
#include "utils/guc_tables.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/pg_lsn.h"
#include "utils/plancache.h"
#include "utils/portal.h"
#include "utils/ps_status.h"
#include "utils/queryjumble.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"
#include "utils/tzparser.h"
#include "utils/inval.h"
#include "utils/varlena.h"
#include "utils/xml.h"
 
#ifndef PG_KRB_SRVTAB
#define PG_KRB_SRVTAB ""
#endif
 
#define CONFIG_FILENAME "postgresql.conf"
#define HBA_FILENAME    "pg_hba.conf"
#define IDENT_FILENAME  "pg_ident.conf"
 
#ifdef EXEC_BACKEND
#define CONFIG_EXEC_PARAMS "global/config_exec_params"
#define CONFIG_EXEC_PARAMS_NEW "global/config_exec_params.new"
#endif
 
/*
 * Precision with which REAL type guc values are to be printed for GUC
 * serialization.
 */
#define REALTYPE_PRECISION 17
 
/* XXX these should appear in other modules' header files */
extern bool Log_disconnections;
extern int  CommitDelay;
extern int  CommitSiblings;
extern char *default_tablespace;
extern char *temp_tablespaces;
extern bool ignore_checksum_failure;
extern bool ignore_invalid_pages;
extern bool synchronize_seqscans;
 
#ifdef TRACE_SYNCSCAN
extern bool trace_syncscan;
#endif
#ifdef DEBUG_BOUNDED_SORT
extern bool optimize_bounded_sort;
#endif
 
static int  GUC_check_errcode_value;
 
static List *reserved_class_prefix = NIL;
 
/* global variables for check hook support */
char       *GUC_check_errmsg_string;
char       *GUC_check_errdetail_string;
char       *GUC_check_errhint_string;
 
static void do_serialize(char **destptr, Size *maxbytes, const char *fmt,...) pg_attribute_printf(3, 4);
 
static void set_config_sourcefile(const char *name, char *sourcefile,
                                  int sourceline);
static bool call_bool_check_hook(struct config_bool *conf, bool *newval,
                                 void **extra, GucSource source, int elevel);
static bool call_int_check_hook(struct config_int *conf, int *newval,
                                void **extra, GucSource source, int elevel);
static bool call_real_check_hook(struct config_real *conf, double *newval,
                                 void **extra, GucSource source, int elevel);
static bool call_string_check_hook(struct config_string *conf, char **newval,
                                   void **extra, GucSource source, int elevel);
static bool call_enum_check_hook(struct config_enum *conf, int *newval,
                                 void **extra, GucSource source, int elevel);
 
static bool check_log_destination(char **newval, void **extra, GucSource source);
static void assign_log_destination(const char *newval, void *extra);
 
static bool check_wal_consistency_checking(char **newval, void **extra,
                                           GucSource source);
static void assign_wal_consistency_checking(const char *newval, void *extra);
 
#ifdef HAVE_SYSLOG
static int  syslog_facility = LOG_LOCAL0;
#else
static int  syslog_facility = 0;
#endif
 
static void assign_syslog_facility(int newval, void *extra);
static void assign_syslog_ident(const char *newval, void *extra);
static void assign_session_replication_role(int newval, void *extra);
static bool check_temp_buffers(int *newval, void **extra, GucSource source);
static bool check_bonjour(bool *newval, void **extra, GucSource source);
static bool check_ssl(bool *newval, void **extra, GucSource source);
static bool check_stage_log_stats(bool *newval, void **extra, GucSource source);
static bool check_log_stats(bool *newval, void **extra, GucSource source);
static bool check_canonical_path(char **newval, void **extra, GucSource source);
static bool check_timezone_abbreviations(char **newval, void **extra, GucSource source);
static void assign_timezone_abbreviations(const char *newval, void *extra);
static void pg_timezone_abbrev_initialize(void);
static const char *show_archive_command(void);
static void assign_tcp_keepalives_idle(int newval, void *extra);
static void assign_tcp_keepalives_interval(int newval, void *extra);
static void assign_tcp_keepalives_count(int newval, void *extra);
static void assign_tcp_user_timeout(int newval, void *extra);
static const char *show_tcp_keepalives_idle(void);
static const char *show_tcp_keepalives_interval(void);
static const char *show_tcp_keepalives_count(void);
static const char *show_tcp_user_timeout(void);
static bool check_maxconnections(int *newval, void **extra, GucSource source);
static bool check_max_worker_processes(int *newval, void **extra, GucSource source);
static bool check_autovacuum_max_workers(int *newval, void **extra, GucSource source);
static bool check_max_wal_senders(int *newval, void **extra, GucSource source);
static bool check_autovacuum_work_mem(int *newval, void **extra, GucSource source);
static bool check_effective_io_concurrency(int *newval, void **extra, GucSource source);
static bool check_maintenance_io_concurrency(int *newval, void **extra, GucSource source);
static bool check_huge_page_size(int *newval, void **extra, GucSource source);
static bool check_client_connection_check_interval(int *newval, void **extra, GucSource source);
static void assign_maintenance_io_concurrency(int newval, void *extra);
static bool check_application_name(char **newval, void **extra, GucSource source);
static void assign_application_name(const char *newval, void *extra);
static bool check_cluster_name(char **newval, void **extra, GucSource source);
static const char *show_unix_socket_permissions(void);
static const char *show_log_file_mode(void);
static const char *show_data_directory_mode(void);
static const char *show_in_hot_standby(void);
static bool check_backtrace_functions(char **newval, void **extra, GucSource source);
static void assign_backtrace_functions(const char *newval, void *extra);
static bool check_recovery_target_timeline(char **newval, void **extra, GucSource source);
static void assign_recovery_target_timeline(const char *newval, void *extra);
static bool check_recovery_target(char **newval, void **extra, GucSource source);
static void assign_recovery_target(const char *newval, void *extra);
static bool check_recovery_target_xid(char **newval, void **extra, GucSource source);
static void assign_recovery_target_xid(const char *newval, void *extra);
static bool check_recovery_target_time(char **newval, void **extra, GucSource source);
static void assign_recovery_target_time(const char *newval, void *extra);
static bool check_recovery_target_name(char **newval, void **extra, GucSource source);
static void assign_recovery_target_name(const char *newval, void *extra);
static bool check_recovery_target_lsn(char **newval, void **extra, GucSource source);
static void assign_recovery_target_lsn(const char *newval, void *extra);
static bool check_primary_slot_name(char **newval, void **extra, GucSource source);
static bool check_default_with_oids(bool *newval, void **extra, GucSource source);
 
/* Private functions in guc-file.l that need to be called from guc.c */
static ConfigVariable *ProcessConfigFileInternal(GucContext context,
                                                 bool applySettings, int elevel);
 
/*
 * Track whether there were any deferred checks for custom resource managers
 * specified in wal_consistency_checking.
 */
static bool check_wal_consistency_checking_deferred = false;
 
/*
 * Options for enum values defined in this module.
 *
 * NOTE! Option values may not contain double quotes!
 */
 
static const struct config_enum_entry bytea_output_options[] = {
    {"escape", BYTEA_OUTPUT_ESCAPE, false},
    {"hex", BYTEA_OUTPUT_HEX, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(bytea_output_options) == (BYTEA_OUTPUT_HEX + 2),
                 "array length mismatch");
 
/*
 * We have different sets for client and server message level options because
 * they sort slightly different (see "log" level), and because "fatal"/"panic"
 * aren't sensible for client_min_messages.
 */
static const struct config_enum_entry client_message_level_options[] = {
    {"debug5", DEBUG5, false},
    {"debug4", DEBUG4, false},
    {"debug3", DEBUG3, false},
    {"debug2", DEBUG2, false},
    {"debug1", DEBUG1, false},
    {"debug", DEBUG2, true},
    {"log", LOG, false},
    {"info", INFO, true},
    {"notice", NOTICE, false},
    {"warning", WARNING, false},
    {"error", ERROR, false},
    {NULL, 0, false}
};
 
static const struct config_enum_entry server_message_level_options[] = {
    {"debug5", DEBUG5, false},
    {"debug4", DEBUG4, false},
    {"debug3", DEBUG3, false},
    {"debug2", DEBUG2, false},
    {"debug1", DEBUG1, false},
    {"debug", DEBUG2, true},
    {"info", INFO, false},
    {"notice", NOTICE, false},
    {"warning", WARNING, false},
    {"error", ERROR, false},
    {"log", LOG, false},
    {"fatal", FATAL, false},
    {"panic", PANIC, false},
    {NULL, 0, false}
};
 
static const struct config_enum_entry intervalstyle_options[] = {
    {"postgres", INTSTYLE_POSTGRES, false},
    {"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
    {"sql_standard", INTSTYLE_SQL_STANDARD, false},
    {"iso_8601", INTSTYLE_ISO_8601, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(intervalstyle_options) == (INTSTYLE_ISO_8601 + 2),
                 "array length mismatch");
 
static const struct config_enum_entry log_error_verbosity_options[] = {
    {"terse", PGERROR_TERSE, false},
    {"default", PGERROR_DEFAULT, false},
    {"verbose", PGERROR_VERBOSE, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
                 "array length mismatch");
 
static const struct config_enum_entry log_statement_options[] = {
    {"none", LOGSTMT_NONE, false},
    {"ddl", LOGSTMT_DDL, false},
    {"mod", LOGSTMT_MOD, false},
    {"all", LOGSTMT_ALL, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(log_statement_options) == (LOGSTMT_ALL + 2),
                 "array length mismatch");
 
static const struct config_enum_entry isolation_level_options[] = {
    {"serializable", XACT_SERIALIZABLE, false},
    {"repeatable read", XACT_REPEATABLE_READ, false},
    {"read committed", XACT_READ_COMMITTED, false},
    {"read uncommitted", XACT_READ_UNCOMMITTED, false},
    {NULL, 0}
};
 
static const struct config_enum_entry session_replication_role_options[] = {
    {"origin", SESSION_REPLICATION_ROLE_ORIGIN, false},
    {"replica", SESSION_REPLICATION_ROLE_REPLICA, false},
    {"local", SESSION_REPLICATION_ROLE_LOCAL, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(session_replication_role_options) == (SESSION_REPLICATION_ROLE_LOCAL + 2),
                 "array length mismatch");
 
static const struct config_enum_entry syslog_facility_options[] = {
#ifdef HAVE_SYSLOG
    {"local0", LOG_LOCAL0, false},
    {"local1", LOG_LOCAL1, false},
    {"local2", LOG_LOCAL2, false},
    {"local3", LOG_LOCAL3, false},
    {"local4", LOG_LOCAL4, false},
    {"local5", LOG_LOCAL5, false},
    {"local6", LOG_LOCAL6, false},
    {"local7", LOG_LOCAL7, false},
#else
    {"none", 0, false},
#endif
    {NULL, 0}
};
 
static const struct config_enum_entry track_function_options[] = {
    {"none", TRACK_FUNC_OFF, false},
    {"pl", TRACK_FUNC_PL, false},
    {"all", TRACK_FUNC_ALL, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(track_function_options) == (TRACK_FUNC_ALL + 2),
                 "array length mismatch");
 
static const struct config_enum_entry stats_fetch_consistency[] = {
    {"none", PGSTAT_FETCH_CONSISTENCY_NONE, false},
    {"cache", PGSTAT_FETCH_CONSISTENCY_CACHE, false},
    {"snapshot", PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(stats_fetch_consistency) == (PGSTAT_FETCH_CONSISTENCY_SNAPSHOT + 2),
                 "array length mismatch");
 
static const struct config_enum_entry xmlbinary_options[] = {
    {"base64", XMLBINARY_BASE64, false},
    {"hex", XMLBINARY_HEX, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(xmlbinary_options) == (XMLBINARY_HEX + 2),
                 "array length mismatch");
 
static const struct config_enum_entry xmloption_options[] = {
    {"content", XMLOPTION_CONTENT, false},
    {"document", XMLOPTION_DOCUMENT, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(xmloption_options) == (XMLOPTION_CONTENT + 2),
                 "array length mismatch");
 
/*
 * Although only "on", "off", and "safe_encoding" are documented, we
 * accept all the likely variants of "on" and "off".
 */
static const struct config_enum_entry backslash_quote_options[] = {
    {"safe_encoding", BACKSLASH_QUOTE_SAFE_ENCODING, false},
    {"on", BACKSLASH_QUOTE_ON, false},
    {"off", BACKSLASH_QUOTE_OFF, false},
    {"true", BACKSLASH_QUOTE_ON, true},
    {"false", BACKSLASH_QUOTE_OFF, true},
    {"yes", BACKSLASH_QUOTE_ON, true},
    {"no", BACKSLASH_QUOTE_OFF, true},
    {"1", BACKSLASH_QUOTE_ON, true},
    {"0", BACKSLASH_QUOTE_OFF, true},
    {NULL, 0, false}
};
 
/*
 * Although only "on", "off", and "auto" are documented, we accept
 * all the likely variants of "on" and "off".
 */
static const struct config_enum_entry compute_query_id_options[] = {
    {"auto", COMPUTE_QUERY_ID_AUTO, false},
    {"regress", COMPUTE_QUERY_ID_REGRESS, false},
    {"on", COMPUTE_QUERY_ID_ON, false},
    {"off", COMPUTE_QUERY_ID_OFF, false},
    {"true", COMPUTE_QUERY_ID_ON, true},
    {"false", COMPUTE_QUERY_ID_OFF, true},
    {"yes", COMPUTE_QUERY_ID_ON, true},
    {"no", COMPUTE_QUERY_ID_OFF, true},
    {"1", COMPUTE_QUERY_ID_ON, true},
    {"0", COMPUTE_QUERY_ID_OFF, true},
    {NULL, 0, false}
};
 
/*
 * Although only "on", "off", and "partition" are documented, we
 * accept all the likely variants of "on" and "off".
 */
static const struct config_enum_entry constraint_exclusion_options[] = {
    {"partition", CONSTRAINT_EXCLUSION_PARTITION, false},
    {"on", CONSTRAINT_EXCLUSION_ON, false},
    {"off", CONSTRAINT_EXCLUSION_OFF, false},
    {"true", CONSTRAINT_EXCLUSION_ON, true},
    {"false", CONSTRAINT_EXCLUSION_OFF, true},
    {"yes", CONSTRAINT_EXCLUSION_ON, true},
    {"no", CONSTRAINT_EXCLUSION_OFF, true},
    {"1", CONSTRAINT_EXCLUSION_ON, true},
    {"0", CONSTRAINT_EXCLUSION_OFF, true},
    {NULL, 0, false}
};
 
/*
 * Although only "on", "off", "remote_apply", "remote_write", and "local" are
 * documented, we accept all the likely variants of "on" and "off".
 */
static const struct config_enum_entry synchronous_commit_options[] = {
    {"local", SYNCHRONOUS_COMMIT_LOCAL_FLUSH, false},
    {"remote_write", SYNCHRONOUS_COMMIT_REMOTE_WRITE, false},
    {"remote_apply", SYNCHRONOUS_COMMIT_REMOTE_APPLY, false},
    {"on", SYNCHRONOUS_COMMIT_ON, false},
    {"off", SYNCHRONOUS_COMMIT_OFF, false},
    {"true", SYNCHRONOUS_COMMIT_ON, true},
    {"false", SYNCHRONOUS_COMMIT_OFF, true},
    {"yes", SYNCHRONOUS_COMMIT_ON, true},
    {"no", SYNCHRONOUS_COMMIT_OFF, true},
    {"1", SYNCHRONOUS_COMMIT_ON, true},
    {"0", SYNCHRONOUS_COMMIT_OFF, true},
    {NULL, 0, false}
};
 
/*
 * Although only "on", "off", "try" are documented, we accept all the likely
 * variants of "on" and "off".
 */
static const struct config_enum_entry huge_pages_options[] = {
    {"off", HUGE_PAGES_OFF, false},
    {"on", HUGE_PAGES_ON, false},
    {"try", HUGE_PAGES_TRY, false},
    {"true", HUGE_PAGES_ON, true},
    {"false", HUGE_PAGES_OFF, true},
    {"yes", HUGE_PAGES_ON, true},
    {"no", HUGE_PAGES_OFF, true},
    {"1", HUGE_PAGES_ON, true},
    {"0", HUGE_PAGES_OFF, true},
    {NULL, 0, false}
};
 
static const struct config_enum_entry recovery_prefetch_options[] = {
    {"off", RECOVERY_PREFETCH_OFF, false},
    {"on", RECOVERY_PREFETCH_ON, false},
    {"try", RECOVERY_PREFETCH_TRY, false},
    {"true", RECOVERY_PREFETCH_ON, true},
    {"false", RECOVERY_PREFETCH_OFF, true},
    {"yes", RECOVERY_PREFETCH_ON, true},
    {"no", RECOVERY_PREFETCH_OFF, true},
    {"1", RECOVERY_PREFETCH_ON, true},
    {"0", RECOVERY_PREFETCH_OFF, true},
    {NULL, 0, false}
};
 
static const struct config_enum_entry force_parallel_mode_options[] = {
    {"off", FORCE_PARALLEL_OFF, false},
    {"on", FORCE_PARALLEL_ON, false},
    {"regress", FORCE_PARALLEL_REGRESS, false},
    {"true", FORCE_PARALLEL_ON, true},
    {"false", FORCE_PARALLEL_OFF, true},
    {"yes", FORCE_PARALLEL_ON, true},
    {"no", FORCE_PARALLEL_OFF, true},
    {"1", FORCE_PARALLEL_ON, true},
    {"0", FORCE_PARALLEL_OFF, true},
    {NULL, 0, false}
};
 
static const struct config_enum_entry plan_cache_mode_options[] = {
    {"auto", PLAN_CACHE_MODE_AUTO, false},
    {"force_generic_plan", PLAN_CACHE_MODE_FORCE_GENERIC_PLAN, false},
    {"force_custom_plan", PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN, false},
    {NULL, 0, false}
};
 
static const struct config_enum_entry password_encryption_options[] = {
    {"md5", PASSWORD_TYPE_MD5, false},
    {"scram-sha-256", PASSWORD_TYPE_SCRAM_SHA_256, false},
    {NULL, 0, false}
};
 
const struct config_enum_entry ssl_protocol_versions_info[] = {
    {"", PG_TLS_ANY, false},
    {"TLSv1", PG_TLS1_VERSION, false},
    {"TLSv1.1", PG_TLS1_1_VERSION, false},
    {"TLSv1.2", PG_TLS1_2_VERSION, false},
    {"TLSv1.3", PG_TLS1_3_VERSION, false},
    {NULL, 0, false}
};
 
StaticAssertDecl(lengthof(ssl_protocol_versions_info) == (PG_TLS1_3_VERSION + 2),
                 "array length mismatch");
 
static struct config_enum_entry recovery_init_sync_method_options[] = {
    {"fsync", RECOVERY_INIT_SYNC_METHOD_FSYNC, false},
#ifdef HAVE_SYNCFS
    {"syncfs", RECOVERY_INIT_SYNC_METHOD_SYNCFS, false},
#endif
    {NULL, 0, false}
};
 
static struct config_enum_entry shared_memory_options[] = {
#ifndef WIN32
    {"sysv", SHMEM_TYPE_SYSV, false},
#endif
#ifndef EXEC_BACKEND
    {"mmap", SHMEM_TYPE_MMAP, false},
#endif
#ifdef WIN32
    {"windows", SHMEM_TYPE_WINDOWS, false},
#endif
    {NULL, 0, false}
};
 
static struct config_enum_entry default_toast_compression_options[] = {
    {"pglz", TOAST_PGLZ_COMPRESSION, false},
#ifdef  USE_LZ4
    {"lz4", TOAST_LZ4_COMPRESSION, false},
#endif
    {NULL, 0, false}
};
 
static const struct config_enum_entry wal_compression_options[] = {
    {"pglz", WAL_COMPRESSION_PGLZ, false},
#ifdef USE_LZ4
    {"lz4", WAL_COMPRESSION_LZ4, false},
#endif
#ifdef USE_ZSTD
    {"zstd", WAL_COMPRESSION_ZSTD, false},
#endif
    {"on", WAL_COMPRESSION_PGLZ, false},
    {"off", WAL_COMPRESSION_NONE, false},
    {"true", WAL_COMPRESSION_PGLZ, true},
    {"false", WAL_COMPRESSION_NONE, true},
    {"yes", WAL_COMPRESSION_PGLZ, true},
    {"no", WAL_COMPRESSION_NONE, true},
    {"1", WAL_COMPRESSION_PGLZ, true},
    {"0", WAL_COMPRESSION_NONE, true},
    {NULL, 0, false}
};
 
/*
 * Options for enum values stored in other modules
 */
extern const struct config_enum_entry wal_level_options[];
extern const struct config_enum_entry archive_mode_options[];
extern const struct config_enum_entry recovery_target_action_options[];
extern const struct config_enum_entry sync_method_options[];
extern const struct config_enum_entry dynamic_shared_memory_options[];
 
/*
 * GUC option variables that are exported from this module
 */
bool        log_duration = false;
bool        Debug_print_plan = false;
bool        Debug_print_parse = false;
bool        Debug_print_rewritten = false;
bool        Debug_pretty_print = true;
 
bool        log_parser_stats = false;
bool        log_planner_stats = false;
bool        log_executor_stats = false;
bool        log_statement_stats = false;    /* this is sort of all three above
                                             * together */
bool        log_btree_build_stats = false;
char       *event_source;
 
bool        row_security;
bool        check_function_bodies = true;
 
/*
 * This GUC exists solely for backward compatibility, check its definition for
 * details.
 */
bool        default_with_oids = false;
bool        session_auth_is_superuser;
 
int         log_min_error_statement = ERROR;
int         log_min_messages = WARNING;
int         client_min_messages = NOTICE;
int         log_min_duration_sample = -1;
int         log_min_duration_statement = -1;
int         log_parameter_max_length = -1;
int         log_parameter_max_length_on_error = 0;
int         log_temp_files = -1;
double      log_statement_sample_rate = 1.0;
double      log_xact_sample_rate = 0;
int         trace_recovery_messages = LOG;
char       *backtrace_functions;
char       *backtrace_symbol_list;
 
int         temp_file_limit = -1;
 
int         num_temp_buffers = 1024;
 
char       *cluster_name = "";
char       *ConfigFileName;
char       *HbaFileName;
char       *IdentFileName;
char       *external_pid_file;
 
char       *pgstat_temp_directory;
 
char       *application_name;
 
int         tcp_keepalives_idle;
int         tcp_keepalives_interval;
int         tcp_keepalives_count;
int         tcp_user_timeout;
 
/*
 * SSL renegotiation was been removed in PostgreSQL 9.5, but we tolerate it
 * being set to zero (meaning never renegotiate) for backward compatibility.
 * This avoids breaking compatibility with clients that have never supported
 * renegotiation and therefore always try to zero it.
 */
int         ssl_renegotiation_limit;
 
/*
 * This really belongs in pg_shmem.c, but is defined here so that it doesn't
 * need to be duplicated in all the different implementations of pg_shmem.c.
 */
int         huge_pages;
int         huge_page_size;
 
/*
 * These variables are all dummies that don't do anything, except in some
 * cases provide the value for SHOW to display.  The real state is elsewhere
 * and is kept in sync by assign_hooks.
 */
static char *syslog_ident_str;
static double phony_random_seed;
static char *client_encoding_string;
static char *datestyle_string;
static char *locale_collate;
static char *locale_ctype;
static char *server_encoding_string;
static char *server_version_string;
static int  server_version_num;
static char *timezone_string;
static char *log_timezone_string;
static char *timezone_abbreviations_string;
static char *data_directory;
static char *session_authorization_string;
static int  max_function_args;
static int  max_index_keys;
static int  max_identifier_length;
static int  block_size;
static int  segment_size;
static int  shared_memory_size_mb;
static int  shared_memory_size_in_huge_pages;
static int  wal_block_size;
static bool data_checksums;
static bool integer_datetimes;
static bool assert_enabled;
static bool in_hot_standby;
static char *recovery_target_timeline_string;
static char *recovery_target_string;
static char *recovery_target_xid_string;
static char *recovery_target_name_string;
static char *recovery_target_lsn_string;
 
 
/* should be static, but commands/variable.c needs to get at this */
char       *role_string;
 
 
/*
 * Displayable names for context types (enum GucContext)
 *
 * Note: these strings are deliberately not localized.
 */
const char *const GucContext_Names[] =
{
     /* PGC_INTERNAL */ "internal",
     /* PGC_POSTMASTER */ "postmaster",
     /* PGC_SIGHUP */ "sighup",
     /* PGC_SU_BACKEND */ "superuser-backend",
     /* PGC_BACKEND */ "backend",
     /* PGC_SUSET */ "superuser",
     /* PGC_USERSET */ "user"
};
 
StaticAssertDecl(lengthof(GucContext_Names) == (PGC_USERSET + 1),
                 "array length mismatch");
 
/*
 * Displayable names for source types (enum GucSource)
 *
 * Note: these strings are deliberately not localized.
 */
const char *const GucSource_Names[] =
{
     /* PGC_S_DEFAULT */ "default",
     /* PGC_S_DYNAMIC_DEFAULT */ "default",
     /* PGC_S_ENV_VAR */ "environment variable",
     /* PGC_S_FILE */ "configuration file",
     /* PGC_S_ARGV */ "command line",
     /* PGC_S_GLOBAL */ "global",
     /* PGC_S_DATABASE */ "database",
     /* PGC_S_USER */ "user",
     /* PGC_S_DATABASE_USER */ "database user",
     /* PGC_S_CLIENT */ "client",
     /* PGC_S_OVERRIDE */ "override",
     /* PGC_S_INTERACTIVE */ "interactive",
     /* PGC_S_TEST */ "test",
     /* PGC_S_SESSION */ "session"
};
 
StaticAssertDecl(lengthof(GucSource_Names) == (PGC_S_SESSION + 1),
                 "array length mismatch");
 
/*
 * Displayable names for the groupings defined in enum config_group
 */
const char *const config_group_names[] =
{
    /* UNGROUPED */
    gettext_noop("Ungrouped"),
    /* FILE_LOCATIONS */
    gettext_noop("File Locations"),
    /* CONN_AUTH_SETTINGS */
    gettext_noop("Connections and Authentication / Connection Settings"),
    /* CONN_AUTH_AUTH */
    gettext_noop("Connections and Authentication / Authentication"),
    /* CONN_AUTH_SSL */
    gettext_noop("Connections and Authentication / SSL"),
    /* RESOURCES_MEM */
    gettext_noop("Resource Usage / Memory"),
    /* RESOURCES_DISK */
    gettext_noop("Resource Usage / Disk"),
    /* RESOURCES_KERNEL */
    gettext_noop("Resource Usage / Kernel Resources"),
    /* RESOURCES_VACUUM_DELAY */
    gettext_noop("Resource Usage / Cost-Based Vacuum Delay"),
    /* RESOURCES_BGWRITER */
    gettext_noop("Resource Usage / Background Writer"),
    /* RESOURCES_ASYNCHRONOUS */
    gettext_noop("Resource Usage / Asynchronous Behavior"),
    /* WAL_SETTINGS */
    gettext_noop("Write-Ahead Log / Settings"),
    /* WAL_CHECKPOINTS */
    gettext_noop("Write-Ahead Log / Checkpoints"),
    /* WAL_ARCHIVING */
    gettext_noop("Write-Ahead Log / Archiving"),
    /* WAL_RECOVERY */
    gettext_noop("Write-Ahead Log / Recovery"),
    /* WAL_ARCHIVE_RECOVERY */
    gettext_noop("Write-Ahead Log / Archive Recovery"),
    /* WAL_RECOVERY_TARGET */
    gettext_noop("Write-Ahead Log / Recovery Target"),
    /* REPLICATION_SENDING */
    gettext_noop("Replication / Sending Servers"),
    /* REPLICATION_PRIMARY */
    gettext_noop("Replication / Primary Server"),
    /* REPLICATION_STANDBY */
    gettext_noop("Replication / Standby Servers"),
    /* REPLICATION_SUBSCRIBERS */
    gettext_noop("Replication / Subscribers"),
    /* QUERY_TUNING_METHOD */
    gettext_noop("Query Tuning / Planner Method Configuration"),
    /* QUERY_TUNING_COST */
    gettext_noop("Query Tuning / Planner Cost Constants"),
    /* QUERY_TUNING_GEQO */
    gettext_noop("Query Tuning / Genetic Query Optimizer"),
    /* QUERY_TUNING_OTHER */
    gettext_noop("Query Tuning / Other Planner Options"),
    /* LOGGING_WHERE */
    gettext_noop("Reporting and Logging / Where to Log"),
    /* LOGGING_WHEN */
    gettext_noop("Reporting and Logging / When to Log"),
    /* LOGGING_WHAT */
    gettext_noop("Reporting and Logging / What to Log"),
    /* PROCESS_TITLE */
    gettext_noop("Reporting and Logging / Process Title"),
    /* STATS_MONITORING */
    gettext_noop("Statistics / Monitoring"),
    /* STATS_CUMULATIVE */
    gettext_noop("Statistics / Cumulative Query and Index Statistics"),
    /* AUTOVACUUM */
    gettext_noop("Autovacuum"),
    /* CLIENT_CONN_STATEMENT */
    gettext_noop("Client Connection Defaults / Statement Behavior"),
    /* CLIENT_CONN_LOCALE */
    gettext_noop("Client Connection Defaults / Locale and Formatting"),
    /* CLIENT_CONN_PRELOAD */
    gettext_noop("Client Connection Defaults / Shared Library Preloading"),
    /* CLIENT_CONN_OTHER */
    gettext_noop("Client Connection Defaults / Other Defaults"),
    /* LOCK_MANAGEMENT */
    gettext_noop("Lock Management"),
    /* COMPAT_OPTIONS_PREVIOUS */
    gettext_noop("Version and Platform Compatibility / Previous PostgreSQL Versions"),
    /* COMPAT_OPTIONS_CLIENT */
    gettext_noop("Version and Platform Compatibility / Other Platforms and Clients"),
    /* ERROR_HANDLING */
    gettext_noop("Error Handling"),
    /* PRESET_OPTIONS */
    gettext_noop("Preset Options"),
    /* CUSTOM_OPTIONS */
    gettext_noop("Customized Options"),
    /* DEVELOPER_OPTIONS */
    gettext_noop("Developer Options"),
    /* help_config wants this array to be null-terminated */
    NULL
};
 
StaticAssertDecl(lengthof(config_group_names) == (DEVELOPER_OPTIONS + 2),
                 "array length mismatch");
 
/*
 * Displayable names for GUC variable types (enum config_type)
 *
 * Note: these strings are deliberately not localized.
 */
const char *const config_type_names[] =
{
     /* PGC_BOOL */ "bool",
     /* PGC_INT */ "integer",
     /* PGC_REAL */ "real",
     /* PGC_STRING */ "string",
     /* PGC_ENUM */ "enum"
};
 
StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
                 "array length mismatch");
 
/*
 * Unit conversion tables.
 *
 * There are two tables, one for memory units, and another for time units.
 * For each supported conversion from one unit to another, we have an entry
 * in the table.
 *
 * To keep things simple, and to avoid possible roundoff error,
 * conversions are never chained.  There needs to be a direct conversion
 * between all units (of the same type).
 *
 * The conversions for each base unit must be kept in order from greatest to
 * smallest human-friendly unit; convert_xxx_from_base_unit() rely on that.
 * (The order of the base-unit groups does not matter.)
 */
#define MAX_UNIT_LEN        3   /* length of longest recognized unit string */
 
typedef struct
{
    char        unit[MAX_UNIT_LEN + 1]; /* unit, as a string, like "kB" or
                                         * "min" */
    int         base_unit;      /* GUC_UNIT_XXX */
    double      multiplier;     /* Factor for converting unit -> base_unit */
} unit_conversion;
 
/* Ensure that the constants in the tables don't overflow or underflow */
#if BLCKSZ < 1024 || BLCKSZ > (1024*1024)
#error BLCKSZ must be between 1KB and 1MB
#endif
#if XLOG_BLCKSZ < 1024 || XLOG_BLCKSZ > (1024*1024)
#error XLOG_BLCKSZ must be between 1KB and 1MB
#endif
 
static const char *memory_units_hint = gettext_noop("Valid units for this parameter are \"B\", \"kB\", \"MB\", \"GB\", and \"TB\".");
 
static const unit_conversion memory_unit_conversion_table[] =
{
    {"TB", GUC_UNIT_BYTE, 1024.0 * 1024.0 * 1024.0 * 1024.0},
    {"GB", GUC_UNIT_BYTE, 1024.0 * 1024.0 * 1024.0},
    {"MB", GUC_UNIT_BYTE, 1024.0 * 1024.0},
    {"kB", GUC_UNIT_BYTE, 1024.0},
    {"B", GUC_UNIT_BYTE, 1.0},
 
    {"TB", GUC_UNIT_KB, 1024.0 * 1024.0 * 1024.0},
    {"GB", GUC_UNIT_KB, 1024.0 * 1024.0},
    {"MB", GUC_UNIT_KB, 1024.0},
    {"kB", GUC_UNIT_KB, 1.0},
    {"B", GUC_UNIT_KB, 1.0 / 1024.0},
 
    {"TB", GUC_UNIT_MB, 1024.0 * 1024.0},
    {"GB", GUC_UNIT_MB, 1024.0},
    {"MB", GUC_UNIT_MB, 1.0},
    {"kB", GUC_UNIT_MB, 1.0 / 1024.0},
    {"B", GUC_UNIT_MB, 1.0 / (1024.0 * 1024.0)},
 
    {"TB", GUC_UNIT_BLOCKS, (1024.0 * 1024.0 * 1024.0) / (BLCKSZ / 1024)},
    {"GB", GUC_UNIT_BLOCKS, (1024.0 * 1024.0) / (BLCKSZ / 1024)},
    {"MB", GUC_UNIT_BLOCKS, 1024.0 / (BLCKSZ / 1024)},
    {"kB", GUC_UNIT_BLOCKS, 1.0 / (BLCKSZ / 1024)},
    {"B", GUC_UNIT_BLOCKS, 1.0 / BLCKSZ},
 
    {"TB", GUC_UNIT_XBLOCKS, (1024.0 * 1024.0 * 1024.0) / (XLOG_BLCKSZ / 1024)},
    {"GB", GUC_UNIT_XBLOCKS, (1024.0 * 1024.0) / (XLOG_BLCKSZ / 1024)},
    {"MB", GUC_UNIT_XBLOCKS, 1024.0 / (XLOG_BLCKSZ / 1024)},
    {"kB", GUC_UNIT_XBLOCKS, 1.0 / (XLOG_BLCKSZ / 1024)},
    {"B", GUC_UNIT_XBLOCKS, 1.0 / XLOG_BLCKSZ},
 
    {""}                        /* end of table marker */
};
 
static const char *time_units_hint = gettext_noop("Valid units for this parameter are \"us\", \"ms\", \"s\", \"min\", \"h\", and \"d\".");
 
static const unit_conversion time_unit_conversion_table[] =
{
    {"d", GUC_UNIT_MS, 1000 * 60 * 60 * 24},
    {"h", GUC_UNIT_MS, 1000 * 60 * 60},
    {"min", GUC_UNIT_MS, 1000 * 60},
    {"s", GUC_UNIT_MS, 1000},
    {"ms", GUC_UNIT_MS, 1},
    {"us", GUC_UNIT_MS, 1.0 / 1000},
 
    {"d", GUC_UNIT_S, 60 * 60 * 24},
    {"h", GUC_UNIT_S, 60 * 60},
    {"min", GUC_UNIT_S, 60},
    {"s", GUC_UNIT_S, 1},
    {"ms", GUC_UNIT_S, 1.0 / 1000},
    {"us", GUC_UNIT_S, 1.0 / (1000 * 1000)},
 
    {"d", GUC_UNIT_MIN, 60 * 24},
    {"h", GUC_UNIT_MIN, 60},
    {"min", GUC_UNIT_MIN, 1},
    {"s", GUC_UNIT_MIN, 1.0 / 60},
    {"ms", GUC_UNIT_MIN, 1.0 / (1000 * 60)},
    {"us", GUC_UNIT_MIN, 1.0 / (1000 * 1000 * 60)},
 
    {""}                        /* end of table marker */
};
 
/*
 * Contents of GUC tables
 *
 * See src/backend/utils/misc/README for design notes.
 *
 * TO ADD AN OPTION:
 *
 * 1. Declare a global variable of type bool, int, double, or char*
 *    and make use of it.
 *
 * 2. Decide at what times it's safe to set the option. See guc.h for
 *    details.
 *
 * 3. Decide on a name, a default value, upper and lower bounds (if
 *    applicable), etc.
 *
 * 4. Add a record below.
 *
 * 5. Add it to src/backend/utils/misc/postgresql.conf.sample, if
 *    appropriate.
 *
 * 6. Don't forget to document the option (at least in config.sgml).
 *
 * 7. If it's a new GUC_LIST_QUOTE option, you must add it to
 *    variable_is_guc_list_quote() in src/bin/pg_dump/dumputils.c.
 */
 
 
/******** option records follow ********/
 
static struct config_bool ConfigureNamesBool[] =
{
    {
        {"enable_seqscan", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of sequential-scan plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_seqscan,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_indexscan", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of index-scan plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_indexscan,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_indexonlyscan", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of index-only-scan plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_indexonlyscan,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_bitmapscan", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of bitmap-scan plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_bitmapscan,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_tidscan", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of TID scan plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_tidscan,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_sort", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of explicit sort steps."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_sort,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_incremental_sort", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of incremental sort steps."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_incremental_sort,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_hashagg", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of hashed aggregation plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_hashagg,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_material", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of materialization."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_material,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_memoize", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of memoization."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_memoize,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_nestloop", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of nested-loop join plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_nestloop,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_mergejoin", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of merge join plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_mergejoin,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_hashjoin", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of hash join plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_hashjoin,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_gathermerge", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of gather merge plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_gathermerge,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_partitionwise_join", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables partitionwise join."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_partitionwise_join,
        false,
        NULL, NULL, NULL
    },
    {
        {"enable_partitionwise_aggregate", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables partitionwise aggregation and grouping."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_partitionwise_aggregate,
        false,
        NULL, NULL, NULL
    },
    {
        {"enable_parallel_append", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of parallel append plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_parallel_append,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_parallel_hash", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of parallel hash plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_parallel_hash,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_partition_pruning", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables plan-time and execution-time partition pruning."),
            gettext_noop("Allows the query planner and executor to compare partition "
                         "bounds to conditions in the query to determine which "
                         "partitions must be scanned."),
            GUC_EXPLAIN
        },
        &enable_partition_pruning,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_async_append", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enables the planner's use of async append plans."),
            NULL,
            GUC_EXPLAIN
        },
        &enable_async_append,
        true,
        NULL, NULL, NULL
    },
    {
        {"enable_group_by_reordering", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("enable reordering of GROUP BY key"),
            NULL,
            GUC_EXPLAIN
        },
        &enable_group_by_reordering,
        true,
        NULL, NULL, NULL
    },
    {
        {"geqo", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("Enables genetic query optimization."),
            gettext_noop("This algorithm attempts to do planning without "
                         "exhaustive searching."),
            GUC_EXPLAIN
        },
        &enable_geqo,
        true,
        NULL, NULL, NULL
    },
    {
        /* Not for general use --- used by SET SESSION AUTHORIZATION */
        {"is_superuser", PGC_INTERNAL, UNGROUPED,
            gettext_noop("Shows whether the current user is a superuser."),
            NULL,
            GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &session_auth_is_superuser,
        false,
        NULL, NULL, NULL
    },
    {
        {"bonjour", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Enables advertising the server via Bonjour."),
            NULL
        },
        &enable_bonjour,
        false,
        check_bonjour, NULL, NULL
    },
    {
        {"track_commit_timestamp", PGC_POSTMASTER, REPLICATION_SENDING,
            gettext_noop("Collects transaction commit time."),
            NULL
        },
        &track_commit_timestamp,
        false,
        NULL, NULL, NULL
    },
    {
        {"ssl", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Enables SSL connections."),
            NULL
        },
        &EnableSSL,
        false,
        check_ssl, NULL, NULL
    },
    {
        {"ssl_passphrase_command_supports_reload", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Controls whether ssl_passphrase_command is called during server reload."),
            NULL
        },
        &ssl_passphrase_command_supports_reload,
        false,
        NULL, NULL, NULL
    },
    {
        {"ssl_prefer_server_ciphers", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Give priority to server ciphersuite order."),
            NULL
        },
        &SSLPreferServerCiphers,
        true,
        NULL, NULL, NULL
    },
    {
        {"fsync", PGC_SIGHUP, WAL_SETTINGS,
            gettext_noop("Forces synchronization of updates to disk."),
            gettext_noop("The server will use the fsync() system call in several places to make "
                         "sure that updates are physically written to disk. This insures "
                         "that a database cluster will recover to a consistent state after "
                         "an operating system or hardware crash.")
        },
        &enableFsync,
        true,
        NULL, NULL, NULL
    },
    {
        {"ignore_checksum_failure", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Continues processing after a checksum failure."),
            gettext_noop("Detection of a checksum failure normally causes PostgreSQL to "
                         "report an error, aborting the current transaction. Setting "
                         "ignore_checksum_failure to true causes the system to ignore the failure "
                         "(but still report a warning), and continue processing. This "
                         "behavior could cause crashes or other serious problems. Only "
                         "has an effect if checksums are enabled."),
            GUC_NOT_IN_SAMPLE
        },
        &ignore_checksum_failure,
        false,
        NULL, NULL, NULL
    },
    {
        {"zero_damaged_pages", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Continues processing past damaged page headers."),
            gettext_noop("Detection of a damaged page header normally causes PostgreSQL to "
                         "report an error, aborting the current transaction. Setting "
                         "zero_damaged_pages to true causes the system to instead report a "
                         "warning, zero out the damaged page, and continue processing. This "
                         "behavior will destroy data, namely all the rows on the damaged page."),
            GUC_NOT_IN_SAMPLE
        },
        &zero_damaged_pages,
        false,
        NULL, NULL, NULL
    },
    {
        {"ignore_invalid_pages", PGC_POSTMASTER, DEVELOPER_OPTIONS,
            gettext_noop("Continues recovery after an invalid pages failure."),
            gettext_noop("Detection of WAL records having references to "
                         "invalid pages during recovery causes PostgreSQL to "
                         "raise a PANIC-level error, aborting the recovery. "
                         "Setting ignore_invalid_pages to true causes "
                         "the system to ignore invalid page references "
                         "in WAL records (but still report a warning), "
                         "and continue recovery. This behavior may cause "
                         "crashes, data loss, propagate or hide corruption, "
                         "or other serious problems. Only has an effect "
                         "during recovery or in standby mode."),
            GUC_NOT_IN_SAMPLE
        },
        &ignore_invalid_pages,
        false,
        NULL, NULL, NULL
    },
    {
        {"full_page_writes", PGC_SIGHUP, WAL_SETTINGS,
            gettext_noop("Writes full pages to WAL when first modified after a checkpoint."),
            gettext_noop("A page write in process during an operating system crash might be "
                         "only partially written to disk.  During recovery, the row changes "
                         "stored in WAL are not enough to recover.  This option writes "
                         "pages when first modified after a checkpoint to WAL so full recovery "
                         "is possible.")
        },
        &fullPageWrites,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"wal_log_hints", PGC_POSTMASTER, WAL_SETTINGS,
            gettext_noop("Writes full pages to WAL when first modified after a checkpoint, even for a non-critical modification."),
            NULL
        },
        &wal_log_hints,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"wal_init_zero", PGC_SUSET, WAL_SETTINGS,
            gettext_noop("Writes zeroes to new WAL files before first use."),
            NULL
        },
        &wal_init_zero,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"wal_recycle", PGC_SUSET, WAL_SETTINGS,
            gettext_noop("Recycles WAL files by renaming them."),
            NULL
        },
        &wal_recycle,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"log_checkpoints", PGC_SIGHUP, LOGGING_WHAT,
            gettext_noop("Logs each checkpoint."),
            NULL
        },
        &log_checkpoints,
        true,
        NULL, NULL, NULL
    },
    {
        {"log_connections", PGC_SU_BACKEND, LOGGING_WHAT,
            gettext_noop("Logs each successful connection."),
            NULL
        },
        &Log_connections,
        false,
        NULL, NULL, NULL
    },
    {
        {"log_disconnections", PGC_SU_BACKEND, LOGGING_WHAT,
            gettext_noop("Logs end of a session, including duration."),
            NULL
        },
        &Log_disconnections,
        false,
        NULL, NULL, NULL
    },
    {
        {"log_replication_commands", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Logs each replication command."),
            NULL
        },
        &log_replication_commands,
        false,
        NULL, NULL, NULL
    },
    {
        {"debug_assertions", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows whether the running server has assertion checks enabled."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &assert_enabled,
#ifdef USE_ASSERT_CHECKING
        true,
#else
        false,
#endif
        NULL, NULL, NULL
    },
 
    {
        {"exit_on_error", PGC_USERSET, ERROR_HANDLING_OPTIONS,
            gettext_noop("Terminate session on any error."),
            NULL
        },
        &ExitOnAnyError,
        false,
        NULL, NULL, NULL
    },
    {
        {"restart_after_crash", PGC_SIGHUP, ERROR_HANDLING_OPTIONS,
            gettext_noop("Reinitialize server after backend crash."),
            NULL
        },
        &restart_after_crash,
        true,
        NULL, NULL, NULL
    },
    {
        {"remove_temp_files_after_crash", PGC_SIGHUP, DEVELOPER_OPTIONS,
            gettext_noop("Remove temporary files after backend crash."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &remove_temp_files_after_crash,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"log_duration", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Logs the duration of each completed SQL statement."),
            NULL
        },
        &log_duration,
        false,
        NULL, NULL, NULL
    },
    {
        {"debug_print_parse", PGC_USERSET, LOGGING_WHAT,
            gettext_noop("Logs each query's parse tree."),
            NULL
        },
        &Debug_print_parse,
        false,
        NULL, NULL, NULL
    },
    {
        {"debug_print_rewritten", PGC_USERSET, LOGGING_WHAT,
            gettext_noop("Logs each query's rewritten parse tree."),
            NULL
        },
        &Debug_print_rewritten,
        false,
        NULL, NULL, NULL
    },
    {
        {"debug_print_plan", PGC_USERSET, LOGGING_WHAT,
            gettext_noop("Logs each query's execution plan."),
            NULL
        },
        &Debug_print_plan,
        false,
        NULL, NULL, NULL
    },
    {
        {"debug_pretty_print", PGC_USERSET, LOGGING_WHAT,
            gettext_noop("Indents parse and plan tree displays."),
            NULL
        },
        &Debug_pretty_print,
        true,
        NULL, NULL, NULL
    },
    {
        {"log_parser_stats", PGC_SUSET, STATS_MONITORING,
            gettext_noop("Writes parser performance statistics to the server log."),
            NULL
        },
        &log_parser_stats,
        false,
        check_stage_log_stats, NULL, NULL
    },
    {
        {"log_planner_stats", PGC_SUSET, STATS_MONITORING,
            gettext_noop("Writes planner performance statistics to the server log."),
            NULL
        },
        &log_planner_stats,
        false,
        check_stage_log_stats, NULL, NULL
    },
    {
        {"log_executor_stats", PGC_SUSET, STATS_MONITORING,
            gettext_noop("Writes executor performance statistics to the server log."),
            NULL
        },
        &log_executor_stats,
        false,
        check_stage_log_stats, NULL, NULL
    },
    {
        {"log_statement_stats", PGC_SUSET, STATS_MONITORING,
            gettext_noop("Writes cumulative performance statistics to the server log."),
            NULL
        },
        &log_statement_stats,
        false,
        check_log_stats, NULL, NULL
    },
#ifdef BTREE_BUILD_STATS
    {
        {"log_btree_build_stats", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Logs system resource usage statistics (memory and CPU) on various B-tree operations."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &log_btree_build_stats,
        false,
        NULL, NULL, NULL
    },
#endif
 
    {
        {"track_activities", PGC_SUSET, STATS_CUMULATIVE,
            gettext_noop("Collects information about executing commands."),
            gettext_noop("Enables the collection of information on the currently "
                         "executing command of each session, along with "
                         "the time at which that command began execution.")
        },
        &pgstat_track_activities,
        true,
        NULL, NULL, NULL
    },
    {
        {"track_counts", PGC_SUSET, STATS_CUMULATIVE,
            gettext_noop("Collects statistics on database activity."),
            NULL
        },
        &pgstat_track_counts,
        true,
        NULL, NULL, NULL
    },
    {
        {"track_io_timing", PGC_SUSET, STATS_CUMULATIVE,
            gettext_noop("Collects timing statistics for database I/O activity."),
            NULL
        },
        &track_io_timing,
        false,
        NULL, NULL, NULL
    },
    {
        {"track_wal_io_timing", PGC_SUSET, STATS_CUMULATIVE,
            gettext_noop("Collects timing statistics for WAL I/O activity."),
            NULL
        },
        &track_wal_io_timing,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"update_process_title", PGC_SUSET, PROCESS_TITLE,
            gettext_noop("Updates the process title to show the active SQL command."),
            gettext_noop("Enables updating of the process title every time a new SQL command is received by the server.")
        },
        &update_process_title,
#ifdef WIN32
        false,
#else
        true,
#endif
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Starts the autovacuum subprocess."),
            NULL
        },
        &autovacuum_start_daemon,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"trace_notify", PGC_USERSET, DEVELOPER_OPTIONS,
            gettext_noop("Generates debugging output for LISTEN and NOTIFY."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &Trace_notify,
        false,
        NULL, NULL, NULL
    },
 
#ifdef LOCK_DEBUG
    {
        {"trace_locks", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Emits information about lock usage."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &Trace_locks,
        false,
        NULL, NULL, NULL
    },
    {
        {"trace_userlocks", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Emits information about user lock usage."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &Trace_userlocks,
        false,
        NULL, NULL, NULL
    },
    {
        {"trace_lwlocks", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Emits information about lightweight lock usage."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &Trace_lwlocks,
        false,
        NULL, NULL, NULL
    },
    {
        {"debug_deadlocks", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Dumps information about all current locks when a deadlock timeout occurs."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &Debug_deadlocks,
        false,
        NULL, NULL, NULL
    },
#endif
 
    {
        {"log_lock_waits", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Logs long lock waits."),
            NULL
        },
        &log_lock_waits,
        false,
        NULL, NULL, NULL
    },
    {
        {"log_recovery_conflict_waits", PGC_SIGHUP, LOGGING_WHAT,
            gettext_noop("Logs standby recovery conflict waits."),
            NULL
        },
        &log_recovery_conflict_waits,
        false,
        NULL, NULL, NULL
    },
    {
        {"log_hostname", PGC_SIGHUP, LOGGING_WHAT,
            gettext_noop("Logs the host name in the connection logs."),
            gettext_noop("By default, connection logs only show the IP address "
                         "of the connecting host. If you want them to show the host name you "
                         "can turn this on, but depending on your host name resolution "
                         "setup it might impose a non-negligible performance penalty.")
        },
        &log_hostname,
        false,
        NULL, NULL, NULL
    },
    {
        {"transform_null_equals", PGC_USERSET, COMPAT_OPTIONS_CLIENT,
            gettext_noop("Treats \"expr=NULL\" as \"expr IS NULL\"."),
            gettext_noop("When turned on, expressions of the form expr = NULL "
                         "(or NULL = expr) are treated as expr IS NULL, that is, they "
                         "return true if expr evaluates to the null value, and false "
                         "otherwise. The correct behavior of expr = NULL is to always "
                         "return null (unknown).")
        },
        &Transform_null_equals,
        false,
        NULL, NULL, NULL
    },
    {
        {"db_user_namespace", PGC_SIGHUP, CONN_AUTH_AUTH,
            gettext_noop("Enables per-database user names."),
            NULL
        },
        &Db_user_namespace,
        false,
        NULL, NULL, NULL
    },
    {
        {"default_transaction_read_only", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the default read-only status of new transactions."),
            NULL,
            GUC_REPORT
        },
        &DefaultXactReadOnly,
        false,
        NULL, NULL, NULL
    },
    {
        {"transaction_read_only", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the current transaction's read-only status."),
            NULL,
            GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &XactReadOnly,
        false,
        check_transaction_read_only, NULL, NULL
    },
    {
        {"default_transaction_deferrable", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the default deferrable status of new transactions."),
            NULL
        },
        &DefaultXactDeferrable,
        false,
        NULL, NULL, NULL
    },
    {
        {"transaction_deferrable", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Whether to defer a read-only serializable transaction until it can be executed with no possible serialization failures."),
            NULL,
            GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &XactDeferrable,
        false,
        check_transaction_deferrable, NULL, NULL
    },
    {
        {"row_security", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Enable row security."),
            gettext_noop("When enabled, row security will be applied to all users.")
        },
        &row_security,
        true,
        NULL, NULL, NULL
    },
    {
        {"check_function_bodies", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Check routine bodies during CREATE FUNCTION and CREATE PROCEDURE."),
            NULL
        },
        &check_function_bodies,
        true,
        NULL, NULL, NULL
    },
    {
        {"array_nulls", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("Enable input of NULL elements in arrays."),
            gettext_noop("When turned on, unquoted NULL in an array input "
                         "value means a null value; "
                         "otherwise it is taken literally.")
        },
        &Array_nulls,
        true,
        NULL, NULL, NULL
    },
 
    /*
     * WITH OIDS support, and consequently default_with_oids, was removed in
     * PostgreSQL 12, but we tolerate the parameter being set to false to
     * avoid unnecessarily breaking older dump files.
     */
    {
        {"default_with_oids", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("WITH OIDS is no longer supported; this can only be false."),
            NULL,
            GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE
        },
        &default_with_oids,
        false,
        check_default_with_oids, NULL, NULL
    },
    {
        {"logging_collector", PGC_POSTMASTER, LOGGING_WHERE,
            gettext_noop("Start a subprocess to capture stderr output and/or csvlogs into log files."),
            NULL
        },
        &Logging_collector,
        false,
        NULL, NULL, NULL
    },
    {
        {"log_truncate_on_rotation", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Truncate existing log files of same name during log rotation."),
            NULL
        },
        &Log_truncate_on_rotation,
        false,
        NULL, NULL, NULL
    },
 
#ifdef TRACE_SORT
    {
        {"trace_sort", PGC_USERSET, DEVELOPER_OPTIONS,
            gettext_noop("Emit information about resource usage in sorting."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &trace_sort,
        false,
        NULL, NULL, NULL
    },
#endif
 
#ifdef TRACE_SYNCSCAN
    /* this is undocumented because not exposed in a standard build */
    {
        {"trace_syncscan", PGC_USERSET, DEVELOPER_OPTIONS,
            gettext_noop("Generate debugging output for synchronized scanning."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &trace_syncscan,
        false,
        NULL, NULL, NULL
    },
#endif
 
#ifdef DEBUG_BOUNDED_SORT
    /* this is undocumented because not exposed in a standard build */
    {
        {
            "optimize_bounded_sort", PGC_USERSET, QUERY_TUNING_METHOD,
            gettext_noop("Enable bounded sorting using heap sort."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_EXPLAIN
        },
        &optimize_bounded_sort,
        true,
        NULL, NULL, NULL
    },
#endif
 
#ifdef WAL_DEBUG
    {
        {"wal_debug", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Emit WAL-related debugging output."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &XLOG_DEBUG,
        false,
        NULL, NULL, NULL
    },
#endif
 
    {
        {"integer_datetimes", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows whether datetimes are integer based."),
            NULL,
            GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &integer_datetimes,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"krb_caseins_users", PGC_SIGHUP, CONN_AUTH_AUTH,
            gettext_noop("Sets whether Kerberos and GSSAPI user names should be treated as case-insensitive."),
            NULL
        },
        &pg_krb_caseins_users,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"escape_string_warning", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("Warn about backslash escapes in ordinary string literals."),
            NULL
        },
        &escape_string_warning,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"standard_conforming_strings", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("Causes '...' strings to treat backslashes literally."),
            NULL,
            GUC_REPORT
        },
        &standard_conforming_strings,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"synchronize_seqscans", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("Enable synchronized sequential scans."),
            NULL
        },
        &synchronize_seqscans,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"recovery_target_inclusive", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Sets whether to include or exclude transaction with recovery target."),
            NULL
        },
        &recoveryTargetInclusive,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"hot_standby", PGC_POSTMASTER, REPLICATION_STANDBY,
            gettext_noop("Allows connections and queries during recovery."),
            NULL
        },
        &EnableHotStandby,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"hot_standby_feedback", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Allows feedback from a hot standby to the primary that will avoid query conflicts."),
            NULL
        },
        &hot_standby_feedback,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"in_hot_standby", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows whether hot standby is currently active."),
            NULL,
            GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &in_hot_standby,
        false,
        NULL, NULL, show_in_hot_standby
    },
 
    {
        {"allow_system_table_mods", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Allows modifications of the structure of system tables."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &allowSystemTableMods,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"ignore_system_indexes", PGC_BACKEND, DEVELOPER_OPTIONS,
            gettext_noop("Disables reading from system indexes."),
            gettext_noop("It does not prevent updating the indexes, so it is safe "
                         "to use.  The worst consequence is slowness."),
            GUC_NOT_IN_SAMPLE
        },
        &IgnoreSystemIndexes,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"allow_in_place_tablespaces", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Allows tablespaces directly inside pg_tblspc, for testing."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &allow_in_place_tablespaces,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"lo_compat_privileges", PGC_SUSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("Enables backward compatibility mode for privilege checks on large objects."),
            gettext_noop("Skips privilege checks when reading or modifying large objects, "
                         "for compatibility with PostgreSQL releases prior to 9.0.")
        },
        &lo_compat_privileges,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"quote_all_identifiers", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("When generating SQL fragments, quote all identifiers."),
            NULL,
        },
        &quote_all_identifiers,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"data_checksums", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows whether data checksums are turned on for this cluster."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
        },
        &data_checksums,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"syslog_sequence_numbers", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Add sequence number to syslog messages to avoid duplicate suppression."),
            NULL
        },
        &syslog_sequence_numbers,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"syslog_split_messages", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Split messages sent to syslog by lines and to fit into 1024 bytes."),
            NULL
        },
        &syslog_split_messages,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"parallel_leader_participation", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
            gettext_noop("Controls whether Gather and Gather Merge also run subplans."),
            gettext_noop("Should gather nodes also run subplans or just gather tuples?"),
            GUC_EXPLAIN
        },
        &parallel_leader_participation,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"jit", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Allow JIT compilation."),
            NULL,
            GUC_EXPLAIN
        },
        &jit_enabled,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"jit_debugging_support", PGC_SU_BACKEND, DEVELOPER_OPTIONS,
            gettext_noop("Register JIT-compiled functions with debugger."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &jit_debugging_support,
        false,
 
        /*
         * This is not guaranteed to be available, but given it's a developer
         * oriented option, it doesn't seem worth adding code checking
         * availability.
         */
        NULL, NULL, NULL
    },
 
    {
        {"jit_dump_bitcode", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Write out LLVM bitcode to facilitate JIT debugging."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &jit_dump_bitcode,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"jit_expressions", PGC_USERSET, DEVELOPER_OPTIONS,
            gettext_noop("Allow JIT compilation of expressions."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &jit_expressions,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"jit_profiling_support", PGC_SU_BACKEND, DEVELOPER_OPTIONS,
            gettext_noop("Register JIT-compiled functions with perf profiler."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &jit_profiling_support,
        false,
 
        /*
         * This is not guaranteed to be available, but given it's a developer
         * oriented option, it doesn't seem worth adding code checking
         * availability.
         */
        NULL, NULL, NULL
    },
 
    {
        {"jit_tuple_deforming", PGC_USERSET, DEVELOPER_OPTIONS,
            gettext_noop("Allow JIT compilation of tuple deforming."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &jit_tuple_deforming,
        true,
        NULL, NULL, NULL
    },
 
    {
        {"data_sync_retry", PGC_POSTMASTER, ERROR_HANDLING_OPTIONS,
            gettext_noop("Whether to continue running after a failure to sync data files."),
        },
        &data_sync_retry,
        false,
        NULL, NULL, NULL
    },
 
    {
        {"wal_receiver_create_temp_slot", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets whether a WAL receiver should create a temporary replication slot if no permanent slot is configured."),
        },
        &wal_receiver_create_temp_slot,
        false,
        NULL, NULL, NULL
    },
 
    /* End-of-list marker */
    {
        {NULL, 0, 0, NULL, NULL}, NULL, false, NULL, NULL, NULL
    }
};
 
 
static struct config_int ConfigureNamesInt[] =
{
    {
        {"archive_timeout", PGC_SIGHUP, WAL_ARCHIVING,
            gettext_noop("Sets the amount of time to wait before forcing a "
                         "switch to the next WAL file."),
            NULL,
            GUC_UNIT_S
        },
        &XLogArchiveTimeout,
        0, 0, INT_MAX / 2,
        NULL, NULL, NULL
    },
    {
        {"post_auth_delay", PGC_BACKEND, DEVELOPER_OPTIONS,
            gettext_noop("Sets the amount of time to wait after "
                         "authentication on connection startup."),
            gettext_noop("This allows attaching a debugger to the process."),
            GUC_NOT_IN_SAMPLE | GUC_UNIT_S
        },
        &PostAuthDelay,
        0, 0, INT_MAX / 1000000,
        NULL, NULL, NULL
    },
    {
        {"default_statistics_target", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Sets the default statistics target."),
            gettext_noop("This applies to table columns that have not had a "
                         "column-specific target set via ALTER TABLE SET STATISTICS.")
        },
        &default_statistics_target,
        100, 1, 10000,
        NULL, NULL, NULL
    },
    {
        {"from_collapse_limit", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Sets the FROM-list size beyond which subqueries "
                         "are not collapsed."),
            gettext_noop("The planner will merge subqueries into upper "
                         "queries if the resulting FROM list would have no more than "
                         "this many items."),
            GUC_EXPLAIN
        },
        &from_collapse_limit,
        8, 1, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"join_collapse_limit", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Sets the FROM-list size beyond which JOIN "
                         "constructs are not flattened."),
            gettext_noop("The planner will flatten explicit JOIN "
                         "constructs into lists of FROM items whenever a "
                         "list of no more than this many items would result."),
            GUC_EXPLAIN
        },
        &join_collapse_limit,
        8, 1, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"geqo_threshold", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("Sets the threshold of FROM items beyond which GEQO is used."),
            NULL,
            GUC_EXPLAIN
        },
        &geqo_threshold,
        12, 2, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"geqo_effort", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("GEQO: effort is used to set the default for other GEQO parameters."),
            NULL,
            GUC_EXPLAIN
        },
        &Geqo_effort,
        DEFAULT_GEQO_EFFORT, MIN_GEQO_EFFORT, MAX_GEQO_EFFORT,
        NULL, NULL, NULL
    },
    {
        {"geqo_pool_size", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("GEQO: number of individuals in the population."),
            gettext_noop("Zero selects a suitable default value."),
            GUC_EXPLAIN
        },
        &Geqo_pool_size,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"geqo_generations", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("GEQO: number of iterations of the algorithm."),
            gettext_noop("Zero selects a suitable default value."),
            GUC_EXPLAIN
        },
        &Geqo_generations,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        /* This is PGC_SUSET to prevent hiding from log_lock_waits. */
        {"deadlock_timeout", PGC_SUSET, LOCK_MANAGEMENT,
            gettext_noop("Sets the time to wait on a lock before checking for deadlock."),
            NULL,
            GUC_UNIT_MS
        },
        &DeadlockTimeout,
        1000, 1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"max_standby_archive_delay", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the maximum delay before canceling queries when a hot standby server is processing archived WAL data."),
            NULL,
            GUC_UNIT_MS
        },
        &max_standby_archive_delay,
        30 * 1000, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"max_standby_streaming_delay", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the maximum delay before canceling queries when a hot standby server is processing streamed WAL data."),
            NULL,
            GUC_UNIT_MS
        },
        &max_standby_streaming_delay,
        30 * 1000, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"recovery_min_apply_delay", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the minimum delay for applying changes during recovery."),
            NULL,
            GUC_UNIT_MS
        },
        &recovery_min_apply_delay,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"wal_receiver_status_interval", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the maximum interval between WAL receiver status reports to the sending server."),
            NULL,
            GUC_UNIT_S
        },
        &wal_receiver_status_interval,
        10, 0, INT_MAX / 1000,
        NULL, NULL, NULL
    },
 
    {
        {"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the maximum wait time to receive data from the sending server."),
            NULL,
            GUC_UNIT_MS
        },
        &wal_receiver_timeout,
        60 * 1000, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"max_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the maximum number of concurrent connections."),
            NULL
        },
        &MaxConnections,
        100, 1, MAX_BACKENDS,
        check_maxconnections, NULL, NULL
    },
 
    {
        /* see max_connections */
        {"superuser_reserved_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the number of connection slots reserved for superusers."),
            NULL
        },
        &ReservedBackends,
        3, 0, MAX_BACKENDS,
        NULL, NULL, NULL
    },
 
    {
        {"min_dynamic_shared_memory", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("Amount of dynamic shared memory reserved at startup."),
            NULL,
            GUC_UNIT_MB
        },
        &min_dynamic_shared_memory,
        0, 0, (int) Min((size_t) INT_MAX, SIZE_MAX / (1024 * 1024)),
        NULL, NULL, NULL
    },
 
    /*
     * We sometimes multiply the number of shared buffers by two without
     * checking for overflow, so we mustn't allow more than INT_MAX / 2.
     */
    {
        {"shared_buffers", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("Sets the number of shared memory buffers used by the server."),
            NULL,
            GUC_UNIT_BLOCKS
        },
        &NBuffers,
        16384, 16, INT_MAX / 2,
        NULL, NULL, NULL
    },
 
    {
        {"shared_memory_size", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the size of the server's main shared memory area (rounded up to the nearest MB)."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_UNIT_MB | GUC_RUNTIME_COMPUTED
        },
        &shared_memory_size_mb,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"shared_memory_size_in_huge_pages", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the number of huge pages needed for the main shared memory area."),
            gettext_noop("-1 indicates that the value could not be determined."),
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
        },
        &shared_memory_size_in_huge_pages,
        -1, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"temp_buffers", PGC_USERSET, RESOURCES_MEM,
            gettext_noop("Sets the maximum number of temporary buffers used by each session."),
            NULL,
            GUC_UNIT_BLOCKS | GUC_EXPLAIN
        },
        &num_temp_buffers,
        1024, 100, INT_MAX / 2,
        check_temp_buffers, NULL, NULL
    },
 
    {
        {"port", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the TCP port the server listens on."),
            NULL
        },
        &PostPortNumber,
        DEF_PGPORT, 1, 65535,
        NULL, NULL, NULL
    },
 
    {
        {"unix_socket_permissions", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the access permissions of the Unix-domain socket."),
            gettext_noop("Unix-domain sockets use the usual Unix file system "
                         "permission set. The parameter value is expected "
                         "to be a numeric mode specification in the form "
                         "accepted by the chmod and umask system calls. "
                         "(To use the customary octal format the number must "
                         "start with a 0 (zero).)")
        },
        &Unix_socket_permissions,
        0777, 0000, 0777,
        NULL, NULL, show_unix_socket_permissions
    },
 
    {
        {"log_file_mode", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the file permissions for log files."),
            gettext_noop("The parameter value is expected "
                         "to be a numeric mode specification in the form "
                         "accepted by the chmod and umask system calls. "
                         "(To use the customary octal format the number must "
                         "start with a 0 (zero).)")
        },
        &Log_file_mode,
        0600, 0000, 0777,
        NULL, NULL, show_log_file_mode
    },
 
 
    {
        {"data_directory_mode", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the mode of the data directory."),
            gettext_noop("The parameter value is a numeric mode specification "
                         "in the form accepted by the chmod and umask system "
                         "calls. (To use the customary octal format the number "
                         "must start with a 0 (zero).)"),
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
        },
        &data_directory_mode,
        0700, 0000, 0777,
        NULL, NULL, show_data_directory_mode
    },
 
    {
        {"work_mem", PGC_USERSET, RESOURCES_MEM,
            gettext_noop("Sets the maximum memory to be used for query workspaces."),
            gettext_noop("This much memory can be used by each internal "
                         "sort operation and hash table before switching to "
                         "temporary disk files."),
            GUC_UNIT_KB | GUC_EXPLAIN
        },
        &work_mem,
        4096, 64, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"maintenance_work_mem", PGC_USERSET, RESOURCES_MEM,
            gettext_noop("Sets the maximum memory to be used for maintenance operations."),
            gettext_noop("This includes operations such as VACUUM and CREATE INDEX."),
            GUC_UNIT_KB
        },
        &maintenance_work_mem,
        65536, 1024, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"logical_decoding_work_mem", PGC_USERSET, RESOURCES_MEM,
            gettext_noop("Sets the maximum memory to be used for logical decoding."),
            gettext_noop("This much memory can be used by each internal "
                         "reorder buffer before spilling to disk."),
            GUC_UNIT_KB
        },
        &logical_decoding_work_mem,
        65536, 64, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    /*
     * We use the hopefully-safely-small value of 100kB as the compiled-in
     * default for max_stack_depth.  InitializeGUCOptions will increase it if
     * possible, depending on the actual platform-specific stack limit.
     */
    {
        {"max_stack_depth", PGC_SUSET, RESOURCES_MEM,
            gettext_noop("Sets the maximum stack depth, in kilobytes."),
            NULL,
            GUC_UNIT_KB
        },
        &max_stack_depth,
        100, 100, MAX_KILOBYTES,
        check_max_stack_depth, assign_max_stack_depth, NULL
    },
 
    {
        {"temp_file_limit", PGC_SUSET, RESOURCES_DISK,
            gettext_noop("Limits the total size of all temporary files used by each process."),
            gettext_noop("-1 means no limit."),
            GUC_UNIT_KB
        },
        &temp_file_limit,
        -1, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_cost_page_hit", PGC_USERSET, RESOURCES_VACUUM_DELAY,
            gettext_noop("Vacuum cost for a page found in the buffer cache."),
            NULL
        },
        &VacuumCostPageHit,
        1, 0, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_cost_page_miss", PGC_USERSET, RESOURCES_VACUUM_DELAY,
            gettext_noop("Vacuum cost for a page not found in the buffer cache."),
            NULL
        },
        &VacuumCostPageMiss,
        2, 0, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_cost_page_dirty", PGC_USERSET, RESOURCES_VACUUM_DELAY,
            gettext_noop("Vacuum cost for a page dirtied by vacuum."),
            NULL
        },
        &VacuumCostPageDirty,
        20, 0, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_cost_limit", PGC_USERSET, RESOURCES_VACUUM_DELAY,
            gettext_noop("Vacuum cost amount available before napping."),
            NULL
        },
        &VacuumCostLimit,
        200, 1, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_vacuum_cost_limit", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Vacuum cost amount available before napping, for autovacuum."),
            NULL
        },
        &autovacuum_vac_cost_limit,
        -1, -1, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"max_files_per_process", PGC_POSTMASTER, RESOURCES_KERNEL,
            gettext_noop("Sets the maximum number of simultaneously open files for each server process."),
            NULL
        },
        &max_files_per_process,
        1000, 64, INT_MAX,
        NULL, NULL, NULL
    },
 
    /*
     * See also CheckRequiredParameterValues() if this parameter changes
     */
    {
        {"max_prepared_transactions", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("Sets the maximum number of simultaneously prepared transactions."),
            NULL
        },
        &max_prepared_xacts,
        0, 0, MAX_BACKENDS,
        NULL, NULL, NULL
    },
 
#ifdef LOCK_DEBUG
    {
        {"trace_lock_oidmin", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Sets the minimum OID of tables for tracking locks."),
            gettext_noop("Is used to avoid output on system tables."),
            GUC_NOT_IN_SAMPLE
        },
        &Trace_lock_oidmin,
        FirstNormalObjectId, 0, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"trace_lock_table", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Sets the OID of the table with unconditionally lock tracing."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &Trace_lock_table,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
#endif
 
    {
        {"statement_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the maximum allowed duration of any statement."),
            gettext_noop("A value of 0 turns off the timeout."),
            GUC_UNIT_MS
        },
        &StatementTimeout,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"lock_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the maximum allowed duration of any wait for a lock."),
            gettext_noop("A value of 0 turns off the timeout."),
            GUC_UNIT_MS
        },
        &LockTimeout,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"idle_in_transaction_session_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the maximum allowed idle time between queries, when in a transaction."),
            gettext_noop("A value of 0 turns off the timeout."),
            GUC_UNIT_MS
        },
        &IdleInTransactionSessionTimeout,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"idle_session_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the maximum allowed idle time between queries, when not in a transaction."),
            gettext_noop("A value of 0 turns off the timeout."),
            GUC_UNIT_MS
        },
        &IdleSessionTimeout,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Minimum age at which VACUUM should freeze a table row."),
            NULL
        },
        &vacuum_freeze_min_age,
        50000000, 0, 1000000000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
            NULL
        },
        &vacuum_freeze_table_age,
        150000000, 0, 2000000000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
            NULL
        },
        &vacuum_multixact_freeze_min_age,
        5000000, 0, 1000000000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
            NULL
        },
        &vacuum_multixact_freeze_table_age,
        150000000, 0, 2000000000,
        NULL, NULL, NULL
    },
 
    {
        {"vacuum_defer_cleanup_age", PGC_SIGHUP, REPLICATION_PRIMARY,
            gettext_noop("Number of transactions by which VACUUM and HOT cleanup should be deferred, if any."),
            NULL
        },
        &vacuum_defer_cleanup_age,
        0, 0, 1000000,          /* see ComputeXidHorizons */
        NULL, NULL, NULL
    },
    {
        {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
            NULL
        },
        &vacuum_failsafe_age,
        1600000000, 0, 2100000000,
        NULL, NULL, NULL
    },
    {
        {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
            NULL
        },
        &vacuum_multixact_failsafe_age,
        1600000000, 0, 2100000000,
        NULL, NULL, NULL
    },
 
    /*
     * See also CheckRequiredParameterValues() if this parameter changes
     */
    {
        {"max_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
            gettext_noop("Sets the maximum number of locks per transaction."),
            gettext_noop("The shared lock table is sized on the assumption that "
                         "at most max_locks_per_transaction * max_connections distinct "
                         "objects will need to be locked at any one time.")
        },
        &max_locks_per_xact,
        64, 10, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"max_pred_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
            gettext_noop("Sets the maximum number of predicate locks per transaction."),
            gettext_noop("The shared predicate lock table is sized on the assumption that "
                         "at most max_pred_locks_per_transaction * max_connections distinct "
                         "objects will need to be locked at any one time.")
        },
        &max_predicate_locks_per_xact,
        64, 10, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"max_pred_locks_per_relation", PGC_SIGHUP, LOCK_MANAGEMENT,
            gettext_noop("Sets the maximum number of predicate-locked pages and tuples per relation."),
            gettext_noop("If more than this total of pages and tuples in the same relation are locked "
                         "by a connection, those locks are replaced by a relation-level lock.")
        },
        &max_predicate_locks_per_relation,
        -2, INT_MIN, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"max_pred_locks_per_page", PGC_SIGHUP, LOCK_MANAGEMENT,
            gettext_noop("Sets the maximum number of predicate-locked tuples per page."),
            gettext_noop("If more than this number of tuples on the same page are locked "
                         "by a connection, those locks are replaced by a page-level lock.")
        },
        &max_predicate_locks_per_page,
        2, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"authentication_timeout", PGC_SIGHUP, CONN_AUTH_AUTH,
            gettext_noop("Sets the maximum allowed time to complete client authentication."),
            NULL,
            GUC_UNIT_S
        },
        &AuthenticationTimeout,
        60, 1, 600,
        NULL, NULL, NULL
    },
 
    {
        /* Not for general use */
        {"pre_auth_delay", PGC_SIGHUP, DEVELOPER_OPTIONS,
            gettext_noop("Sets the amount of time to wait before "
                         "authentication on connection startup."),
            gettext_noop("This allows attaching a debugger to the process."),
            GUC_NOT_IN_SAMPLE | GUC_UNIT_S
        },
        &PreAuthDelay,
        0, 0, 60,
        NULL, NULL, NULL
    },
 
    {
        {"wal_decode_buffer_size", PGC_POSTMASTER, WAL_RECOVERY,
            gettext_noop("Maximum buffer size for reading ahead in the WAL during recovery."),
            gettext_noop("This controls the maximum distance we can read ahead in the WAL to prefetch referenced blocks."),
            GUC_UNIT_BYTE
        },
        &wal_decode_buffer_size,
        512 * 1024, 64 * 1024, MaxAllocSize,
        NULL, NULL, NULL
    },
 
    {
        {"wal_keep_size", PGC_SIGHUP, REPLICATION_SENDING,
            gettext_noop("Sets the size of WAL files held for standby servers."),
            NULL,
            GUC_UNIT_MB
        },
        &wal_keep_size_mb,
        0, 0, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"min_wal_size", PGC_SIGHUP, WAL_CHECKPOINTS,
            gettext_noop("Sets the minimum size to shrink the WAL to."),
            NULL,
            GUC_UNIT_MB
        },
        &min_wal_size_mb,
        DEFAULT_MIN_WAL_SEGS * (DEFAULT_XLOG_SEG_SIZE / (1024 * 1024)),
        2, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"max_wal_size", PGC_SIGHUP, WAL_CHECKPOINTS,
            gettext_noop("Sets the WAL size that triggers a checkpoint."),
            NULL,
            GUC_UNIT_MB
        },
        &max_wal_size_mb,
        DEFAULT_MAX_WAL_SEGS * (DEFAULT_XLOG_SEG_SIZE / (1024 * 1024)),
        2, MAX_KILOBYTES,
        NULL, assign_max_wal_size, NULL
    },
 
    {
        {"checkpoint_timeout", PGC_SIGHUP, WAL_CHECKPOINTS,
            gettext_noop("Sets the maximum time between automatic WAL checkpoints."),
            NULL,
            GUC_UNIT_S
        },
        &CheckPointTimeout,
        300, 30, 86400,
        NULL, NULL, NULL
    },
 
    {
        {"checkpoint_warning", PGC_SIGHUP, WAL_CHECKPOINTS,
            gettext_noop("Sets the maximum time before warning if checkpoints "
                         "triggered by WAL volume happen too frequently."),
            gettext_noop("Write a message to the server log if checkpoints "
                         "caused by the filling of WAL segment files happen more "
                         "frequently than this amount of time. "
                         "Zero turns off the warning."),
            GUC_UNIT_S
        },
        &CheckPointWarning,
        30, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"checkpoint_flush_after", PGC_SIGHUP, WAL_CHECKPOINTS,
            gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
            NULL,
            GUC_UNIT_BLOCKS
        },
        &checkpoint_flush_after,
        DEFAULT_CHECKPOINT_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
        NULL, NULL, NULL
    },
 
    {
        {"wal_buffers", PGC_POSTMASTER, WAL_SETTINGS,
            gettext_noop("Sets the number of disk-page buffers in shared memory for WAL."),
            NULL,
            GUC_UNIT_XBLOCKS
        },
        &XLOGbuffers,
        -1, -1, (INT_MAX / XLOG_BLCKSZ),
        check_wal_buffers, NULL, NULL
    },
 
    {
        {"wal_writer_delay", PGC_SIGHUP, WAL_SETTINGS,
            gettext_noop("Time between WAL flushes performed in the WAL writer."),
            NULL,
            GUC_UNIT_MS
        },
        &WalWriterDelay,
        200, 1, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"wal_writer_flush_after", PGC_SIGHUP, WAL_SETTINGS,
            gettext_noop("Amount of WAL written out by WAL writer that triggers a flush."),
            NULL,
            GUC_UNIT_XBLOCKS
        },
        &WalWriterFlushAfter,
        (1024 * 1024) / XLOG_BLCKSZ, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"wal_skip_threshold", PGC_USERSET, WAL_SETTINGS,
            gettext_noop("Minimum size of new file to fsync instead of writing WAL."),
            NULL,
            GUC_UNIT_KB
        },
        &wal_skip_threshold,
        2048, 0, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"max_wal_senders", PGC_POSTMASTER, REPLICATION_SENDING,
            gettext_noop("Sets the maximum number of simultaneously running WAL sender processes."),
            NULL
        },
        &max_wal_senders,
        10, 0, MAX_BACKENDS,
        check_max_wal_senders, NULL, NULL
    },
 
    {
        /* see max_wal_senders */
        {"max_replication_slots", PGC_POSTMASTER, REPLICATION_SENDING,
            gettext_noop("Sets the maximum number of simultaneously defined replication slots."),
            NULL
        },
        &max_replication_slots,
        10, 0, MAX_BACKENDS /* XXX? */ ,
        NULL, NULL, NULL
    },
 
    {
        {"max_slot_wal_keep_size", PGC_SIGHUP, REPLICATION_SENDING,
            gettext_noop("Sets the maximum WAL size that can be reserved by replication slots."),
            gettext_noop("Replication slots will be marked as failed, and segments released "
                         "for deletion or recycling, if this much space is occupied by WAL "
                         "on disk."),
            GUC_UNIT_MB
        },
        &max_slot_wal_keep_size_mb,
        -1, -1, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"wal_sender_timeout", PGC_USERSET, REPLICATION_SENDING,
            gettext_noop("Sets the maximum time to wait for WAL replication."),
            NULL,
            GUC_UNIT_MS
        },
        &wal_sender_timeout,
        60 * 1000, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"commit_delay", PGC_SUSET, WAL_SETTINGS,
            gettext_noop("Sets the delay in microseconds between transaction commit and "
                         "flushing WAL to disk."),
            NULL
            /* we have no microseconds designation, so can't supply units here */
        },
        &CommitDelay,
        0, 0, 100000,
        NULL, NULL, NULL
    },
 
    {
        {"commit_siblings", PGC_USERSET, WAL_SETTINGS,
            gettext_noop("Sets the minimum number of concurrent open transactions "
                         "required before performing commit_delay."),
            NULL
        },
        &CommitSiblings,
        5, 0, 1000,
        NULL, NULL, NULL
    },
 
    {
        {"extra_float_digits", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the number of digits displayed for floating-point values."),
            gettext_noop("This affects real, double precision, and geometric data types. "
                         "A zero or negative parameter value is added to the standard "
                         "number of digits (FLT_DIG or DBL_DIG as appropriate). "
                         "Any value greater than zero selects precise output mode.")
        },
        &extra_float_digits,
        1, -15, 3,
        NULL, NULL, NULL
    },
 
    {
        {"log_min_duration_sample", PGC_SUSET, LOGGING_WHEN,
            gettext_noop("Sets the minimum execution time above which "
                         "a sample of statements will be logged."
                         " Sampling is determined by log_statement_sample_rate."),
            gettext_noop("Zero logs a sample of all queries. -1 turns this feature off."),
            GUC_UNIT_MS
        },
        &log_min_duration_sample,
        -1, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"log_min_duration_statement", PGC_SUSET, LOGGING_WHEN,
            gettext_noop("Sets the minimum execution time above which "
                         "all statements will be logged."),
            gettext_noop("Zero prints all queries. -1 turns this feature off."),
            GUC_UNIT_MS
        },
        &log_min_duration_statement,
        -1, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"log_autovacuum_min_duration", PGC_SIGHUP, LOGGING_WHAT,
            gettext_noop("Sets the minimum execution time above which "
                         "autovacuum actions will be logged."),
            gettext_noop("Zero prints all actions. -1 turns autovacuum logging off."),
            GUC_UNIT_MS
        },
        &Log_autovacuum_min_duration,
        600000, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"log_parameter_max_length", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Sets the maximum length in bytes of data logged for bind "
                         "parameter values when logging statements."),
            gettext_noop("-1 to print values in full."),
            GUC_UNIT_BYTE
        },
        &log_parameter_max_length,
        -1, -1, INT_MAX / 2,
        NULL, NULL, NULL
    },
 
    {
        {"log_parameter_max_length_on_error", PGC_USERSET, LOGGING_WHAT,
            gettext_noop("Sets the maximum length in bytes of data logged for bind "
                         "parameter values when logging statements, on error."),
            gettext_noop("-1 to print values in full."),
            GUC_UNIT_BYTE
        },
        &log_parameter_max_length_on_error,
        0, -1, INT_MAX / 2,
        NULL, NULL, NULL
    },
 
    {
        {"bgwriter_delay", PGC_SIGHUP, RESOURCES_BGWRITER,
            gettext_noop("Background writer sleep time between rounds."),
            NULL,
            GUC_UNIT_MS
        },
        &BgWriterDelay,
        200, 10, 10000,
        NULL, NULL, NULL
    },
 
    {
        {"bgwriter_lru_maxpages", PGC_SIGHUP, RESOURCES_BGWRITER,
            gettext_noop("Background writer maximum number of LRU pages to flush per round."),
            NULL
        },
        &bgwriter_lru_maxpages,
        100, 0, INT_MAX / 2,    /* Same upper limit as shared_buffers */
        NULL, NULL, NULL
    },
 
    {
        {"bgwriter_flush_after", PGC_SIGHUP, RESOURCES_BGWRITER,
            gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
            NULL,
            GUC_UNIT_BLOCKS
        },
        &bgwriter_flush_after,
        DEFAULT_BGWRITER_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
        NULL, NULL, NULL
    },
 
    {
        {"effective_io_concurrency",
            PGC_USERSET,
            RESOURCES_ASYNCHRONOUS,
            gettext_noop("Number of simultaneous requests that can be handled efficiently by the disk subsystem."),
            NULL,
            GUC_EXPLAIN
        },
        &effective_io_concurrency,
#ifdef USE_PREFETCH
        1,
#else
        0,
#endif
        0, MAX_IO_CONCURRENCY,
        check_effective_io_concurrency, NULL, NULL
    },
 
    {
        {"maintenance_io_concurrency",
            PGC_USERSET,
            RESOURCES_ASYNCHRONOUS,
            gettext_noop("A variant of effective_io_concurrency that is used for maintenance work."),
            NULL,
            GUC_EXPLAIN
        },
        &maintenance_io_concurrency,
#ifdef USE_PREFETCH
        10,
#else
        0,
#endif
        0, MAX_IO_CONCURRENCY,
        check_maintenance_io_concurrency, assign_maintenance_io_concurrency,
        NULL
    },
 
    {
        {"backend_flush_after", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
            gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
            NULL,
            GUC_UNIT_BLOCKS
        },
        &backend_flush_after,
        DEFAULT_BACKEND_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
        NULL, NULL, NULL
    },
 
    {
        {"max_worker_processes",
            PGC_POSTMASTER,
            RESOURCES_ASYNCHRONOUS,
            gettext_noop("Maximum number of concurrent worker processes."),
            NULL,
        },
        &max_worker_processes,
        8, 0, MAX_BACKENDS,
        check_max_worker_processes, NULL, NULL
    },
 
    {
        {"max_logical_replication_workers",
            PGC_POSTMASTER,
            REPLICATION_SUBSCRIBERS,
            gettext_noop("Maximum number of logical replication worker processes."),
            NULL,
        },
        &max_logical_replication_workers,
        4, 0, MAX_BACKENDS,
        NULL, NULL, NULL
    },
 
    {
        {"max_sync_workers_per_subscription",
            PGC_SIGHUP,
            REPLICATION_SUBSCRIBERS,
            gettext_noop("Maximum number of table synchronization workers per subscription."),
            NULL,
        },
        &max_sync_workers_per_subscription,
        2, 0, MAX_BACKENDS,
        NULL, NULL, NULL
    },
 
    {
        {"log_rotation_age", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the amount of time to wait before forcing "
                         "log file rotation."),
            NULL,
            GUC_UNIT_MIN
        },
        &Log_RotationAge,
        HOURS_PER_DAY * MINS_PER_HOUR, 0, INT_MAX / SECS_PER_MINUTE,
        NULL, NULL, NULL
    },
 
    {
        {"log_rotation_size", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the maximum size a log file can reach before "
                         "being rotated."),
            NULL,
            GUC_UNIT_KB
        },
        &Log_RotationSize,
        10 * 1024, 0, INT_MAX / 1024,
        NULL, NULL, NULL
    },
 
    {
        {"max_function_args", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the maximum number of function arguments."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &max_function_args,
        FUNC_MAX_ARGS, FUNC_MAX_ARGS, FUNC_MAX_ARGS,
        NULL, NULL, NULL
    },
 
    {
        {"max_index_keys", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the maximum number of index keys."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &max_index_keys,
        INDEX_MAX_KEYS, INDEX_MAX_KEYS, INDEX_MAX_KEYS,
        NULL, NULL, NULL
    },
 
    {
        {"max_identifier_length", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the maximum identifier length."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &max_identifier_length,
        NAMEDATALEN - 1, NAMEDATALEN - 1, NAMEDATALEN - 1,
        NULL, NULL, NULL
    },
 
    {
        {"block_size", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the size of a disk block."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &block_size,
        BLCKSZ, BLCKSZ, BLCKSZ,
        NULL, NULL, NULL
    },
 
    {
        {"segment_size", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the number of pages per disk file."),
            NULL,
            GUC_UNIT_BLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &segment_size,
        RELSEG_SIZE, RELSEG_SIZE, RELSEG_SIZE,
        NULL, NULL, NULL
    },
 
    {
        {"wal_block_size", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the block size in the write ahead log."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &wal_block_size,
        XLOG_BLCKSZ, XLOG_BLCKSZ, XLOG_BLCKSZ,
        NULL, NULL, NULL
    },
 
    {
        {"wal_retrieve_retry_interval", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the time to wait before retrying to retrieve WAL "
                         "after a failed attempt."),
            NULL,
            GUC_UNIT_MS
        },
        &wal_retrieve_retry_interval,
        5000, 1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"wal_segment_size", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the size of write ahead log segments."),
            NULL,
            GUC_UNIT_BYTE | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
        },
        &wal_segment_size,
        DEFAULT_XLOG_SEG_SIZE,
        WalSegMinSize,
        WalSegMaxSize,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_naptime", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Time to sleep between autovacuum runs."),
            NULL,
            GUC_UNIT_S
        },
        &autovacuum_naptime,
        60, 1, INT_MAX / 1000,
        NULL, NULL, NULL
    },
    {
        {"autovacuum_vacuum_threshold", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Minimum number of tuple updates or deletes prior to vacuum."),
            NULL
        },
        &autovacuum_vac_thresh,
        50, 0, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"autovacuum_vacuum_insert_threshold", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums."),
            NULL
        },
        &autovacuum_vac_ins_thresh,
        1000, -1, INT_MAX,
        NULL, NULL, NULL
    },
    {
        {"autovacuum_analyze_threshold", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Minimum number of tuple inserts, updates, or deletes prior to analyze."),
            NULL
        },
        &autovacuum_anl_thresh,
        50, 0, INT_MAX,
        NULL, NULL, NULL
    },
    {
        /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
        {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
            gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
            NULL
        },
        &autovacuum_freeze_max_age,
 
        /* see vacuum_failsafe_age if you change the upper-limit value. */
        200000000, 100000, 2000000000,
        NULL, NULL, NULL
    },
    {
        /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
        {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
            gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
            NULL
        },
        &autovacuum_multixact_freeze_max_age,
        400000000, 10000, 2000000000,
        NULL, NULL, NULL
    },
    {
        /* see max_connections */
        {"autovacuum_max_workers", PGC_POSTMASTER, AUTOVACUUM,
            gettext_noop("Sets the maximum number of simultaneously running autovacuum worker processes."),
            NULL
        },
        &autovacuum_max_workers,
        3, 1, MAX_BACKENDS,
        check_autovacuum_max_workers, NULL, NULL
    },
 
    {
        {"max_parallel_maintenance_workers", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
            gettext_noop("Sets the maximum number of parallel processes per maintenance operation."),
            NULL
        },
        &max_parallel_maintenance_workers,
        2, 0, 1024,
        NULL, NULL, NULL
    },
 
    {
        {"max_parallel_workers_per_gather", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
            gettext_noop("Sets the maximum number of parallel processes per executor node."),
            NULL,
            GUC_EXPLAIN
        },
        &max_parallel_workers_per_gather,
        2, 0, MAX_PARALLEL_WORKER_LIMIT,
        NULL, NULL, NULL
    },
 
    {
        {"max_parallel_workers", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
            gettext_noop("Sets the maximum number of parallel workers that can be active at one time."),
            NULL,
            GUC_EXPLAIN
        },
        &max_parallel_workers,
        8, 0, MAX_PARALLEL_WORKER_LIMIT,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_work_mem", PGC_SIGHUP, RESOURCES_MEM,
            gettext_noop("Sets the maximum memory to be used by each autovacuum worker process."),
            NULL,
            GUC_UNIT_KB
        },
        &autovacuum_work_mem,
        -1, -1, MAX_KILOBYTES,
        check_autovacuum_work_mem, NULL, NULL
    },
 
    {
        {"old_snapshot_threshold", PGC_POSTMASTER, RESOURCES_ASYNCHRONOUS,
            gettext_noop("Time before a snapshot is too old to read pages changed after the snapshot was taken."),
            gettext_noop("A value of -1 disables this feature."),
            GUC_UNIT_MIN
        },
        &old_snapshot_threshold,
        -1, -1, MINS_PER_HOUR * HOURS_PER_DAY * 60,
        NULL, NULL, NULL
    },
 
    {
        {"tcp_keepalives_idle", PGC_USERSET, CONN_AUTH_SETTINGS,
            gettext_noop("Time between issuing TCP keepalives."),
            gettext_noop("A value of 0 uses the system default."),
            GUC_UNIT_S
        },
        &tcp_keepalives_idle,
        0, 0, INT_MAX,
        NULL, assign_tcp_keepalives_idle, show_tcp_keepalives_idle
    },
 
    {
        {"tcp_keepalives_interval", PGC_USERSET, CONN_AUTH_SETTINGS,
            gettext_noop("Time between TCP keepalive retransmits."),
            gettext_noop("A value of 0 uses the system default."),
            GUC_UNIT_S
        },
        &tcp_keepalives_interval,
        0, 0, INT_MAX,
        NULL, assign_tcp_keepalives_interval, show_tcp_keepalives_interval
    },
 
    {
        {"ssl_renegotiation_limit", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("SSL renegotiation is no longer supported; this can only be 0."),
            NULL,
            GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE,
        },
        &ssl_renegotiation_limit,
        0, 0, 0,
        NULL, NULL, NULL
    },
 
    {
        {"tcp_keepalives_count", PGC_USERSET, CONN_AUTH_SETTINGS,
            gettext_noop("Maximum number of TCP keepalive retransmits."),
            gettext_noop("This controls the number of consecutive keepalive retransmits that can be "
                         "lost before a connection is considered dead. A value of 0 uses the "
                         "system default."),
        },
        &tcp_keepalives_count,
        0, 0, INT_MAX,
        NULL, assign_tcp_keepalives_count, show_tcp_keepalives_count
    },
 
    {
        {"gin_fuzzy_search_limit", PGC_USERSET, CLIENT_CONN_OTHER,
            gettext_noop("Sets the maximum allowed result for exact search by GIN."),
            NULL,
            0
        },
        &GinFuzzySearchLimit,
        0, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"effective_cache_size", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's assumption about the total size of the data caches."),
            gettext_noop("That is, the total size of the caches (kernel cache and shared buffers) used for PostgreSQL data files. "
                         "This is measured in disk pages, which are normally 8 kB each."),
            GUC_UNIT_BLOCKS | GUC_EXPLAIN,
        },
        &effective_cache_size,
        DEFAULT_EFFECTIVE_CACHE_SIZE, 1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"min_parallel_table_scan_size", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the minimum amount of table data for a parallel scan."),
            gettext_noop("If the planner estimates that it will read a number of table pages too small to reach this limit, a parallel scan will not be considered."),
            GUC_UNIT_BLOCKS | GUC_EXPLAIN,
        },
        &min_parallel_table_scan_size,
        (8 * 1024 * 1024) / BLCKSZ, 0, INT_MAX / 3,
        NULL, NULL, NULL
    },
 
    {
        {"min_parallel_index_scan_size", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the minimum amount of index data for a parallel scan."),
            gettext_noop("If the planner estimates that it will read a number of index pages too small to reach this limit, a parallel scan will not be considered."),
            GUC_UNIT_BLOCKS | GUC_EXPLAIN,
        },
        &min_parallel_index_scan_size,
        (512 * 1024) / BLCKSZ, 0, INT_MAX / 3,
        NULL, NULL, NULL
    },
 
    {
        /* Can't be set in postgresql.conf */
        {"server_version_num", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the server version as an integer."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &server_version_num,
        PG_VERSION_NUM, PG_VERSION_NUM, PG_VERSION_NUM,
        NULL, NULL, NULL
    },
 
    {
        {"log_temp_files", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Log the use of temporary files larger than this number of kilobytes."),
            gettext_noop("Zero logs all files. The default is -1 (turning this feature off)."),
            GUC_UNIT_KB
        },
        &log_temp_files,
        -1, -1, INT_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"track_activity_query_size", PGC_POSTMASTER, STATS_CUMULATIVE,
            gettext_noop("Sets the size reserved for pg_stat_activity.query, in bytes."),
            NULL,
            GUC_UNIT_BYTE
        },
        &pgstat_track_activity_query_size,
        1024, 100, 1048576,
        NULL, NULL, NULL
    },
 
    {
        {"gin_pending_list_limit", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the maximum size of the pending list for GIN index."),
            NULL,
            GUC_UNIT_KB
        },
        &gin_pending_list_limit,
        4096, 64, MAX_KILOBYTES,
        NULL, NULL, NULL
    },
 
    {
        {"tcp_user_timeout", PGC_USERSET, CONN_AUTH_SETTINGS,
            gettext_noop("TCP user timeout."),
            gettext_noop("A value of 0 uses the system default."),
            GUC_UNIT_MS
        },
        &tcp_user_timeout,
        0, 0, INT_MAX,
        NULL, assign_tcp_user_timeout, show_tcp_user_timeout
    },
 
    {
        {"huge_page_size", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("The size of huge page that should be requested."),
            NULL,
            GUC_UNIT_KB
        },
        &huge_page_size,
        0, 0, INT_MAX,
        check_huge_page_size, NULL, NULL
    },
 
    {
        {"debug_discard_caches", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Aggressively flush system caches for debugging purposes."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &debug_discard_caches,
#ifdef DISCARD_CACHES_ENABLED
        /* Set default based on older compile-time-only cache clobber macros */
#if defined(CLOBBER_CACHE_RECURSIVELY)
        3,
#elif defined(CLOBBER_CACHE_ALWAYS)
        1,
#else
        0,
#endif
        0, 5,
#else                           /* not DISCARD_CACHES_ENABLED */
        0, 0, 0,
#endif                          /* not DISCARD_CACHES_ENABLED */
        NULL, NULL, NULL
    },
 
    {
        {"client_connection_check_interval", PGC_USERSET, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the time interval between checks for disconnection while running queries."),
            NULL,
            GUC_UNIT_MS
        },
        &client_connection_check_interval,
        0, 0, INT_MAX,
        check_client_connection_check_interval, NULL, NULL
    },
 
    {
        {"log_startup_progress_interval", PGC_SIGHUP, LOGGING_WHEN,
            gettext_noop("Time between progress updates for "
                         "long-running startup operations."),
            gettext_noop("0 turns this feature off."),
            GUC_UNIT_MS,
        },
        &log_startup_progress_interval,
        10000, 0, INT_MAX,
        NULL, NULL, NULL
    },
 
    /* End-of-list marker */
    {
        {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
    }
};
 
 
static struct config_real ConfigureNamesReal[] =
{
    {
        {"seq_page_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of a "
                         "sequentially fetched disk page."),
            NULL,
            GUC_EXPLAIN
        },
        &seq_page_cost,
        DEFAULT_SEQ_PAGE_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
    {
        {"random_page_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of a "
                         "nonsequentially fetched disk page."),
            NULL,
            GUC_EXPLAIN
        },
        &random_page_cost,
        DEFAULT_RANDOM_PAGE_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
    {
        {"cpu_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of "
                         "processing each tuple (row)."),
            NULL,
            GUC_EXPLAIN
        },
        &cpu_tuple_cost,
        DEFAULT_CPU_TUPLE_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
    {
        {"cpu_index_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of "
                         "processing each index entry during an index scan."),
            NULL,
            GUC_EXPLAIN
        },
        &cpu_index_tuple_cost,
        DEFAULT_CPU_INDEX_TUPLE_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
    {
        {"cpu_operator_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of "
                         "processing each operator or function call."),
            NULL,
            GUC_EXPLAIN
        },
        &cpu_operator_cost,
        DEFAULT_CPU_OPERATOR_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
    {
        {"parallel_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of "
                         "passing each tuple (row) from worker to leader backend."),
            NULL,
            GUC_EXPLAIN
        },
        &parallel_tuple_cost,
        DEFAULT_PARALLEL_TUPLE_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
    {
        {"parallel_setup_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Sets the planner's estimate of the cost of "
                         "starting up worker processes for parallel query."),
            NULL,
            GUC_EXPLAIN
        },
        &parallel_setup_cost,
        DEFAULT_PARALLEL_SETUP_COST, 0, DBL_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"jit_above_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Perform JIT compilation if query is more expensive."),
            gettext_noop("-1 disables JIT compilation."),
            GUC_EXPLAIN
        },
        &jit_above_cost,
        100000, -1, DBL_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"jit_optimize_above_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Optimize JIT-compiled functions if query is more expensive."),
            gettext_noop("-1 disables optimization."),
            GUC_EXPLAIN
        },
        &jit_optimize_above_cost,
        500000, -1, DBL_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"jit_inline_above_cost", PGC_USERSET, QUERY_TUNING_COST,
            gettext_noop("Perform JIT inlining if query is more expensive."),
            gettext_noop("-1 disables inlining."),
            GUC_EXPLAIN
        },
        &jit_inline_above_cost,
        500000, -1, DBL_MAX,
        NULL, NULL, NULL
    },
 
    {
        {"cursor_tuple_fraction", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Sets the planner's estimate of the fraction of "
                         "a cursor's rows that will be retrieved."),
            NULL,
            GUC_EXPLAIN
        },
        &cursor_tuple_fraction,
        DEFAULT_CURSOR_TUPLE_FRACTION, 0.0, 1.0,
        NULL, NULL, NULL
    },
 
    {
        {"recursive_worktable_factor", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Sets the planner's estimate of the average size "
                         "of a recursive query's working table."),
            NULL,
            GUC_EXPLAIN
        },
        &recursive_worktable_factor,
        DEFAULT_RECURSIVE_WORKTABLE_FACTOR, 0.001, 1000000.0,
        NULL, NULL, NULL
    },
 
    {
        {"geqo_selection_bias", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("GEQO: selective pressure within the population."),
            NULL,
            GUC_EXPLAIN
        },
        &Geqo_selection_bias,
        DEFAULT_GEQO_SELECTION_BIAS,
        MIN_GEQO_SELECTION_BIAS, MAX_GEQO_SELECTION_BIAS,
        NULL, NULL, NULL
    },
    {
        {"geqo_seed", PGC_USERSET, QUERY_TUNING_GEQO,
            gettext_noop("GEQO: seed for random path selection."),
            NULL,
            GUC_EXPLAIN
        },
        &Geqo_seed,
        0.0, 0.0, 1.0,
        NULL, NULL, NULL
    },
 
    {
        {"hash_mem_multiplier", PGC_USERSET, RESOURCES_MEM,
            gettext_noop("Multiple of work_mem to use for hash tables."),
            NULL,
            GUC_EXPLAIN
        },
        &hash_mem_multiplier,
        2.0, 1.0, 1000.0,
        NULL, NULL, NULL
    },
 
    {
        {"bgwriter_lru_multiplier", PGC_SIGHUP, RESOURCES_BGWRITER,
            gettext_noop("Multiple of the average buffer usage to free per round."),
            NULL
        },
        &bgwriter_lru_multiplier,
        2.0, 0.0, 10.0,
        NULL, NULL, NULL
    },
 
    {
        {"seed", PGC_USERSET, UNGROUPED,
            gettext_noop("Sets the seed for random-number generation."),
            NULL,
            GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &phony_random_seed,
        0.0, -1.0, 1.0,
        check_random_seed, assign_random_seed, show_random_seed
    },
 
    {
        {"vacuum_cost_delay", PGC_USERSET, RESOURCES_VACUUM_DELAY,
            gettext_noop("Vacuum cost delay in milliseconds."),
            NULL,
            GUC_UNIT_MS
        },
        &VacuumCostDelay,
        0, 0, 100,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_vacuum_cost_delay", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Vacuum cost delay in milliseconds, for autovacuum."),
            NULL,
            GUC_UNIT_MS
        },
        &autovacuum_vac_cost_delay,
        2, -1, 100,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_vacuum_scale_factor", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Number of tuple updates or deletes prior to vacuum as a fraction of reltuples."),
            NULL
        },
        &autovacuum_vac_scale,
        0.2, 0.0, 100.0,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_vacuum_insert_scale_factor", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Number of tuple inserts prior to vacuum as a fraction of reltuples."),
            NULL
        },
        &autovacuum_vac_ins_scale,
        0.2, 0.0, 100.0,
        NULL, NULL, NULL
    },
 
    {
        {"autovacuum_analyze_scale_factor", PGC_SIGHUP, AUTOVACUUM,
            gettext_noop("Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples."),
            NULL
        },
        &autovacuum_anl_scale,
        0.1, 0.0, 100.0,
        NULL, NULL, NULL
    },
 
    {
        {"checkpoint_completion_target", PGC_SIGHUP, WAL_CHECKPOINTS,
            gettext_noop("Time spent flushing dirty buffers during checkpoint, as fraction of checkpoint interval."),
            NULL
        },
        &CheckPointCompletionTarget,
        0.9, 0.0, 1.0,
        NULL, NULL, NULL
    },
 
    {
        {"log_statement_sample_rate", PGC_SUSET, LOGGING_WHEN,
            gettext_noop("Fraction of statements exceeding log_min_duration_sample to be logged."),
            gettext_noop("Use a value between 0.0 (never log) and 1.0 (always log).")
        },
        &log_statement_sample_rate,
        1.0, 0.0, 1.0,
        NULL, NULL, NULL
    },
 
    {
        {"log_transaction_sample_rate", PGC_SUSET, LOGGING_WHEN,
            gettext_noop("Sets the fraction of transactions from which to log all statements."),
            gettext_noop("Use a value between 0.0 (never log) and 1.0 (log all "
                         "statements for all transactions).")
        },
        &log_xact_sample_rate,
        0.0, 0.0, 1.0,
        NULL, NULL, NULL
    },
 
    /* End-of-list marker */
    {
        {NULL, 0, 0, NULL, NULL}, NULL, 0.0, 0.0, 0.0, NULL, NULL, NULL
    }
};
 
 
static struct config_string ConfigureNamesString[] =
{
    {
        {"archive_command", PGC_SIGHUP, WAL_ARCHIVING,
            gettext_noop("Sets the shell command that will be called to archive a WAL file."),
            gettext_noop("This is used only if \"archive_library\" is not set.")
        },
        &XLogArchiveCommand,
        "",
        NULL, NULL, show_archive_command
    },
 
    {
        {"archive_library", PGC_SIGHUP, WAL_ARCHIVING,
            gettext_noop("Sets the library that will be called to archive a WAL file."),
            gettext_noop("An empty string indicates that \"archive_command\" should be used.")
        },
        &XLogArchiveLibrary,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"restore_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
            gettext_noop("Sets the shell command that will be called to retrieve an archived WAL file."),
            NULL
        },
        &recoveryRestoreCommand,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"archive_cleanup_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
            gettext_noop("Sets the shell command that will be executed at every restart point."),
            NULL
        },
        &archiveCleanupCommand,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"recovery_end_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
            gettext_noop("Sets the shell command that will be executed once at the end of recovery."),
            NULL
        },
        &recoveryEndCommand,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"recovery_target_timeline", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Specifies the timeline to recover into."),
            NULL
        },
        &recovery_target_timeline_string,
        "latest",
        check_recovery_target_timeline, assign_recovery_target_timeline, NULL
    },
 
    {
        {"recovery_target", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Set to \"immediate\" to end recovery as soon as a consistent state is reached."),
            NULL
        },
        &recovery_target_string,
        "",
        check_recovery_target, assign_recovery_target, NULL
    },
    {
        {"recovery_target_xid", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Sets the transaction ID up to which recovery will proceed."),
            NULL
        },
        &recovery_target_xid_string,
        "",
        check_recovery_target_xid, assign_recovery_target_xid, NULL
    },
    {
        {"recovery_target_time", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Sets the time stamp up to which recovery will proceed."),
            NULL
        },
        &recovery_target_time_string,
        "",
        check_recovery_target_time, assign_recovery_target_time, NULL
    },
    {
        {"recovery_target_name", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Sets the named restore point up to which recovery will proceed."),
            NULL
        },
        &recovery_target_name_string,
        "",
        check_recovery_target_name, assign_recovery_target_name, NULL
    },
    {
        {"recovery_target_lsn", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Sets the LSN of the write-ahead log location up to which recovery will proceed."),
            NULL
        },
        &recovery_target_lsn_string,
        "",
        check_recovery_target_lsn, assign_recovery_target_lsn, NULL
    },
 
    {
        {"promote_trigger_file", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Specifies a file name whose presence ends recovery in the standby."),
            NULL
        },
        &PromoteTriggerFile,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"primary_conninfo", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the connection string to be used to connect to the sending server."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &PrimaryConnInfo,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"primary_slot_name", PGC_SIGHUP, REPLICATION_STANDBY,
            gettext_noop("Sets the name of the replication slot to use on the sending server."),
            NULL
        },
        &PrimarySlotName,
        "",
        check_primary_slot_name, NULL, NULL
    },
 
    {
        {"client_encoding", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the client's character set encoding."),
            NULL,
            GUC_IS_NAME | GUC_REPORT
        },
        &client_encoding_string,
        "SQL_ASCII",
        check_client_encoding, assign_client_encoding, NULL
    },
 
    {
        {"log_line_prefix", PGC_SIGHUP, LOGGING_WHAT,
            gettext_noop("Controls information prefixed to each log line."),
            gettext_noop("If blank, no prefix is used.")
        },
        &Log_line_prefix,
        "%m [%p] ",
        NULL, NULL, NULL
    },
 
    {
        {"log_timezone", PGC_SIGHUP, LOGGING_WHAT,
            gettext_noop("Sets the time zone to use in log messages."),
            NULL
        },
        &log_timezone_string,
        "GMT",
        check_log_timezone, assign_log_timezone, show_log_timezone
    },
 
    {
        {"DateStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the display format for date and time values."),
            gettext_noop("Also controls interpretation of ambiguous "
                         "date inputs."),
            GUC_LIST_INPUT | GUC_REPORT
        },
        &datestyle_string,
        "ISO, MDY",
        check_datestyle, assign_datestyle, NULL
    },
 
    {
        {"default_table_access_method", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the default table access method for new tables."),
            NULL,
            GUC_IS_NAME
        },
        &default_table_access_method,
        DEFAULT_TABLE_ACCESS_METHOD,
        check_default_table_access_method, NULL, NULL
    },
 
    {
        {"default_tablespace", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the default tablespace to create tables and indexes in."),
            gettext_noop("An empty string selects the database's default tablespace."),
            GUC_IS_NAME
        },
        &default_tablespace,
        "",
        check_default_tablespace, NULL, NULL
    },
 
    {
        {"temp_tablespaces", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the tablespace(s) to use for temporary tables and sort files."),
            NULL,
            GUC_LIST_INPUT | GUC_LIST_QUOTE
        },
        &temp_tablespaces,
        "",
        check_temp_tablespaces, assign_temp_tablespaces, NULL
    },
 
    {
        {"dynamic_library_path", PGC_SUSET, CLIENT_CONN_OTHER,
            gettext_noop("Sets the path for dynamically loadable modules."),
            gettext_noop("If a dynamically loadable module needs to be opened and "
                         "the specified name does not have a directory component (i.e., the "
                         "name does not contain a slash), the system will search this path for "
                         "the specified file."),
            GUC_SUPERUSER_ONLY
        },
        &Dynamic_library_path,
        "$libdir",
        NULL, NULL, NULL
    },
 
    {
        {"krb_server_keyfile", PGC_SIGHUP, CONN_AUTH_AUTH,
            gettext_noop("Sets the location of the Kerberos server key file."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &pg_krb_server_keyfile,
        PG_KRB_SRVTAB,
        NULL, NULL, NULL
    },
 
    {
        {"bonjour_name", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the Bonjour service name."),
            NULL
        },
        &bonjour_name,
        "",
        NULL, NULL, NULL
    },
 
    /* See main.c about why defaults for LC_foo are not all alike */
 
    {
        {"lc_collate", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the collation order locale."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &locale_collate,
        "C",
        NULL, NULL, NULL
    },
 
    {
        {"lc_ctype", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the character classification and case conversion locale."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &locale_ctype,
        "C",
        NULL, NULL, NULL
    },
 
    {
        {"lc_messages", PGC_SUSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the language in which messages are displayed."),
            NULL
        },
        &locale_messages,
        "",
        check_locale_messages, assign_locale_messages, NULL
    },
 
    {
        {"lc_monetary", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the locale for formatting monetary amounts."),
            NULL
        },
        &locale_monetary,
        "C",
        check_locale_monetary, assign_locale_monetary, NULL
    },
 
    {
        {"lc_numeric", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the locale for formatting numbers."),
            NULL
        },
        &locale_numeric,
        "C",
        check_locale_numeric, assign_locale_numeric, NULL
    },
 
    {
        {"lc_time", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the locale for formatting date and time values."),
            NULL
        },
        &locale_time,
        "C",
        check_locale_time, assign_locale_time, NULL
    },
 
    {
        {"session_preload_libraries", PGC_SUSET, CLIENT_CONN_PRELOAD,
            gettext_noop("Lists shared libraries to preload into each backend."),
            NULL,
            GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
        },
        &session_preload_libraries_string,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"shared_preload_libraries", PGC_POSTMASTER, CLIENT_CONN_PRELOAD,
            gettext_noop("Lists shared libraries to preload into server."),
            NULL,
            GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
        },
        &shared_preload_libraries_string,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"local_preload_libraries", PGC_USERSET, CLIENT_CONN_PRELOAD,
            gettext_noop("Lists unprivileged shared libraries to preload into each backend."),
            NULL,
            GUC_LIST_INPUT | GUC_LIST_QUOTE
        },
        &local_preload_libraries_string,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"search_path", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the schema search order for names that are not schema-qualified."),
            NULL,
            GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_EXPLAIN
        },
        &namespace_search_path,
        "\"$user\", public",
        check_search_path, assign_search_path, NULL
    },
 
    {
        /* Can't be set in postgresql.conf */
        {"server_encoding", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the server (database) character set encoding."),
            NULL,
            GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &server_encoding_string,
        "SQL_ASCII",
        NULL, NULL, NULL
    },
 
    {
        /* Can't be set in postgresql.conf */
        {"server_version", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the server version."),
            NULL,
            GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &server_version_string,
        PG_VERSION,
        NULL, NULL, NULL
    },
 
    {
        /* Not for general use --- used by SET ROLE */
        {"role", PGC_USERSET, UNGROUPED,
            gettext_noop("Sets the current role."),
            NULL,
            GUC_IS_NAME | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_NOT_WHILE_SEC_REST
        },
        &role_string,
        "none",
        check_role, assign_role, show_role
    },
 
    {
        /* Not for general use --- used by SET SESSION AUTHORIZATION */
        {"session_authorization", PGC_USERSET, UNGROUPED,
            gettext_noop("Sets the session user name."),
            NULL,
            GUC_IS_NAME | GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_NOT_WHILE_SEC_REST
        },
        &session_authorization_string,
        NULL,
        check_session_authorization, assign_session_authorization, NULL
    },
 
    {
        {"log_destination", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the destination for server log output."),
            gettext_noop("Valid values are combinations of \"stderr\", "
                         "\"syslog\", \"csvlog\", \"jsonlog\", and \"eventlog\", "
                         "depending on the platform."),
            GUC_LIST_INPUT
        },
        &Log_destination_string,
        "stderr",
        check_log_destination, assign_log_destination, NULL
    },
    {
        {"log_directory", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the destination directory for log files."),
            gettext_noop("Can be specified as relative to the data directory "
                         "or as absolute path."),
            GUC_SUPERUSER_ONLY
        },
        &Log_directory,
        "log",
        check_canonical_path, NULL, NULL
    },
    {
        {"log_filename", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the file name pattern for log files."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &Log_filename,
        "postgresql-%Y-%m-%d_%H%M%S.log",
        NULL, NULL, NULL
    },
 
    {
        {"syslog_ident", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the program name used to identify PostgreSQL "
                         "messages in syslog."),
            NULL
        },
        &syslog_ident_str,
        "postgres",
        NULL, assign_syslog_ident, NULL
    },
 
    {
        {"event_source", PGC_POSTMASTER, LOGGING_WHERE,
            gettext_noop("Sets the application name used to identify "
                         "PostgreSQL messages in the event log."),
            NULL
        },
        &event_source,
        DEFAULT_EVENT_SOURCE,
        NULL, NULL, NULL
    },
 
    {
        {"TimeZone", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the time zone for displaying and interpreting time stamps."),
            NULL,
            GUC_REPORT
        },
        &timezone_string,
        "GMT",
        check_timezone, assign_timezone, show_timezone
    },
    {
        {"timezone_abbreviations", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Selects a file of time zone abbreviations."),
            NULL
        },
        &timezone_abbreviations_string,
        NULL,
        check_timezone_abbreviations, assign_timezone_abbreviations, NULL
    },
 
    {
        {"unix_socket_group", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the owning group of the Unix-domain socket."),
            gettext_noop("The owning user of the socket is always the user "
                         "that starts the server.")
        },
        &Unix_socket_group,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"unix_socket_directories", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the directories where Unix-domain sockets will be created."),
            NULL,
            GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
        },
        &Unix_socket_directories,
#ifdef HAVE_UNIX_SOCKETS
        DEFAULT_PGSOCKET_DIR,
#else
        "",
#endif
        NULL, NULL, NULL
    },
 
    {
        {"listen_addresses", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
            gettext_noop("Sets the host name or IP address(es) to listen to."),
            NULL,
            GUC_LIST_INPUT
        },
        &ListenAddresses,
        "localhost",
        NULL, NULL, NULL
    },
 
    {
        /*
         * Can't be set by ALTER SYSTEM as it can lead to recursive definition
         * of data_directory.
         */
        {"data_directory", PGC_POSTMASTER, FILE_LOCATIONS,
            gettext_noop("Sets the server's data directory."),
            NULL,
            GUC_SUPERUSER_ONLY | GUC_DISALLOW_IN_AUTO_FILE
        },
        &data_directory,
        NULL,
        NULL, NULL, NULL
    },
 
    {
        {"config_file", PGC_POSTMASTER, FILE_LOCATIONS,
            gettext_noop("Sets the server's main configuration file."),
            NULL,
            GUC_DISALLOW_IN_FILE | GUC_SUPERUSER_ONLY
        },
        &ConfigFileName,
        NULL,
        NULL, NULL, NULL
    },
 
    {
        {"hba_file", PGC_POSTMASTER, FILE_LOCATIONS,
            gettext_noop("Sets the server's \"hba\" configuration file."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &HbaFileName,
        NULL,
        NULL, NULL, NULL
    },
 
    {
        {"ident_file", PGC_POSTMASTER, FILE_LOCATIONS,
            gettext_noop("Sets the server's \"ident\" configuration file."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &IdentFileName,
        NULL,
        NULL, NULL, NULL
    },
 
    {
        {"external_pid_file", PGC_POSTMASTER, FILE_LOCATIONS,
            gettext_noop("Writes the postmaster PID to the specified file."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &external_pid_file,
        NULL,
        check_canonical_path, NULL, NULL
    },
 
    {
        {"ssl_library", PGC_INTERNAL, PRESET_OPTIONS,
            gettext_noop("Shows the name of the SSL library."),
            NULL,
            GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &ssl_library,
#ifdef USE_SSL
        "OpenSSL",
#else
        "",
#endif
        NULL, NULL, NULL
    },
 
    {
        {"ssl_cert_file", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Location of the SSL server certificate file."),
            NULL
        },
        &ssl_cert_file,
        "server.crt",
        NULL, NULL, NULL
    },
 
    {
        {"ssl_key_file", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Location of the SSL server private key file."),
            NULL
        },
        &ssl_key_file,
        "server.key",
        NULL, NULL, NULL
    },
 
    {
        {"ssl_ca_file", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Location of the SSL certificate authority file."),
            NULL
        },
        &ssl_ca_file,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"ssl_crl_file", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Location of the SSL certificate revocation list file."),
            NULL
        },
        &ssl_crl_file,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"ssl_crl_dir", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Location of the SSL certificate revocation list directory."),
            NULL
        },
        &ssl_crl_dir,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"synchronous_standby_names", PGC_SIGHUP, REPLICATION_PRIMARY,
            gettext_noop("Number of synchronous standbys and list of names of potential synchronous ones."),
            NULL,
            GUC_LIST_INPUT
        },
        &SyncRepStandbyNames,
        "",
        check_synchronous_standby_names, assign_synchronous_standby_names, NULL
    },
 
    {
        {"default_text_search_config", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets default text search configuration."),
            NULL
        },
        &TSCurrentConfig,
        "pg_catalog.simple",
        check_TSCurrentConfig, assign_TSCurrentConfig, NULL
    },
 
    {
        {"ssl_ciphers", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Sets the list of allowed SSL ciphers."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &SSLCipherSuites,
#ifdef USE_OPENSSL
        "HIGH:MEDIUM:+3DES:!aNULL",
#else
        "none",
#endif
        NULL, NULL, NULL
    },
 
    {
        {"ssl_ecdh_curve", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Sets the curve to use for ECDH."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &SSLECDHCurve,
#ifdef USE_SSL
        "prime256v1",
#else
        "none",
#endif
        NULL, NULL, NULL
    },
 
    {
        {"ssl_dh_params_file", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Location of the SSL DH parameters file."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &ssl_dh_params_file,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"ssl_passphrase_command", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Command to obtain passphrases for SSL."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &ssl_passphrase_command,
        "",
        NULL, NULL, NULL
    },
 
    {
        {"application_name", PGC_USERSET, LOGGING_WHAT,
            gettext_noop("Sets the application name to be reported in statistics and logs."),
            NULL,
            GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE
        },
        &application_name,
        "",
        check_application_name, assign_application_name, NULL
    },
 
    {
        {"cluster_name", PGC_POSTMASTER, PROCESS_TITLE,
            gettext_noop("Sets the name of the cluster, which is included in the process title."),
            NULL,
            GUC_IS_NAME
        },
        &cluster_name,
        "",
        check_cluster_name, NULL, NULL
    },
 
    {
        {"wal_consistency_checking", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Sets the WAL resource managers for which WAL consistency checks are done."),
            gettext_noop("Full-page images will be logged for all data blocks and cross-checked against the results of WAL replay."),
            GUC_LIST_INPUT | GUC_NOT_IN_SAMPLE
        },
        &wal_consistency_checking_string,
        "",
        check_wal_consistency_checking, assign_wal_consistency_checking, NULL
    },
 
    {
        {"jit_provider", PGC_POSTMASTER, CLIENT_CONN_PRELOAD,
            gettext_noop("JIT provider to use."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &jit_provider,
        "llvmjit",
        NULL, NULL, NULL
    },
 
    {
        {"backtrace_functions", PGC_SUSET, DEVELOPER_OPTIONS,
            gettext_noop("Log backtrace for errors in these functions."),
            NULL,
            GUC_NOT_IN_SAMPLE
        },
        &backtrace_functions,
        "",
        check_backtrace_functions, assign_backtrace_functions, NULL
    },
 
    /* End-of-list marker */
    {
        {NULL, 0, 0, NULL, NULL}, NULL, NULL, NULL, NULL, NULL
    }
};
 
 
static struct config_enum ConfigureNamesEnum[] =
{
    {
        {"backslash_quote", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
            gettext_noop("Sets whether \"\\'\" is allowed in string literals."),
            NULL
        },
        &backslash_quote,
        BACKSLASH_QUOTE_SAFE_ENCODING, backslash_quote_options,
        NULL, NULL, NULL
    },
 
    {
        {"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the output format for bytea."),
            NULL
        },
        &bytea_output,
        BYTEA_OUTPUT_HEX, bytea_output_options,
        NULL, NULL, NULL
    },
 
    {
        {"client_min_messages", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the message levels that are sent to the client."),
            gettext_noop("Each level includes all the levels that follow it. The later"
                         " the level, the fewer messages are sent.")
        },
        &client_min_messages,
        NOTICE, client_message_level_options,
        NULL, NULL, NULL
    },
 
    {
        {"compute_query_id", PGC_SUSET, STATS_MONITORING,
            gettext_noop("Enables in-core computation of query identifiers."),
            NULL
        },
        &compute_query_id,
        COMPUTE_QUERY_ID_AUTO, compute_query_id_options,
        NULL, NULL, NULL
    },
 
    {
        {"constraint_exclusion", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Enables the planner to use constraints to optimize queries."),
            gettext_noop("Table scans will be skipped if their constraints"
                         " guarantee that no rows match the query."),
            GUC_EXPLAIN
        },
        &constraint_exclusion,
        CONSTRAINT_EXCLUSION_PARTITION, constraint_exclusion_options,
        NULL, NULL, NULL
    },
 
    {
        {"default_toast_compression", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the default compression method for compressible values."),
            NULL
        },
        &default_toast_compression,
        TOAST_PGLZ_COMPRESSION,
        default_toast_compression_options,
        NULL, NULL, NULL
    },
 
    {
        {"default_transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the transaction isolation level of each new transaction."),
            NULL
        },
        &DefaultXactIsoLevel,
        XACT_READ_COMMITTED, isolation_level_options,
        NULL, NULL, NULL
    },
 
    {
        {"transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the current transaction's isolation level."),
            NULL,
            GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
        },
        &XactIsoLevel,
        XACT_READ_COMMITTED, isolation_level_options,
        check_XactIsoLevel, NULL, NULL
    },
 
    {
        {"IntervalStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
            gettext_noop("Sets the display format for interval values."),
            NULL,
            GUC_REPORT
        },
        &IntervalStyle,
        INTSTYLE_POSTGRES, intervalstyle_options,
        NULL, NULL, NULL
    },
 
    {
        {"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Sets the verbosity of logged messages."),
            NULL
        },
        &Log_error_verbosity,
        PGERROR_DEFAULT, log_error_verbosity_options,
        NULL, NULL, NULL
    },
 
    {
        {"log_min_messages", PGC_SUSET, LOGGING_WHEN,
            gettext_noop("Sets the message levels that are logged."),
            gettext_noop("Each level includes all the levels that follow it. The later"
                         " the level, the fewer messages are sent.")
        },
        &log_min_messages,
        WARNING, server_message_level_options,
        NULL, NULL, NULL
    },
 
    {
        {"log_min_error_statement", PGC_SUSET, LOGGING_WHEN,
            gettext_noop("Causes all statements generating error at or above this level to be logged."),
            gettext_noop("Each level includes all the levels that follow it. The later"
                         " the level, the fewer messages are sent.")
        },
        &log_min_error_statement,
        ERROR, server_message_level_options,
        NULL, NULL, NULL
    },
 
    {
        {"log_statement", PGC_SUSET, LOGGING_WHAT,
            gettext_noop("Sets the type of statements logged."),
            NULL
        },
        &log_statement,
        LOGSTMT_NONE, log_statement_options,
        NULL, NULL, NULL
    },
 
    {
        {"syslog_facility", PGC_SIGHUP, LOGGING_WHERE,
            gettext_noop("Sets the syslog \"facility\" to be used when syslog enabled."),
            NULL
        },
        &syslog_facility,
#ifdef HAVE_SYSLOG
        LOG_LOCAL0,
#else
        0,
#endif
        syslog_facility_options,
        NULL, assign_syslog_facility, NULL
    },
 
    {
        {"session_replication_role", PGC_SUSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets the session's behavior for triggers and rewrite rules."),
            NULL
        },
        &SessionReplicationRole,
        SESSION_REPLICATION_ROLE_ORIGIN, session_replication_role_options,
        NULL, assign_session_replication_role, NULL
    },
 
    {
        {"synchronous_commit", PGC_USERSET, WAL_SETTINGS,
            gettext_noop("Sets the current transaction's synchronization level."),
            NULL
        },
        &synchronous_commit,
        SYNCHRONOUS_COMMIT_ON, synchronous_commit_options,
        NULL, assign_synchronous_commit, NULL
    },
 
    {
        {"archive_mode", PGC_POSTMASTER, WAL_ARCHIVING,
            gettext_noop("Allows archiving of WAL files using archive_command."),
            NULL
        },
        &XLogArchiveMode,
        ARCHIVE_MODE_OFF, archive_mode_options,
        NULL, NULL, NULL
    },
 
    {
        {"recovery_target_action", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
            gettext_noop("Sets the action to perform upon reaching the recovery target."),
            NULL
        },
        &recoveryTargetAction,
        RECOVERY_TARGET_ACTION_PAUSE, recovery_target_action_options,
        NULL, NULL, NULL
    },
 
    {
        {"trace_recovery_messages", PGC_SIGHUP, DEVELOPER_OPTIONS,
            gettext_noop("Enables logging of recovery-related debugging information."),
            gettext_noop("Each level includes all the levels that follow it. The later"
                         " the level, the fewer messages are sent."),
            GUC_NOT_IN_SAMPLE,
        },
        &trace_recovery_messages,
 
        /*
         * client_message_level_options allows too many values, really, but
         * it's not worth having a separate options array for this.
         */
        LOG, client_message_level_options,
        NULL, NULL, NULL
    },
 
    {
        {"track_functions", PGC_SUSET, STATS_CUMULATIVE,
            gettext_noop("Collects function-level statistics on database activity."),
            NULL
        },
        &pgstat_track_functions,
        TRACK_FUNC_OFF, track_function_options,
        NULL, NULL, NULL
    },
 
 
    {
        {"stats_fetch_consistency", PGC_USERSET, STATS_CUMULATIVE,
            gettext_noop("Sets the consistency of accesses to statistics data"),
            NULL
        },
        &pgstat_fetch_consistency,
        PGSTAT_FETCH_CONSISTENCY_CACHE, stats_fetch_consistency,
        NULL, NULL, NULL
    },
 
    {
        {"wal_compression", PGC_SUSET, WAL_SETTINGS,
            gettext_noop("Compresses full-page writes written in WAL file with specified method."),
            NULL
        },
        &wal_compression,
        WAL_COMPRESSION_NONE, wal_compression_options,
        NULL, NULL, NULL
    },
 
    {
        {"wal_level", PGC_POSTMASTER, WAL_SETTINGS,
            gettext_noop("Sets the level of information written to the WAL."),
            NULL
        },
        &wal_level,
        WAL_LEVEL_REPLICA, wal_level_options,
        NULL, NULL, NULL
    },
 
    {
        {"dynamic_shared_memory_type", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("Selects the dynamic shared memory implementation used."),
            NULL
        },
        &dynamic_shared_memory_type,
        DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE, dynamic_shared_memory_options,
        NULL, NULL, NULL
    },
 
    {
        {"shared_memory_type", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("Selects the shared memory implementation used for the main shared memory region."),
            NULL
        },
        &shared_memory_type,
        DEFAULT_SHARED_MEMORY_TYPE, shared_memory_options,
        NULL, NULL, NULL
    },
 
    {
        {"wal_sync_method", PGC_SIGHUP, WAL_SETTINGS,
            gettext_noop("Selects the method used for forcing WAL updates to disk."),
            NULL
        },
        &sync_method,
        DEFAULT_SYNC_METHOD, sync_method_options,
        NULL, assign_xlog_sync_method, NULL
    },
 
    {
        {"xmlbinary", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets how binary values are to be encoded in XML."),
            NULL
        },
        &xmlbinary,
        XMLBINARY_BASE64, xmlbinary_options,
        NULL, NULL, NULL
    },
 
    {
        {"xmloption", PGC_USERSET, CLIENT_CONN_STATEMENT,
            gettext_noop("Sets whether XML data in implicit parsing and serialization "
                         "operations is to be considered as documents or content fragments."),
            NULL
        },
        &xmloption,
        XMLOPTION_CONTENT, xmloption_options,
        NULL, NULL, NULL
    },
 
    {
        {"huge_pages", PGC_POSTMASTER, RESOURCES_MEM,
            gettext_noop("Use of huge pages on Linux or Windows."),
            NULL
        },
        &huge_pages,
        HUGE_PAGES_TRY, huge_pages_options,
        NULL, NULL, NULL
    },
 
    {
        {"recovery_prefetch", PGC_SIGHUP, WAL_RECOVERY,
            gettext_noop("Prefetch referenced blocks during recovery"),
            gettext_noop("Look ahead in the WAL to find references to uncached data.")
        },
        &recovery_prefetch,
        RECOVERY_PREFETCH_TRY, recovery_prefetch_options,
        check_recovery_prefetch, assign_recovery_prefetch, NULL
    },
 
    {
        {"force_parallel_mode", PGC_USERSET, DEVELOPER_OPTIONS,
            gettext_noop("Forces use of parallel query facilities."),
            gettext_noop("If possible, run query using a parallel worker and with parallel restrictions."),
            GUC_NOT_IN_SAMPLE | GUC_EXPLAIN
        },
        &force_parallel_mode,
        FORCE_PARALLEL_OFF, force_parallel_mode_options,
        NULL, NULL, NULL
    },
 
    {
        {"password_encryption", PGC_USERSET, CONN_AUTH_AUTH,
            gettext_noop("Chooses the algorithm for encrypting passwords."),
            NULL
        },
        &Password_encryption,
        PASSWORD_TYPE_SCRAM_SHA_256, password_encryption_options,
        NULL, NULL, NULL
    },
 
    {
        {"plan_cache_mode", PGC_USERSET, QUERY_TUNING_OTHER,
            gettext_noop("Controls the planner's selection of custom or generic plan."),
            gettext_noop("Prepared statements can have custom and generic plans, and the planner "
                         "will attempt to choose which is better.  This can be set to override "
                         "the default behavior."),
            GUC_EXPLAIN
        },
        &plan_cache_mode,
        PLAN_CACHE_MODE_AUTO, plan_cache_mode_options,
        NULL, NULL, NULL
    },
 
    {
        {"ssl_min_protocol_version", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Sets the minimum SSL/TLS protocol version to use."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &ssl_min_protocol_version,
        PG_TLS1_2_VERSION,
        ssl_protocol_versions_info + 1, /* don't allow PG_TLS_ANY */
        NULL, NULL, NULL
    },
 
    {
        {"ssl_max_protocol_version", PGC_SIGHUP, CONN_AUTH_SSL,
            gettext_noop("Sets the maximum SSL/TLS protocol version to use."),
            NULL,
            GUC_SUPERUSER_ONLY
        },
        &ssl_max_protocol_version,
        PG_TLS_ANY,
        ssl_protocol_versions_info,
        NULL, NULL, NULL
    },
 
    {
        {"recovery_init_sync_method", PGC_SIGHUP, ERROR_HANDLING_OPTIONS,
            gettext_noop("Sets the method for synchronizing the data directory before crash recovery."),
        },
        &recovery_init_sync_method,
        RECOVERY_INIT_SYNC_METHOD_FSYNC, recovery_init_sync_method_options,
        NULL, NULL, NULL
    },
 
    /* End-of-list marker */
    {
        {NULL, 0, 0, NULL, NULL}, NULL, 0, NULL, NULL, NULL, NULL
    }
};
 
/******** end of options list ********/
 
 
/*
 * To allow continued support of obsolete names for GUC variables, we apply
 * the following mappings to any unrecognized name.  Note that an old name
 * should be mapped to a new one only if the new variable has very similar
 * semantics to the old.
 */
static const char *const map_old_guc_names[] = {
    "sort_mem", "work_mem",
    "vacuum_mem", "maintenance_work_mem",
    NULL
};
 
 
/*
 * Actual lookup of variables is done through this single, sorted array.
 */
static struct config_generic **guc_variables;
 
/* Current number of variables contained in the vector */
static int  num_guc_variables;
 
/* Vector capacity */
static int  size_guc_variables;
 
 
static bool guc_dirty;          /* true if need to do commit/abort work */
 
static bool reporting_enabled;  /* true to enable GUC_REPORT */
 
static bool report_needed;      /* true if any GUC_REPORT reports are needed */
 
static int  GUCNestLevel = 0;   /* 1 when in main transaction */
 
 
static int  guc_var_compare(const void *a, const void *b);
static int  guc_name_compare(const char *namea, const char *nameb);
static void InitializeGUCOptionsFromEnvironment(void);
static void InitializeOneGUCOption(struct config_generic *gconf);
static void push_old_value(struct config_generic *gconf, GucAction action);
static void ReportGUCOption(struct config_generic *record);
static void reapply_stacked_values(struct config_generic *variable,
                                   struct config_string *pHolder,
                                   GucStack *stack,
                                   const char *curvalue,
                                   GucContext curscontext, GucSource cursource);
static void ShowGUCConfigOption(const char *name, DestReceiver *dest);
static void ShowAllGUCConfig(DestReceiver *dest);
static char *_ShowOption(struct config_generic *record, bool use_units);
static bool validate_option_array_item(const char *name, const char *value,
                                       bool skipIfNoPermissions);
static void write_auto_conf_file(int fd, const char *filename, ConfigVariable *head_p);
static void replace_auto_config_value(ConfigVariable **head_p, ConfigVariable **tail_p,
                                      const char *name, const char *value);
 
 
/*
 * Some infrastructure for checking malloc/strdup/realloc calls
 */
static void *
guc_malloc(int elevel, size_t size)
{
    void       *data;
 
    /* Avoid unportable behavior of malloc(0) */
    if (size == 0)
        size = 1;
    data = malloc(size);
    if (data == NULL)
        ereport(elevel,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
    return data;
}
 
static void *
guc_realloc(int elevel, void *old, size_t size)
{
    void       *data;
 
    /* Avoid unportable behavior of realloc(NULL, 0) */
    if (old == NULL && size == 0)
        size = 1;
    data = realloc(old, size);
    if (data == NULL)
        ereport(elevel,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
    return data;
}
 
static char *
guc_strdup(int elevel, const char *src)
{
    char       *data;
 
    data = strdup(src);
    if (data == NULL)
        ereport(elevel,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
    return data;
}
 
 
/*
 * Detect whether strval is referenced anywhere in a GUC string item
 */
static bool
string_field_used(struct config_string *conf, char *strval)
{
    GucStack   *stack;
 
    if (strval == *(conf->variable) ||
        strval == conf->reset_val ||
        strval == conf->boot_val)
        return true;
    for (stack = conf->gen.stack; stack; stack = stack->prev)
    {
        if (strval == stack->prior.val.stringval ||
            strval == stack->masked.val.stringval)
            return true;
    }
    return false;
}
 
/*
 * Support for assigning to a field of a string GUC item.  Free the prior
 * value if it's not referenced anywhere else in the item (including stacked
 * states).
 */
static void
set_string_field(struct config_string *conf, char **field, char *newval)
{
    char       *oldval = *field;
 
    /* Do the assignment */
    *field = newval;
 
    /* Free old value if it's not NULL and isn't referenced anymore */
    if (oldval && !string_field_used(conf, oldval))
        free(oldval);
}
 
/*
 * Detect whether an "extra" struct is referenced anywhere in a GUC item
 */
static bool
extra_field_used(struct config_generic *gconf, void *extra)
{
    GucStack   *stack;
 
    if (extra == gconf->extra)
        return true;
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            if (extra == ((struct config_bool *) gconf)->reset_extra)
                return true;
            break;
        case PGC_INT:
            if (extra == ((struct config_int *) gconf)->reset_extra)
                return true;
            break;
        case PGC_REAL:
            if (extra == ((struct config_real *) gconf)->reset_extra)
                return true;
            break;
        case PGC_STRING:
            if (extra == ((struct config_string *) gconf)->reset_extra)
                return true;
            break;
        case PGC_ENUM:
            if (extra == ((struct config_enum *) gconf)->reset_extra)
                return true;
            break;
    }
    for (stack = gconf->stack; stack; stack = stack->prev)
    {
        if (extra == stack->prior.extra ||
            extra == stack->masked.extra)
            return true;
    }
 
    return false;
}
 
/*
 * Support for assigning to an "extra" field of a GUC item.  Free the prior
 * value if it's not referenced anywhere else in the item (including stacked
 * states).
 */
static void
set_extra_field(struct config_generic *gconf, void **field, void *newval)
{
    void       *oldval = *field;
 
    /* Do the assignment */
    *field = newval;
 
    /* Free old value if it's not NULL and isn't referenced anymore */
    if (oldval && !extra_field_used(gconf, oldval))
        free(oldval);
}
 
/*
 * Support for copying a variable's active value into a stack entry.
 * The "extra" field associated with the active value is copied, too.
 *
 * NB: be sure stringval and extra fields of a new stack entry are
 * initialized to NULL before this is used, else we'll try to free() them.
 */
static void
set_stack_value(struct config_generic *gconf, config_var_value *val)
{
    switch (gconf->vartype)
    {
        case PGC_BOOL:
            val->val.boolval =
                *((struct config_bool *) gconf)->variable;
            break;
        case PGC_INT:
            val->val.intval =
                *((struct config_int *) gconf)->variable;
            break;
        case PGC_REAL:
            val->val.realval =
                *((struct config_real *) gconf)->variable;
            break;
        case PGC_STRING:
            set_string_field((struct config_string *) gconf,
                             &(val->val.stringval),
                             *((struct config_string *) gconf)->variable);
            break;
        case PGC_ENUM:
            val->val.enumval =
                *((struct config_enum *) gconf)->variable;
            break;
    }
    set_extra_field(gconf, &(val->extra), gconf->extra);
}
 
/*
 * Support for discarding a no-longer-needed value in a stack entry.
 * The "extra" field associated with the stack entry is cleared, too.
 */
static void
discard_stack_value(struct config_generic *gconf, config_var_value *val)
{
    switch (gconf->vartype)
    {
        case PGC_BOOL:
        case PGC_INT:
        case PGC_REAL:
        case PGC_ENUM:
            /* no need to do anything */
            break;
        case PGC_STRING:
            set_string_field((struct config_string *) gconf,
                             &(val->val.stringval),
                             NULL);
            break;
    }
    set_extra_field(gconf, &(val->extra), NULL);
}
 
 
/*
 * Fetch the sorted array pointer (exported for help_config.c's use ONLY)
 */
struct config_generic **
get_guc_variables(void)
{
    return guc_variables;
}
 
 
/*
 * Build the sorted array.  This is split out so that it could be
 * re-executed after startup (e.g., we could allow loadable modules to
 * add vars, and then we'd need to re-sort).
 */
void
build_guc_variables(void)
{
    int         size_vars;
    int         num_vars = 0;
    struct config_generic **guc_vars;
    int         i;
 
    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
    {
        struct config_bool *conf = &ConfigureNamesBool[i];
 
        /* Rather than requiring vartype to be filled in by hand, do this: */
        conf->gen.vartype = PGC_BOOL;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
    {
        struct config_int *conf = &ConfigureNamesInt[i];
 
        conf->gen.vartype = PGC_INT;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
    {
        struct config_real *conf = &ConfigureNamesReal[i];
 
        conf->gen.vartype = PGC_REAL;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesString[i].gen.name; i++)
    {
        struct config_string *conf = &ConfigureNamesString[i];
 
        conf->gen.vartype = PGC_STRING;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
    {
        struct config_enum *conf = &ConfigureNamesEnum[i];
 
        conf->gen.vartype = PGC_ENUM;
        num_vars++;
    }
 
    /*
     * Create table with 20% slack
     */
    size_vars = num_vars + num_vars / 4;
 
    guc_vars = (struct config_generic **)
        guc_malloc(FATAL, size_vars * sizeof(struct config_generic *));
 
    num_vars = 0;
 
    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesBool[i].gen;
 
    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesInt[i].gen;
 
    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesReal[i].gen;
 
    for (i = 0; ConfigureNamesString[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesString[i].gen;
 
    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
        guc_vars[num_vars++] = &ConfigureNamesEnum[i].gen;
 
    if (guc_variables)
        free(guc_variables);
    guc_variables = guc_vars;
    num_guc_variables = num_vars;
    size_guc_variables = size_vars;
    qsort((void *) guc_variables, num_guc_variables,
          sizeof(struct config_generic *), guc_var_compare);
}
 
/*
 * Add a new GUC variable to the list of known variables. The
 * list is expanded if needed.
 */
static bool
add_guc_variable(struct config_generic *var, int elevel)
{
    if (num_guc_variables + 1 >= size_guc_variables)
    {
        /*
         * Increase the vector by 25%
         */
        int         size_vars = size_guc_variables + size_guc_variables / 4;
        struct config_generic **guc_vars;
 
        if (size_vars == 0)
        {
            size_vars = 100;
            guc_vars = (struct config_generic **)
                guc_malloc(elevel, size_vars * sizeof(struct config_generic *));
        }
        else
        {
            guc_vars = (struct config_generic **)
                guc_realloc(elevel, guc_variables, size_vars * sizeof(struct config_generic *));
        }
 
        if (guc_vars == NULL)
            return false;       /* out of memory */
 
        guc_variables = guc_vars;
        size_guc_variables = size_vars;
    }
    guc_variables[num_guc_variables++] = var;
    qsort((void *) guc_variables, num_guc_variables,
          sizeof(struct config_generic *), guc_var_compare);
    return true;
}
 
/*
 * Decide whether a proposed custom variable name is allowed.
 *
 * It must be two or more identifiers separated by dots, where the rules
 * for what is an identifier agree with scan.l.  (If you change this rule,
 * adjust the errdetail in find_option().)
 */
static bool
valid_custom_variable_name(const char *name)
{
    bool        saw_sep = false;
    bool        name_start = true;
 
    for (const char *p = name; *p; p++)
    {
        if (*p == GUC_QUALIFIER_SEPARATOR)
        {
            if (name_start)
                return false;   /* empty name component */
            saw_sep = true;
            name_start = true;
        }
        else if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                        "abcdefghijklmnopqrstuvwxyz_", *p) != NULL ||
                 IS_HIGHBIT_SET(*p))
        {
            /* okay as first or non-first character */
            name_start = false;
        }
        else if (!name_start && strchr("0123456789$", *p) != NULL)
             /* okay as non-first character */ ;
        else
            return false;
    }
    if (name_start)
        return false;           /* empty name component */
    /* OK if we found at least one separator */
    return saw_sep;
}
 
/*
 * Create and add a placeholder variable for a custom variable name.
 */
static struct config_generic *
add_placeholder_variable(const char *name, int elevel)
{
    size_t      sz = sizeof(struct config_string) + sizeof(char *);
    struct config_string *var;
    struct config_generic *gen;
 
    var = (struct config_string *) guc_malloc(elevel, sz);
    if (var == NULL)
        return NULL;
    memset(var, 0, sz);
    gen = &var->gen;
 
    gen->name = guc_strdup(elevel, name);
    if (gen->name == NULL)
    {
        free(var);
        return NULL;
    }
 
    gen->context = PGC_USERSET;
    gen->group = CUSTOM_OPTIONS;
    gen->short_desc = "GUC placeholder variable";
    gen->flags = GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_CUSTOM_PLACEHOLDER;
    gen->vartype = PGC_STRING;
 
    /*
     * The char* is allocated at the end of the struct since we have no
     * 'static' place to point to.  Note that the current value, as well as
     * the boot and reset values, start out NULL.
     */
    var->variable = (char **) (var + 1);
 
    if (!add_guc_variable((struct config_generic *) var, elevel))
    {
        free(unconstify(char *, gen->name));
        free(var);
        return NULL;
    }
 
    return gen;
}
 
/*
 * Look up option "name".  If it exists, return a pointer to its record.