database/openGauss-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9918729b4efcb03f096466dc80972f0a80bb2c63
openGauss-server/src/common/backend/utils/misc/guc.cpp

21611 lines
664 KiB
C++
Raw Blame History

/* --------------------------------------------------------------------
* guc.c
*
* Support for grand unified configuration schema, including SET
* command, configuration file, and command line options.
* See src/backend/utils/misc/README for more information.
*
*
* Copyright (c) 2000-2012, PostgreSQL Global Development Group
* Portions Copyright (c) 2010-2012 Postgres-XC Development Group
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* IDENTIFICATION
* src/backend/utils/misc/guc.c
*
* --------------------------------------------------------------------
*/
#include "postgres.h"
#include "knl/knl_variable.h"
#include <float.h>
#include <math.h>
#include <limits.h>
#include "utils/elog.h"
#ifdef HAVE_SYSLOG
#include <syslog.h>
#endif
#include "access/cbmparsexlog.h"
#include "access/gin.h"
#ifdef PGXC
#include "access/gtm.h"
#include "pgxc/pgxc.h"
#endif
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/dfs/dfs_insert.h"
#include "catalog/namespace.h"
#include "catalog/pgxc_group.h"
#include "catalog/storage_gtt.h"
#include "commands/async.h"
#include "commands/prepare.h"
#include "commands/vacuum.h"
#include "commands/variable.h"
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "funcapi.h"
#include "job/job_scheduler.h"
#include "libpq/auth.h"
#include "libpq/be-fsstubs.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "opfusion/opfusion.h"
#include "optimizer/cost.h"
#include "optimizer/geqo.h"
#include "optimizer/nodegroups.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
#include "optimizer/prep.h"
#include "parser/parse_expr.h"
#include "parser/parse_oper.h"
#include "parser/parse_type.h"
#include "parser/parser.h"
#include "parser/scansup.h"
#include "pgstat.h"
#include "workload/workload.h"
#include "pgaudit.h"
#include "instruments/instr_unique_sql.h"
#ifdef PGXC
#include "commands/tablecmds.h"
#include "nodes/nodes.h"
#include "optimizer/pgxcship.h"
#include "pgxc/execRemote.h"
#include "pgxc/locator.h"
#include "optimizer/pgxcplan.h"
#include "pgxc/poolmgr.h"
#include "pgxc/nodemgr.h"
#include "utils/lsyscache.h"
#endif
#include "access/multi_redo_settings.h"
#include "catalog/pg_authid.h"
#include "commands/user.h"
#include "commands/user.h"
#include "flock.h"
#include "gaussdb_version.h"
#include "libcomm/libcomm.h"
#include "libpq/libpq-be.h"
#include "libpq/md5.h"
#include "libpq/sha2.h"
#include "optimizer/planner.h"
#include "optimizer/streamplan.h"
#include "postmaster/alarmchecker.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgwriter.h"
#include "postmaster/pagewriter.h"
#include "postmaster/postmaster.h"
#include "postmaster/syslogger.h"
#include "postmaster/twophasecleaner.h"
#include "postmaster/walwriter.h"
#include "replication/dataqueue.h"
#include "replication/datareceiver.h"
#include "replication/reorderbuffer.h"
#include "replication/replicainternal.h"
#include "replication/slot.h"
#include "replication/syncrep.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/cucache_mgr.h"
#include "storage/fd.h"
#include "storage/predicate.h"
#include "storage/procarray.h"
#include "storage/standby.h"
#include "storage/remote_adapter.h"
#include "tcop/tcopprot.h"
#include "threadpool/threadpool.h"
#include "tsearch/ts_cache.h"
#include "utils/anls_opt.h"
#include "utils/atomic.h"
#include "utils/be_module.h"
#include "utils/builtins.h"
#include "utils/bytea.h"
#include "utils/distribute_test.h"
#include "utils/guc_tables.h"
#include "utils/memtrack.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/plancache.h"
#include "utils/portal.h"
#include "utils/ps_status.h"
#include "utils/rel_gs.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/tqual.h"
#include "utils/tzparser.h"
#include "utils/xml.h"
#include "workload/cpwlm.h"
#include "workload/workload.h"
#ifndef PG_KRB_SRVTAB
#define PG_KRB_SRVTAB ""
#endif
#ifndef PG_KRB_SRVNAM
#define PG_KRB_SRVNAM ""
#endif
#define CONFIG_FILENAME "postgresql.conf"
#define MOT_CONFIG_FILENAME "mot.conf"
#define CONFIG_LOCK_FILE "postgresql.conf.lock"
#define HBA_FILENAME "pg_hba.conf"
#define IDENT_FILENAME "pg_ident.conf"
#define INVALID_LINES_IDX (int)(~0)
#define MAX_PARAM_LEN 1024
#define WRITE_CONFIG_LOCK_LEN (1024 * 1024)
#define CONFIG_BAK_FILENAME "postgresql.conf.bak"
#define NO_LIMIT_SIZE -1
#ifdef EXEC_BACKEND
#define CONFIG_EXEC_PARAMS "global/config_exec_params"
#define CONFIG_EXEC_PARAMS_NEW "global/config_exec_params.new"
#endif
/* upper limit for GUC variables measured in kilobytes of memory */
/* note that various places assume the byte size fits in a "long" variable */
#if SIZEOF_SIZE_T > 4 && SIZEOF_LONG > 4
#define MAX_KILOBYTES INT_MAX
#else
#define MAX_KILOBYTES (INT_MAX / 1024)
#endif
#define KB_PER_MB 1024
#define KB_PER_GB (1024 * 1024)
#define MS_PER_S 1000
#define S_PER_MIN 60
#define MS_PER_MIN (1000 * 60)
#define MIN_PER_H 60
#define S_PER_H (60 * 60)
#define MS_PER_H (1000 * 60 * 60)
#define MIN_PER_D (60 * 24)
#define S_PER_D (60 * 60 * 24)
#define MS_PER_D (1000 * 60 * 60 * 24)
#define H_PER_D 24
/* max reuse time interval and times */
#define MAX_PASSWORD_REUSE_TIME 3650
#define MAX_PASSWORD_REUSE_MAX 1000
#define MAX_ACCOUNT_LOCK_TIME 365
#define MAX_FAILED_LOGIN_ATTAMPTS 1000
#define MAX_PASSWORD_EFFECTIVE_TIME 999
#define MAX_PASSWORD_NOTICE_TIME 999
/* max num of assign character in password */
#define MAX_PASSWORD_ASSIGNED_CHARACTER 999
/* max length of password */
#define MAX_PASSWORD_LENGTH 999
extern volatile int synchronous_commit;
extern volatile bool most_available_sync;
extern void SetThreadLocalGUC(knl_session_context* session);
THR_LOCAL int comm_ackchk_time;
static THR_LOCAL GucContext currentGucContext;
const char* sync_guc_variable_namelist[] = {"work_mem",
"query_mem",
"ssl_renegotiation_limit",
"temp_buffers",
"maintenance_work_mem",
"max_stack_depth",
"temp_file_limit",
"vacuum_cost_delay",
"vacuum_cost_page_hit",
"vacuum_cost_page_miss",
"vacuum_cost_page_dirty",
"vacuum_cost_limit",
"effective_io_concurrency",
"synchronous_commit",
"commit_delay",
"commit_siblings",
"client_min_messages",
"log_min_messages",
"log_min_error_statement",
"log_min_duration_statement",
"logging_module",
"analysis_options",
"plog_merge_age",
"application_name",
"connection_info",
"cgroup_name",
"memory_detail_tracking",
"debug_print_parse",
"debug_print_rewritten",
"debug_print_plan",
"debug_pretty_print",
"log_connections",
"log_disconnections",
"log_duration",
"log_error_verbosity",
"log_lock_waits",
"log_statement",
"log_temp_files",
"track_activities",
"enable_instr_track_wait",
"enable_instr_rt_percentile",
"instr_rt_percentile_interval",
"enable_wdr_snapshot",
"wdr_snapshot_interval",
"wdr_snapshot_retention_days",
"wdr_snapshot_query_timeout",
"track_counts",
"track_io_timing",
"track_functions",
"update_process_title",
"log_statement_stats",
"log_parser_stats",
"log_planner_stats",
"log_executor_stats",
"search_path",
"percentile",
"default_tablespace",
"temp_tablespaces",
"check_function_bodies",
"default_transaction_isolation",
"default_transaction_read_only",
"default_transaction_deferrable",
"session_replication_role",
"session_respool",
"statement_timeout",
"vacuum_freeze_table_age",
"vacuum_freeze_min_age",
"bytea_output",
"xmlbinary",
"xmloption",
"DateStyle",
"IntervalStyle",
"TimeZone",
"timezone_abbreviations",
"extra_float_digits",
"client_encoding",
"lc_messages",
"lc_monetary",
"lc_numeric",
"lc_time",
"default_text_search_config",
"dynamic_library_path",
"gin_fuzzy_search_limit",
"local_preload_libraries",
"deadlock_timeout",
"array_nulls",
"backslash_quote",
"default_with_oids",
"escape_string_warning",
"lo_compat_privileges",
"quote_all_identifiers",
"sql_inheritance",
"standard_conforming_strings",
"synchronize_seqscans",
"transform_null_equals",
"exit_on_error",
#ifdef ENABLE_MULTIPLE_NODES
"gtm_backup_barrier",
#endif
"enforce_two_phase_commit",
"xc_maintenance_mode",
#ifdef ENABLE_MULTIPLE_NODES
"enable_hdfs_predicate_pushdown",
"enable_hadoop_env",
#endif
"behavior_compat_options",
"enable_valuepartition_pruning",
#ifdef ENABLE_MULTIPLE_NODES
"enable_constraint_optimization",
#endif
"enable_bloom_filter",
#ifdef ENABLE_MULTIPLE_NODES
"cstore_insert_mode",
#endif
"enable_delta_store",
"enable_codegen",
"enable_codegen_print",
"codegen_cost_threshold",
"codegen_strategy",
"max_query_retry_times",
"convert_string_to_digit",
#ifdef ENABLE_MULTIPLE_NODES
"agg_redistribute_enhancement",
#endif
"sql_compatibility",
"hashagg_table_size",
"max_loaded_cudesc",
"partition_mem_batch",
"partition_max_cache_size",
"memory_tracking_mode",
"enable_early_free",
"cstore_backwrite_quantity",
"cstore_backwrite_max_threshold",
"prefetch_quantity",
"backwrite_quantity",
"cstore_prefetch_quantity",
"enable_fast_allocate",
"enable_adio_debug",
"enable_adio_function",
"fast_extend_file_size",
"enable_global_stats",
"td_compatible_truncation",
#ifdef ENABLE_MULTIPLE_NODES
"gds_debug_mod",
#endif
"ngram_punctuation_ignore",
"ngram_grapsymbol_ignore",
"ngram_gram_size",
"enable_parallel_ddl",
#ifdef ENABLE_MULTIPLE_NODES
"enable_orc_cache",
"enable_cluster_resize",
"enable_compress_hll",
"hll_default_log2m",
"hll_default_regwidth",
"hll_default_sparseon",
"hll_default_expthresh",
"hll_max_sparse",
#endif
"enable_compress_spill",
"resource_track_level",
"fault_mon_timeout",
"trace_sort",
"ignore_checksum_failure",
"wal_log_hints",
"max_cn_temp_file_size",
"cn_send_buffer_size",
"enable_sonic_optspill",
"enable_sonic_hashjoin",
"enable_sonic_hashagg",
#ifdef ENABLE_MULTIPLE_NODES
"enable_stream_recursive",
#endif
"data_sync_retry",
#ifdef ENABLE_QUNIT
"qunit_case_number",
#endif
"instr_unique_sql_count",
"enable_instr_cpu_timer",
"instr_unique_sql_track_type",
"enable_incremental_catchup",
"wait_dummy_time",
"max_recursive_times",
"sql_use_spacelimit"};
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_int64_check_hook(struct config_int64* conf, int64* 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);
void free_memory_context_list(memory_context_list* head_node);
memory_context_list* split_string_into_list(const char* source);
static bool check_uncontrolled_memory_context(char** newval, void** extra, GucSource source);
static void assign_uncontrolled_memory_context(const char* newval, void* extra);
static const char* show_uncontrolled_memory_context(void); // end of GUC variables for uncontrolled_memory_context
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_client_min_messages(int* newval, void** extra, GucSource source);
static bool check_temp_buffers(int* newval, void** extra, GucSource source);
static bool check_fencedUDFMemoryLimit(int* newval, void** extra, GucSource source);
static bool check_udf_memory_limit(int* newval, void** extra, GucSource source);
static bool check_phony_autocommit(bool* newval, void** extra, GucSource source);
static bool check_debug_assertions(bool* newval, void** extra, GucSource source);
#ifdef USE_BONJOUR
static bool check_bonjour(bool* newval, void** extra, GucSource source);
#endif
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);
#ifdef PGXC
static bool check_pgxc_maintenance_mode(bool* newval, void** extra, GucSource source);
static bool check_sctp_support(bool* newval, void** extra, GucSource source);
static void assign_comm_debug_mode(bool newval, void* extra);
static void assign_comm_stat_mode(bool newval, void* extra);
static void assign_comm_timer_mode(bool newval, void* extra);
static void assign_comm_no_delay(bool newval, void* extra);
static void assign_comm_ackchk_time(int newval, void* extra);
#endif
#ifdef LIBCOMM_SPEED_TEST_ENABLE
static void assign_comm_test_thread_num(int newval, void* extra);
static void assign_comm_test_msg_len(int newval, void* extra);
static void assign_comm_test_send_sleep(int newval, void* extra);
static void assign_comm_test_send_once(int newval, void* extra);
static void assign_comm_test_recv_sleep(int newval, void* extra);
static void assign_comm_test_recv_once(int newval, void* extra);
#endif
#ifdef LIBCOMM_FAULT_INJECTION_ENABLE
static void assign_comm_fault_injection(int newval, void* extra);
#endif
static const char* show_enable_memory_limit(void);
static bool check_use_workload_manager(bool* newval, void** extra, GucSource source);
static bool check_canonical_path(char** newval, void** extra, GucSource source);
static bool check_perf_log(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 bool check_maxconnections(int* newval, void** extra, GucSource source);
static bool CheckMaxInnerToolConnections(int* newval, void** extra, GucSource source);
static bool check_statistics_memory_limit(int* newval, void** extra, GucSource source);
static void assign_statistics_memory(int newval, void* extra);
static void assign_history_memory(int newval, void* extra);
static bool check_history_memory_limit(int* newval, void** extra, GucSource source);
static bool check_autovacuum_max_workers(int* newval, void** extra, GucSource source);
static bool check_job_max_workers(int* newval, void** extra, GucSource source);
static bool check_effective_io_concurrency(int* newval, void** extra, GucSource source);
static void assign_effective_io_concurrency(int newval, void* extra);
static void assign_pgstat_temp_directory(const char* newval, void* extra);
static bool check_application_name(char** newval, void** extra, GucSource source);
static void assign_application_name(const char* newval, void* extra);
static void assign_connection_info(const char* newval, void* extra);
static bool check_cgroup_name(char** newval, void** extra, GucSource source);
static void assign_cgroup_name(const char* newval, void* extra);
static const char* show_cgroup_name(void);
static bool check_query_band_name(char** newval, void** extra, GucSource source);
static bool check_session_respool(char** newval, void** extra, GucSource source);
static void assign_session_respool(const char* newval, void* extra);
static const char* show_session_respool(void);
static bool check_memory_detail_tracking(char** newval, void** extra, GucSource source);
static void assign_memory_detail_tracking(const char* newval, void* extra);
static const char* show_memory_detail_tracking(void);
static void assign_collect_timer(int newval, void* extra);
static bool check_statement_mem(int* newval, void** extra, GucSource source);
static bool check_statement_max_mem(int* newval, void** extra, GucSource source);
static const char* show_unix_socket_permissions(void);
static const char* show_log_file_mode(void);
static char* config_enum_get_options(
struct config_enum* record, const char* prefix, const char* suffix, const char* separator);
/* Database Security: Support password complexity */
static bool check_int_parameter(int* newval, void** extra, GucSource source);
static bool check_double_parameter(double* newval, void** extra, GucSource source);
static bool verify_setrole_passwd(const char* rolename, char* passwd, bool IsSetRole);
static bool check_repl_channel(const char* channel_info);
static int get_length_and_check_repl_conn(const char* conn_info_list);
static ReplConnInfo* parse_repl_conn_info(const char* conn_info_list, int* info_length);
static bool check_replconninfo(char** newval, void** extra, GucSource source);
static void assign_replconninfo1(const char* newval, void* extra);
static void assign_replconninfo2(const char* newval, void* extra);
static void assign_replconninfo3(const char* newval, void* extra);
static void assign_replconninfo4(const char* newval, void* extra);
#ifdef ENABLE_MULTIPLE_NODES
static void assign_replconninfo5(const char* newval, void* extra);
static void assign_replconninfo6(const char* newval, void* extra);
static void assign_replconninfo7(const char* newval, void* extra);
#endif
static bool check_inlist2joininfo(char** newval, void** extra, GucSource source);
static void assign_inlist2joininfo(const char* newval, void* extra);
static bool check_replication_type(int* newval, void** extra, GucSource source);
static bool is_opt_line_commented(char* opt_line);
static bool is_match_option_name(
char* opt_line, const char* para_name, int para_length, int* para_offset, int* value_length, int* value_offset);
static const char* logging_module_guc_show(void);
static bool logging_module_check(char** newval, void** extra, GucSource source);
static void logging_module_guc_assign(const char* newval, void* extra);
static void plog_merge_age_assign(int newval, void* extra);
/* Inplace Upgrade GUC hooks */
static bool check_is_upgrade(bool* newval, void** extra, GucSource source);
static void assign_is_inplace_upgrade(const bool newval, void* extra);
static bool check_inplace_upgrade_next_oids(char** newval, void** extra, GucSource source);
static bool transparent_encrypt_kms_url_region_check(char** newval, void** extra, GucSource source);
/* SQL DFx Options : Support different sql dfx option */
static const char* analysis_options_guc_show(void);
static bool analysis_options_check(char** newval, void** extra, GucSource source);
static void analysis_options_guc_assign(const char* newval, void* extra);
static bool check_behavior_compat_options(char** newval, void** extra, GucSource source);
static void assign_behavior_compat_options(const char* newval, void* extra);
static void assign_use_workload_manager(const bool newval, void* extra);
static void assign_convert_string_to_digit(bool newval, void* extra);
void SetThreadLocalGUC(knl_session_context* session);
static bool check_enable_data_replicate(bool* newval, void** extra, GucSource source);
static void assign_instr_unique_sql_count(int newval, void* extra);
#ifdef ENABLE_MULTIPLE_NODES
static bool parse_query_dop(int* newval, void** extra, GucSource source);
static void AssignQueryDop(int newval, void* extra);
static bool check_cn_dn_logic_support(bool* newval, void** extra, GucSource source);
static void assign_enable_cgroup_switch(bool newval, void* extra);
static const char* show_enable_dynamic_workload(void);
static void assign_active_statements(int newval, void* extra);
static void assign_memory_quota(int newval, void* extra);
static bool check_gtmhostconninfo(char** newval, void** extra, GucSource source);
static void assign_gtmhostconninfo0(const char* newval, void* extra);
static void assign_gtmhostconninfo1(const char* newval, void* extra);
static void assign_gtmhostconninfo2(const char* newval, void* extra);
static void assign_gtmhostconninfo3(const char* newval, void* extra);
static void assign_gtmhostconninfo4(const char* newval, void* extra);
static void assign_gtmhostconninfo5(const char* newval, void* extra);
static void assign_gtmhostconninfo6(const char* newval, void* extra);
static void assign_gtmhostconninfo7(const char* newval, void* extra);
static GTM_HOST_IP* parse_gtm_host_conn_info(const char* conn_info_list, int* info_length);
static void assign_gtm_rw_timeout(int newval, void* extra);
static bool check_enable_gtm_free(bool* newval, void** extra, GucSource source);
static void comm_change_datanode(int newval, void* extra);
static void comm_change_coordnode(int newval, void* extra);
static bool check_max_datanode(int* newval, void** extra, GucSource source);
static bool check_max_coordnode(int* newval, void** extra, GucSource source);
static const char* show_max_datanode(void);
static const char* show_max_coordnode(void);
void assign_control_group(const bool newval, void* extra);
#endif
/*
* is_match_option_name - Check wether the option name is in the configure file.
*
* Params:
* @opt_line: Line in the configure file.
* @para_name: Paramater name.
* @para_length: Paramater length.
* @para_offset: Paramater offset int the opt_line.
* @value_length: Value length.
* @value_offset: Value offset int the opt_line.
*
* Returns:
* True, iff the option name is in the configure file; else false.
*/
static bool is_match_option_name(
char* opt_line, const char* para_name, int para_length, int* para_offset, int* value_length, int* value_offset)
{
char* p = NULL;
char* q = NULL;
char* tmp = NULL;
p = opt_line;
/* Skip all the blanks at the begin of the opt_line */
while (isspace((unsigned char)*p)) {
p++;
}
if (*p == '#') {
p++;
}
/* Skip all the blanks after '#' and before the para_name */
while (isspace((unsigned char)*p)) {
p++;
}
if (strncmp(p, para_name, para_length) != 0) {
return false;
}
if (para_offset != NULL) {
*para_offset = p - opt_line;
}
p += para_length;
while (isspace((unsigned char)*p)) {
p++;
}
/* If not '=', this opt_line's format is wrong in configure file */
if (*p != '=') {
return false;
}
p++;
/* Skip all the blanks after '=' and before the value */
while (isspace((unsigned char)*p)) {
p++;
}
q = p + 1;
tmp = q;
while (*q && !(*q == '\n' || *q == '#')) {
if (!isspace((unsigned char)*q)) {
/* End of string */
if (*q == '\'') {
tmp = ++q;
break;
} else {
tmp = ++q;
}
} else {
/*
* If para_name is a string, the ' ' is considered to
* be part of the string.
*/
(*p == '\'') ? tmp = ++q : q++;
}
}
if (value_offset != NULL) {
*value_offset = p - opt_line;
}
if (value_length != NULL) {
*value_length = (NULL == tmp) ? 0 : (tmp - p);
}
return true;
}
/*
* is_opt_line_commented - Check wether the option line is commented with '#'.
*
* Params:
* @opt_line: Line in the configure file.
*
* Returns:
* True, iff the option line starts with '#'; else false.
*/
static bool is_opt_line_commented(char* opt_line)
{
char* tmp = NULL;
if (opt_line == NULL) {
return false;
}
tmp = opt_line;
/* Skip all the blanks at the begin of the opt_line */
while (isspace((unsigned char)*tmp)) {
tmp++;
}
if (*tmp == '#') {
return true;
}
return 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}};
/*
* We have different sets for client and server message level options because
* they sort slightly different (see "log" level)
*/
static const struct config_enum_entry client_message_level_options[] = {{"debug", DEBUG2, true},
{"debug5", DEBUG5, false},
{"debug4", DEBUG4, false},
{"debug3", DEBUG3, false},
{"debug2", DEBUG2, false},
{"debug1", DEBUG1, false},
{"log", LOG, false},
{"info", INFO, true},
{"notice", NOTICE, false},
{"warning", WARNING, false},
{"error", ERROR, false},
{"fatal", FATAL, true},
{"panic", PANIC, true},
{NULL, 0, false}};
static const struct config_enum_entry server_message_level_options[] = {{"debug", DEBUG2, true},
{"debug5", DEBUG5, false},
{"debug4", DEBUG4, false},
{"debug3", DEBUG3, false},
{"debug2", DEBUG2, false},
{"debug1", DEBUG1, false},
{"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},
{"a", INTSTYLE_A, false},
{NULL, 0, false}};
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}};
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}};
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}};
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 io_priority_level_options[] = {{"None", IOPRIORITY_NONE, false},
{"Low", IOPRIORITY_LOW, false},
{"Medium", IOPRIORITY_MEDIUM, false},
{"High", IOPRIORITY_HIGH, false},
{NULL, 0, false}};
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}};
static const struct config_enum_entry xmlbinary_options[] = {
{"base64", XMLBINARY_BASE64, false}, {"hex", XMLBINARY_HEX, false}, {NULL, 0, false}};
static const struct config_enum_entry xmloption_options[] = {
{"content", XMLOPTION_CONTENT, false}, {"document", XMLOPTION_DOCUMENT, false}, {NULL, 0, false}};
/* change the char * sql_compatibility to enum */
static const struct config_enum_entry adapt_database[] = {{DBCOMPATIBILITY_A, A_FORMAT, false},
{DBCOMPATIBILITY_B, B_FORMAT, false},
{DBCOMPATIBILITY_C, C_FORMAT, false},
{NULL, 0, false}};
/* change the char * enable_performance_data to enum */
static const struct config_enum_entry explain_option[] = {{"normal", EXPLAIN_NORMAL, false},
{"pretty", EXPLAIN_PRETTY, false},
{"summary", EXPLAIN_SUMMARY, false},
{"run", EXPLAIN_RUN, false},
{NULL, 0, false}};
/* change the char * skew options to enum */
static const struct config_enum_entry skew_strategy_option[] = {
{"off", SKEW_OPT_OFF, false}, {"normal", SKEW_OPT_NORMAL, false}, {"lazy", SKEW_OPT_LAZY, false}, {NULL, 0, false}};
/* change the char * codegen_strategy to enum */
static const struct config_enum_entry codegen_strategy_option[] = {
{"partial", CODEGEN_PARTIAL, false}, {"pure", CODEGEN_PURE, false}, {NULL, 0, false}};
/* change the char * memory_tracking_mode to enum */
static const struct config_enum_entry memory_tracking_option[] = {{"none", MEMORY_TRACKING_NONE, false},
{"normal", MEMORY_TRACKING_NORMAL, false},
{"executor", MEMORY_TRACKING_EXECUTOR, false},
{"fullexec", MEMORY_TRACKING_FULLEXEC, false},
{NULL, 0, false}};
static const struct config_enum_entry resource_track_option[] = {{"none", RESOURCE_TRACK_NONE, false},
{"query", RESOURCE_TRACK_QUERY, false},
{"operator", RESOURCE_TRACK_OPERATOR, false},
{NULL, 0, false}};
/*
* 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 "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}};
#ifdef PGXC
/*
* Define remote connection types for PGXC
*/
static const struct config_enum_entry pgxc_conn_types[] = {{"application", REMOTE_CONN_APP, false},
{"coordinator", REMOTE_CONN_COORD, false},
{"datanode", REMOTE_CONN_DATANODE, false},
{"gtm", REMOTE_CONN_GTM, false},
{"gtmproxy", REMOTE_CONN_GTM_PROXY, false},
{"internaltool", REMOTE_CONN_INTERNAL_TOOL, false},
{"gtmtool", REMOTE_CONN_GTM_TOOL, false},
{NULL, 0, false}};
/* autovac mode */
static const struct config_enum_entry autovacuum_mode_options[] = {{"analyze", AUTOVACUUM_DO_ANALYZE, false},
{"vacuum", AUTOVACUUM_DO_VACUUM, false},
{"mix", AUTOVACUUM_DO_ANALYZE_VACUUM, false},
{"none", AUTOVACUUM_DO_NONE, false},
{NULL, 0, false}};
#endif
/*
* Although only "on", "off", "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_receive", SYNCHRONOUS_COMMIT_REMOTE_RECEIVE, false},
{"remote_write", SYNCHRONOUS_COMMIT_REMOTE_WRITE, 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},
{"2", SYNCHRONOUS_COMMIT_REMOTE_REPLAY, false},
{"remote_apply", SYNCHRONOUS_COMMIT_REMOTE_REPLAY, false},
{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}
};
/*
* define insert mode for dfs_insert
*/
static const struct config_enum_entry cstore_insert_mode_options[] = {
{"auto", TO_AUTO, true}, {"main", TO_MAIN, true}, {"delta", TO_DELTA, true}, {NULL, 0, false}};
static const struct config_enum_entry rewrite_options[] = {
{"none", NO_REWRITE, false}, {"lazyagg", LAZY_AGG, false}, {"magicset", MAGIC_SET, false}, {NULL, 0, false}};
static const struct config_enum_entry remote_read_options[] = {{"off", REMOTE_READ_OFF, false},
{"non_authentication", REMOTE_READ_NON_AUTH, false},
{"authentication", REMOTE_READ_AUTH, false},
{NULL, 0, false}};
static const struct config_enum_entry resource_track_log_options[] = {
{"summary", SUMMARY, false}, {"detail", DETAIL, false}, {NULL, 0, false}};
static const struct config_enum_entry opfusion_debug_level_options[] = {
{"off", BYPASS_OFF, false}, {"log", BYPASS_LOG, false}, {NULL, 0, false}};
static const struct config_enum_entry unique_sql_track_option[] = {
{"top", UNIQUE_SQL_TRACK_TOP, false}, {"all", UNIQUE_SQL_TRACK_ALL, true}, {NULL, 0, false}};
/*
* Options for enum values stored in other modules
*/
extern struct config_enum_entry wal_level_options[];
extern struct config_enum_entry sync_method_options[];
/*
* GUC option variables that are exported from this module
*/
#ifdef USE_ASSERT_CHECKING
THR_LOCAL bool assert_enabled = true;
#else
THR_LOCAL bool assert_enabled = false;
#endif
THR_LOCAL int log_min_messages = WARNING;
THR_LOCAL int client_min_messages = NOTICE;
THR_LOCAL bool force_backtrace_messages = false;
/*
* 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_BACKEND */ "backend",
/* PGC_SUSET */ "superuser",
/* PGC_USERSET */ "user"
};
/*
* 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_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"
};
/*
* 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 */
gettext_noop("Connections and Authentication"),
/* CONN_AUTH_SETTINGS */
gettext_noop("Connections and Authentication / Connection Settings"),
/* CONN_AUTH_SECURITY */
gettext_noop("Connections and Authentication / Security and Authentication"),
/* RESOURCES */
gettext_noop("Resource Usage"),
/* 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"),
/* RESOURCES_RECOVERY */
gettext_noop("Resource usage / Recovery"),
/* RESOURCES_WORKLOAD */
gettext_noop("Resource usage / Workload Scheduling"),
/* WAL */
gettext_noop("Write-Ahead Log"),
/* WAL_SETTINGS */
gettext_noop("Write-Ahead Log / Settings"),
/* WAL_CHECKPOINTS */
gettext_noop("Write-Ahead Log / Checkpoints"),
/* WAL_ARCHIVING */
gettext_noop("Write-Ahead Log / Archiving"),
/* REPLICATION */
gettext_noop("Replication"),
/* REPLICATION_SENDING */
gettext_noop("Replication / Sending Servers"),
/* REPLICATION_MASTER */
gettext_noop("Replication / Master Server"),
/* REPLICATION_STANDBY */
gettext_noop("Replication / Standby Servers"),
/* QUERY_TUNING */
gettext_noop("Query Tuning"),
/* 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 */
gettext_noop("Reporting and Logging"),
/* 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"),
/* AUDIT_OPTIONS */
gettext_noop("Audit Options"),
/* STATS */
gettext_noop("Statistics"),
/* STATS_MONITORING */
gettext_noop("Statistics / Monitoring"),
/* STATS_COLLECTOR */
gettext_noop("Statistics / Query and Index Statistics Collector"),
/* AUTOVACUUM */
gettext_noop("Autovacuum"),
/* JOB_ENABLE */
gettext_noop("Job Schedule"),
/* CLIENT_CONN */
gettext_noop("Client Connection Defaults"),
/* CLIENT_CONN_STATEMENT */
gettext_noop("Client Connection Defaults / Statement Behavior"),
/* CLIENT_CONN_LOCALE */
gettext_noop("Client Connection Defaults / Locale and Formatting"),
/* CLIENT_CONN_OTHER */
gettext_noop("Client Connection Defaults / Other Defaults"),
/* LOCK_MANAGEMENT */
gettext_noop("Lock Management"),
/* COMPAT_OPTIONS */
gettext_noop("Version and Platform Compatibility"),
/* 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"),
/* TEXT_SEARCH */
gettext_noop("Text Search Parser Options"),
/* DEVELOPER_OPTIONS */
gettext_noop("Developer Options"),
/* UPGRADE_OPTIONS */
gettext_noop("Upgrade Options"),
/* INSTRUMENTS_OPTIONS */
gettext_noop("Instruments Options"),
#ifdef PGXC
/* DATA_NODES */
gettext_noop("Datanodes and Connection Pooling"),
/* GTM */
gettext_noop("GTM Connection"),
/* COORDINATORS */
gettext_noop("Coordinator Options"),
/* XC_HOUSEKEEPING_OPTIONS */
gettext_noop("XC Housekeeping Options"),
#endif
/* help_config wants this array to be null-terminated */
NULL};
/*
* 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_INT64 */ "int64",
/* PGC_REAL */ "real",
/* PGC_STRING */ "string",
/* PGC_ENUM */ "enum"};
/*
* 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 option you must edit pg_dumpall.c to ensure
* it is not single quoted at dump time.
*/
static void init_configure_names_bool()
{
struct config_bool local_configure_names_bool[] = {
{
{
"raise_errors_if_no_files",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("raise errors if no files to be imported."),
NULL
},
&u_sess->attr.attr_storage.raise_errors_if_no_files,
false,
NULL,
NULL,
NULL
},
{
{
"enable_fast_numeric",
PGC_SUSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable numeric optimize."),
NULL
},
&u_sess->attr.attr_sql.enable_fast_numeric,
true,
NULL,
NULL,
NULL
},
{
{
"enable_wdr_snapshot",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Enable wdr snapshot"),
NULL
},
&u_sess->attr.attr_common.enable_wdr_snapshot,
false,
NULL,
NULL,
NULL
},
{
{
"enable_global_stats",
PGC_SUSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable global stats for analyze."),
NULL
},
&u_sess->attr.attr_sql.enable_global_stats,
true,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_hdfs_predicate_pushdown",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable hdfs predicate pushdown."),
NULL
},
&u_sess->attr.attr_sql.enable_hdfs_predicate_pushdown,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_absolute_tablespace",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop(" Enable tablespace using absolute location."),
NULL
},
&u_sess->attr.attr_sql.enable_absolute_tablespace,
true,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_hadoop_env",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop(" Enable hadoop enviroment."),
NULL
},
&u_sess->attr.attr_sql.enable_hadoop_env,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_valuepartition_pruning",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop(
"Enable optimization for partitioned DFS table to be staticly/dynamically-pruned when possible."),
NULL
},
&u_sess->attr.attr_sql.enable_valuepartition_pruning,
true,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_constraint_optimization",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable optimize query by using informational constraint."),
NULL
},
&u_sess->attr.attr_sql.enable_constraint_optimization,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_bloom_filter",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable bloom filter check"),
NULL
},
&u_sess->attr.attr_sql.enable_bloom_filter,
true,
NULL,
NULL,
NULL
},
{
{
"enable_codegen",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable llvm for executor."),
NULL
},
&u_sess->attr.attr_sql.enable_codegen,
true,
NULL,
NULL,
NULL
},
{
{
"enable_delta_store",
PGC_POSTMASTER,
QUERY_TUNING,
gettext_noop("Enable delta for column store."),
NULL
},
&g_instance.attr.attr_storage.enable_delta_store,
false,
NULL,
NULL,
NULL
},
{
{
"enable_incremental_catchup",
PGC_SIGHUP,
REPLICATION_STANDBY,
gettext_noop("Enable incremental searching bcm files when catchup."),
},
&u_sess->attr.attr_storage.enable_incremental_catchup,
true,
NULL,
NULL,
NULL
},
{
{
"enable_codegen_print",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable dump() for llvm function."),
NULL
},
&u_sess->attr.attr_sql.enable_codegen_print,
false,
NULL,
NULL,
NULL
},
{
{
"enable_sonic_optspill",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable Sonic optimized spill."),
NULL
},
&u_sess->attr.attr_sql.enable_sonic_optspill,
true,
NULL,
NULL,
NULL
},
{
{
"enable_sonic_hashjoin",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable Sonic hashjoin."),
NULL
},
&u_sess->attr.attr_sql.enable_sonic_hashjoin,
true,
NULL,
NULL,
NULL
},
{
{
"enable_sonic_hashagg",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable Sonic hashagg."),
NULL
},
&u_sess->attr.attr_sql.enable_sonic_hashagg,
true,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_csqual_pushdown",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("Enables colstore qual push down."),
NULL
},
&u_sess->attr.attr_sql.enable_csqual_pushdown,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_change_hjcost",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("Enable change hash join cost"),
NULL
},
&u_sess->attr.attr_sql.enable_change_hjcost,
false,
NULL,
NULL,
NULL
},
{
{
"enable_seqscan",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of sequential-scan plans."),
NULL
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.enable_bitmapscan,
true,
NULL,
NULL,
NULL
},
{
{
"force_bitmapand",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Force the planner's use of bitmap-and plans."),
NULL
},
&u_sess->attr.attr_sql.force_bitmapand,
false,
NULL,
NULL,
NULL
},
{
{
"enable_parallel_ddl",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Allow user to implement DDL parallel without dead lock."),
NULL
},
&u_sess->attr.attr_sql.enable_parallel_ddl,
true,
NULL,
NULL,
NULL
},
{
{
"enable_tidscan",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of TID-scan plans."),
NULL
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.enable_sort,
true,
NULL,
NULL,
NULL
},
{
{
"enable_compress_spill",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables spilling compress."),
NULL
},
&u_sess->attr.attr_sql.enable_compress_spill,
true,
NULL,
NULL,
NULL
},
{
{
"enable_hashagg",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of hashed aggregation plans."),
NULL
},
&u_sess->attr.attr_sql.enable_hashagg,
true,
NULL,
NULL,
NULL
},
{
{
"enable_material",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of materialization."),
NULL
},
&u_sess->attr.attr_sql.enable_material,
true,
NULL,
NULL,
NULL
},
{
{
"enable_nestloop",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of nested-loop join plans."),
NULL
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.enable_hashjoin,
true,
NULL,
NULL,
NULL
},
{
{
"enable_index_nestloop",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of index-nested join plans."),
NULL
},
&u_sess->attr.attr_sql.enable_index_nestloop,
true,
NULL,
NULL,
NULL
},
{
{
"enable_nodegroup_debug",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's node group debug mode."),
NULL
},
&u_sess->attr.attr_sql.enable_nodegroup_debug,
false,
NULL,
NULL,
NULL
},
{
{
"enable_partitionwise",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of partitionwise join plans."),
NULL
},
&u_sess->attr.attr_sql.enable_partitionwise,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_remotejoin",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of remote join plans."),
NULL
},
&u_sess->attr.attr_sql.enable_remotejoin,
true,
NULL,
NULL,
NULL
},
{
{
"enable_fast_query_shipping",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of fast query shipping to ship query directly to datanode."),
NULL
},
&u_sess->attr.attr_sql.enable_fast_query_shipping,
true,
NULL,
NULL,
NULL
},
{
{
"enable_compress_hll",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables hll use less memory on datanode."),
NULL
},
&u_sess->attr.attr_sql.enable_compress_hll,
false,
NULL,
NULL,
NULL
},
{
{
"enable_remotegroup",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of remote group plans."),
NULL
},
&u_sess->attr.attr_sql.enable_remotegroup,
true,
NULL,
NULL,
NULL
},
{
{
"enable_remotesort",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of remote sort plans."),
NULL
},
&u_sess->attr.attr_sql.enable_remotesort,
true,
NULL,
NULL,
NULL
},
{
{
"enable_remotelimit",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of remote limit plans."),
NULL
},
&u_sess->attr.attr_sql.enable_remotelimit,
true,
NULL,
NULL,
NULL
},
{
{
"gtm_backup_barrier",
PGC_SUSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables coordinator to report barrier id to GTM for backup."),
NULL
},
&u_sess->attr.attr_sql.gtm_backup_barrier,
false,
NULL,
NULL,
NULL
},
{
{
"enable_stream_operator",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of stream operator."),
NULL
},
&u_sess->attr.attr_sql.enable_stream_operator,
true,
NULL,
NULL,
NULL
},
{
{
"enable_unshipping_log",
PGC_USERSET,
LOGGING_WHEN,
gettext_noop("Enables output the unshipping log."),
NULL
},
&u_sess->attr.attr_sql.enable_unshipping_log,
true,
NULL,
NULL,
NULL
},
{
{
"enable_stream_concurrent_update",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables concurrent update under stream mode."),
NULL
},
&u_sess->attr.attr_sql.enable_stream_concurrent_update,
true,
NULL,
NULL,
NULL
},
{
{
"enable_stream_recursive",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of streaming plan for with-recursive"),
NULL
},
&u_sess->attr.attr_sql.enable_stream_recursive,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_vector_engine",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the vector engine."),
NULL
},
&u_sess->attr.attr_sql.enable_vector_engine,
true,
NULL,
NULL,
NULL
},
{
{
"enable_force_vector_engine",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Forces to enable the vector engine."),
NULL
},
&u_sess->attr.attr_sql.enable_force_vector_engine,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_random_datanode",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of random datanode."),
NULL
},
&u_sess->attr.attr_sql.enable_random_datanode,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"support_extended_features",
PGC_POSTMASTER,
DEVELOPER_OPTIONS,
gettext_noop("Enables unofficial supported extended features."),
NULL
},
&g_instance.attr.attr_common.support_extended_features,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"lastval_supported",
PGC_POSTMASTER,
DEVELOPER_OPTIONS,
gettext_noop("Enable functionality of lastval() function."),
NULL
},
&g_instance.attr.attr_common.lastval_supported,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_beta_features",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Enable features that ever supported in former version ."),
NULL
},
&u_sess->attr.attr_common.enable_beta_features,
false,
NULL,
NULL,
NULL
},
{
{
"string_hash_compatible",
PGC_POSTMASTER,
QUERY_TUNING,
gettext_noop("Enables the hash compatibility of char() and varchar() datatype"),
NULL
},
&g_instance.attr.attr_sql.string_hash_compatible,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_fstream",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("use stream operator to replace remotequery "),
NULL
},
&u_sess->attr.attr_sql.enable_fstream,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"geqo",
PGC_USERSET,
QUERY_TUNING_GEQO,
gettext_noop("Enables genetic query optimization."),
gettext_noop("This algorithm attempts to do planning without "
"exhaustive searching.")
},
&u_sess->attr.attr_sql.enable_geqo,
true,
NULL,
NULL,
NULL
},
{ /* Not for general use --- used by SET SESSION AUTHORIZATION */
{
"is_sysadmin",
PGC_INTERNAL,
UNGROUPED,
gettext_noop("Shows whether the current user is a system admin."),
NULL,
GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.session_auth_is_superuser,
false,
NULL,
NULL,
NULL
},
#ifdef USE_BONJOUR
{
{
"bonjour",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Enables advertising the server via Bonjour."),
NULL
},
&g_instance.attr.attr_common.enable_bonjour,
false,
check_bonjour,
NULL,
NULL
},
#endif
{
{
"ssl",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Enables SSL connections."),
NULL
},
&g_instance.attr.attr_security.EnableSSL,
false,
check_ssl,
NULL,
NULL
},
{
{
"require_ssl",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("Requires SSL connections."),
NULL
},
&u_sess->attr.attr_security.RequireSSL,
false,
check_ssl,
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 crashes.")
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_common.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 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
},
&u_sess->attr.attr_security.zero_damaged_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.")
},
&u_sess->attr.attr_storage.fullPageWrites,
true,
NULL,
NULL,
NULL
},
{
{
"wal_compression",
PGC_USERSET,
WAL_SETTINGS,
gettext_noop("Compresses full-page writes written in WAL file."),
NULL
},
&u_sess->attr.attr_storage.wal_compression,
false,
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 "
"modifications."),
NULL
},
&g_instance.attr.attr_storage.wal_log_hints,
true,
NULL,
NULL,
NULL
},
{
{
"log_checkpoints",
PGC_SIGHUP,
LOGGING_WHAT,
gettext_noop("Logs each checkpoint."),
NULL
},
&u_sess->attr.attr_common.log_checkpoints,
false,
NULL,
NULL,
NULL
},
{
{
"log_connections",
PGC_BACKEND,
LOGGING_WHAT,
gettext_noop("Logs each successful connection."),
NULL
},
&u_sess->attr.attr_storage.Log_connections,
false,
NULL,
NULL,
NULL
},
{
{
"log_disconnections",
PGC_BACKEND,
LOGGING_WHAT,
gettext_noop("Logs end of a session, including duration."),
NULL
},
&u_sess->attr.attr_common.Log_disconnections,
false,
NULL,
NULL,
NULL
},
{
{
"debug_assertions",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Turns on various assertion checks."),
gettext_noop("This is a debugging aid."),
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.assert_enabled,
#ifdef USE_ASSERT_CHECKING
true,
#else
false,
#endif
check_debug_assertions,
NULL,
NULL
},
{
/*
* security requirements: ordinary users can not set this parameter, promoting the setting level to PGC_SUSET.
*/
{
"exit_on_error",
PGC_SUSET,
ERROR_HANDLING_OPTIONS,
gettext_noop("Terminates session on any error."),
NULL
},
&u_sess->attr.attr_common.ExitOnAnyError,
false,
NULL,
NULL,
NULL
},
{
{
"restart_after_crash",
PGC_SIGHUP,
ERROR_HANDLING_OPTIONS,
gettext_noop("Reinitializes server after backend crashes."),
NULL
},
&u_sess->attr.attr_sql.restart_after_crash,
true,
NULL,
NULL,
NULL
},
// variable to enable memory pool
{
{
"memorypool_enable",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Using memory pool."),
NULL
},
&g_instance.attr.attr_memory.memorypool_enable,
false,
NULL,
NULL,
NULL
},
// variable to enable memory protect
{
{
"enable_memory_limit",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Using memory protect feature."),
NULL
},
&g_instance.attr.attr_memory.enable_memory_limit,
true,
NULL,
NULL,
show_enable_memory_limit
},
{
{
"enable_memory_context_control",
PGC_SIGHUP,
RESOURCES_MEM,
gettext_noop("check the max space size of memory context."),
NULL
},
&u_sess->attr.attr_memory.enable_memory_context_control,
false,
NULL,
NULL,
NULL
},
// variable to enable early free policy
{
{
"disable_memory_protect",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("disable memory protect for query execution."),
NULL
},
&u_sess->attr.attr_memory.disable_memory_protect,
false,
NULL,
NULL,
NULL
},
// variable to enable early free policy
{
{
"enable_early_free",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Using memory early free policy."),
NULL
},
&u_sess->attr.attr_sql.enable_early_free,
true,
NULL,
NULL,
NULL
},
// support to kill a working query when drop a user
{
/*
* security requirements: ordinary users can not set this parameter, promoting the setting level to PGC_SUSET.
*/
{
"enable_kill_query",
PGC_SUSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables cancelling a query that locks some relations owned by a user "
"when the user is dropped."),
NULL
},
&u_sess->attr.attr_sql.enable_kill_query,
false,
NULL,
NULL,
NULL
},
// omit untranslatable char error
{
{
"omit_encoding_error",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Omits encoding convert error."),
NULL
},
&u_sess->attr.attr_common.omit_encoding_error,
false,
NULL,
NULL,
NULL
},
{
{
"log_duration",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("Logs the duration of each completed SQL statement."),
NULL
},
&u_sess->attr.attr_sql.log_duration,
true,
NULL,
NULL,
NULL
},
{
{
"debug_print_parse",
PGC_SIGHUP,
LOGGING_WHAT,
gettext_noop("Logs each query's parse tree."),
NULL
},
&u_sess->attr.attr_sql.Debug_print_parse,
false,
NULL,
NULL,
NULL
},
{
{
"debug_print_rewritten",
PGC_SIGHUP,
LOGGING_WHAT,
gettext_noop("Logs each query's rewritten parse tree."),
NULL
},
&u_sess->attr.attr_sql.Debug_print_rewritten,
false,
NULL,
NULL,
NULL
},
{
{
"debug_print_plan",
PGC_SIGHUP,
LOGGING_WHAT,
gettext_noop("Logs each query's execution plan."),
NULL
},
&u_sess->attr.attr_sql.Debug_print_plan,
false,
NULL,
NULL,
NULL
},
{
{
"debug_pretty_print",
PGC_USERSET,
LOGGING_WHAT,
gettext_noop("Indents parse and plan tree displays."),
NULL
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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 on various B-tree operations."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_resource.log_btree_build_stats,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"track_activities",
PGC_SUSET,
STATS_COLLECTOR,
gettext_noop("Collects information about executing commands."),
gettext_noop("Enables the collection of information on the current "
"executing command of each session, along with "
"the time at which that command began execution.")
},
&u_sess->attr.attr_common.pgstat_track_activities,
true,
NULL,
NULL,
NULL
},
{
{
"enable_instr_track_wait",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Collects information about wait status."),
NULL
},
&u_sess->attr.attr_common.enable_instr_track_wait,
true,
NULL,
NULL,
NULL
},
{
{
"enable_instr_rt_percentile",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Calculate percentile info of sql responstime."),
NULL
},
&u_sess->attr.attr_common.enable_instr_rt_percentile,
true,
NULL,
NULL,
NULL
},
{
{
"enable_instr_cpu_timer",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Enables instruments cpu timer functionality."),
NULL
},
&u_sess->attr.attr_common.enable_instr_cpu_timer,
true,
NULL,
NULL,
NULL
},
{
{
"track_counts",
PGC_SUSET,
STATS_COLLECTOR,
gettext_noop("Collects statistics on database activity."),
NULL
},
&u_sess->attr.attr_common.pgstat_track_counts,
true,
NULL,
NULL,
NULL
},
{
{
"track_sql_count",
PGC_SUSET,
STATS_COLLECTOR,
gettext_noop("Collects query info on database activity."),
NULL
},
&u_sess->attr.attr_common.pgstat_track_sql_count,
true,
NULL,
NULL,
NULL
},
{
{
"track_io_timing",
PGC_SUSET,
STATS_COLLECTOR,
gettext_noop("Collects timing statistics for database I/O activity."),
NULL
},
&u_sess->attr.attr_common.track_io_timing,
false,
NULL,
NULL,
NULL
},
{
{
"update_process_title",
PGC_SUSET,
STATS_COLLECTOR,
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.")
},
&u_sess->attr.attr_common.update_process_title,
false,
NULL,
NULL,
NULL
},
{
{
"autovacuum",
PGC_SIGHUP,
AUTOVACUUM,
gettext_noop("Starts the autovacuum subprocess."),
NULL
},
&u_sess->attr.attr_storage.autovacuum_start_daemon,
true,
NULL,
NULL,
NULL
},
{
{
"enable_analyze_check",
PGC_SUSET,
STATS,
gettext_noop("Enable check if table is analyzed when querying."),
NULL
},
&u_sess->attr.attr_sql.enable_analyze_check,
true,
NULL,
NULL,
NULL
},
{
{
"autoanalyze",
PGC_SUSET,
STATS,
gettext_noop("Enable auto-analyze when querying tables with no statistic."),
NULL
},
&u_sess->attr.attr_sql.enable_autoanalyze,
false,
NULL,
NULL,
NULL
},
{
{
"cache_connection",
PGC_SIGHUP,
RESOURCES,
gettext_noop("pooler cache connection"),
NULL
},
&u_sess->attr.attr_common.pooler_cache_connection,
true,
NULL,
NULL,
NULL
},
{
{
"trace_notify",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Generates debugging output for LISTEN and NOTIFY."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.Trace_notify,
false,
NULL,
NULL,
NULL
},
#ifdef LOCK_DEBUG
{
{
"trace_locks",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("No description available."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.Trace_locks,
false,
NULL,
NULL,
NULL
},
{
{
"trace_userlocks",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("No description available."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.Trace_userlocks,
false,
NULL,
NULL,
NULL
},
{
{
"trace_lwlocks",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("No description available."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.Trace_lwlocks,
false,
NULL,
NULL,
NULL
},
{
{
"debug_deadlocks",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("No description available."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.Debug_deadlocks,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"log_lock_waits",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("Logs long lock waits."),
NULL
},
&u_sess->attr.attr_storage.log_lock_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.")
},
&u_sess->attr.attr_common.log_hostname,
true,
NULL,
NULL,
NULL
},
{
{
"sql_inheritance",
PGC_USERSET,
COMPAT_OPTIONS_PREVIOUS,
gettext_noop("Causes subtables to be included by default in various commands."),
NULL
},
&u_sess->attr.attr_sql.SQL_inheritance,
true,
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).")
},
&u_sess->attr.attr_sql.Transform_null_equals,
false,
NULL,
NULL,
NULL
},
{ /* only here for backwards compatibility */
{
"autocommit",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("This parameter doesn't do anything."),
gettext_noop("It's just here so that we won't choke on SET AUTOCOMMIT TO ON from 7.3-vintage clients."),
GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.phony_autocommit,
true,
check_phony_autocommit,
NULL,
NULL
},
{
/*
* security requirements: system/ordinary users can not set current transaction to read-only,
* promoting the setting level to database level.
*/
{
"default_transaction_read_only",
PGC_SIGHUP,
CLIENT_CONN_STATEMENT,
gettext_noop("Sets the default read-only status of new transactions."),
NULL
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.XactDeferrable,
false,
check_transaction_deferrable,
NULL,
NULL
},
{
{
"check_function_bodies",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Checks function bodies during CREATE FUNCTION."),
NULL
},
&u_sess->attr.attr_sql.check_function_bodies,
true,
NULL,
NULL,
NULL
},
{
{
"array_nulls",
PGC_USERSET,
COMPAT_OPTIONS_PREVIOUS,
gettext_noop("Enables 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.")
},
&u_sess->attr.attr_sql.Array_nulls,
true,
NULL,
NULL,
NULL
},
{
{
"default_with_oids",
PGC_USERSET,
COMPAT_OPTIONS_PREVIOUS,
gettext_noop("Creates new tables with OIDs by default."),
NULL
},
&u_sess->attr.attr_sql.default_with_oids,
false,
NULL,
NULL,
NULL
},
{
{
"logging_collector",
PGC_POSTMASTER,
LOGGING_WHERE,
gettext_noop("Starts a subprocess to capture stderr output and/or csvlogs into log files."),
NULL
},
&g_instance.attr.attr_common.Logging_collector,
false,
NULL,
NULL,
NULL
},
{
{
"log_truncate_on_rotation",
PGC_SIGHUP,
LOGGING_WHERE,
gettext_noop("Truncates existing log files of same name during log rotation."),
NULL
},
&u_sess->attr.attr_common.Log_truncate_on_rotation,
false,
NULL,
NULL,
NULL
},
#ifdef TRACE_SORT
{
{
"trace_sort",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Emits information about resource usage in sorting."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.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("Generates debugging output for synchronized scanning."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_resource.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("Enables bounded sorting using heap sort."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_sql.optimize_bounded_sort,
true,
NULL,
NULL,
NULL
},
#endif
#ifdef WAL_DEBUG
{
{
"wal_debug",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("Emits WAL-related debugging output."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.XLOG_DEBUG,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"integer_datetimes",
PGC_INTERNAL,
PRESET_OPTIONS,
gettext_noop("Datetimes are integer based."),
NULL,
GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.integer_datetimes,
#ifdef HAVE_INT64_TIMESTAMP
true,
#else
false,
#endif
NULL,
NULL,
NULL
},
{
{
"krb_caseins_users",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("Sets whether Kerberos and GSSAPI user names should be treated as case-insensitive."),
NULL
},
&u_sess->attr.attr_security.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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.standard_conforming_strings,
true,
NULL,
NULL,
NULL
},
{
{
"synchronize_seqscans",
PGC_USERSET,
COMPAT_OPTIONS_PREVIOUS,
gettext_noop("Enables synchronized sequential scans."),
NULL
},
&u_sess->attr.attr_storage.synchronize_seqscans,
true,
NULL,
NULL,
NULL
},
{
{
"archive_mode",
PGC_SIGHUP,
WAL_ARCHIVING,
gettext_noop("Allows archiving of WAL files using archive_command."),
NULL
},
&u_sess->attr.attr_common.XLogArchiveMode,
false,
NULL,
NULL,
NULL
},
{
{
"hot_standby",
PGC_POSTMASTER,
REPLICATION_STANDBY,
gettext_noop("Allows connections and queries during recovery."),
NULL
},
&g_instance.attr.attr_storage.EnableHotStandby,
false,
NULL,
NULL,
NULL
},
{
{
"enable_data_replicate",
PGC_USERSET,
REPLICATION_STANDBY,
gettext_noop("Allows data replicate."),
NULL
},
&u_sess->attr.attr_storage.enable_data_replicate,
true,
check_enable_data_replicate,
NULL,
NULL
},
{
{
"enable_mix_replication",
PGC_POSTMASTER,
REPLICATION,
gettext_noop("All the replication log sent by the wal streaming."),
NULL
},
&g_instance.attr.attr_storage.enable_mix_replication,
false,
check_mix_replication_param,
NULL,
NULL
},
{
{
"ha_module_debug",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("debug ha module."),
NULL
},
&u_sess->attr.attr_storage.HaModuleDebug,
false,
NULL,
NULL,
NULL
},
{
{
"enable_alarm",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("Enables alarm or not."),
NULL
},
&g_instance.attr.attr_common.enable_alarm,
false,
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
},
&u_sess->attr.attr_storage.hot_standby_feedback,
false,
NULL,
NULL,
NULL
},
{
{
"enable_stream_replication",
PGC_SIGHUP,
REPLICATION_STANDBY,
gettext_noop("Allows stream replication to standby or secondary."),
NULL
},
&u_sess->attr.attr_storage.enable_stream_replication,
true,
NULL,
NULL,
NULL
},
{
{
"allow_system_table_mods",
PGC_POSTMASTER,
DEVELOPER_OPTIONS,
gettext_noop("Allows modifications of the structure of system tables."),
NULL,
GUC_NOT_IN_SAMPLE
},
&g_instance.attr.attr_common.allowSystemTableMods,
false,
NULL,
NULL,
NULL
},
{
{
"IsInplaceUpgrade",
PGC_SUSET,
UPGRADE_OPTIONS,
gettext_noop("Enable/disable inplace upgrade mode."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_common.IsInplaceUpgrade,
false,
check_is_upgrade,
assign_is_inplace_upgrade,
NULL
},
{
{
"enable_roach_standby_cluster",
PGC_POSTMASTER,
REPLICATION,
gettext_noop("True if current instance is in ROACH standby cluster."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_storage.IsRoachStandbyCluster,
false,
NULL,
NULL,
NULL
},
{
{
"allow_concurrent_tuple_update",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Allows concurrent tuple update."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.allow_concurrent_tuple_update,
true,
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
},
&u_sess->attr.attr_common.IgnoreSystemIndexes,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"persistent_datanode_connections",
PGC_BACKEND,
DEVELOPER_OPTIONS,
gettext_noop("Session never releases acquired connections."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.PersistentConnections,
false,
NULL,
NULL,
NULL
},
{
{
"enable_force_reuse_connections",
PGC_BACKEND,
DEVELOPER_OPTIONS,
gettext_noop("Session force reuse pooler connections."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_network.PoolerForceReuse,
false,
NULL,
NULL,
NULL
},
{
{
"enable_stateless_pooler_reuse",
PGC_POSTMASTER,
DEVELOPER_OPTIONS,
gettext_noop("Pooler stateless reuse mode."),
NULL,
GUC_NOT_IN_SAMPLE
},
&g_instance.attr.attr_network.PoolerStatelessReuse,
false,
NULL,
NULL,
NULL
},
{
{
"comm_client_bind",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Whether client use bind function"),
NULL,
},
&u_sess->attr.attr_network.comm_client_bind,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enforce_two_phase_commit",
PGC_SUSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Enforces the use of two-phase commit on transactions that"
"made use of temporary objects."),
NULL
},
&u_sess->attr.attr_storage.EnforceTwoPhaseCommit,
true,
NULL,
NULL,
NULL
},
{
{
"xc_maintenance_mode",
PGC_SUSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Turns on XC maintenance mode."),
gettext_noop("Can set ON by SET command by system admin.")
},
&u_sess->attr.attr_common.xc_maintenance_mode,
false,
check_pgxc_maintenance_mode,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_gtm_free",
PGC_POSTMASTER,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Turns on gtm free mode."),
NULL
},
&g_instance.attr.attr_storage.enable_gtm_free,
false,
check_enable_gtm_free,
NULL,
NULL
},
{
{
"enable_twophase_commit",
PGC_USERSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Enable two phase commit when gtm free is on."),
NULL
},
&u_sess->attr.attr_storage.enable_twophase_commit,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_light_proxy",
PGC_SUSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Turns on light proxy on coordinator."),
NULL
},
&u_sess->attr.attr_sql.enable_light_proxy,
true,
NULL,
NULL,
NULL
},
{
{
"enable_pbe_optimization",
PGC_SUSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Turns on pbe optimization: force to reuse generic plan."),
NULL
},
&u_sess->attr.attr_sql.enable_pbe_optimization,
true,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_redistribute",
PGC_SUSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Enables redistribute at nodes mis-match."),
NULL
},
&u_sess->attr.attr_common.enable_redistribute,
false,
NULL,
NULL,
NULL
},
{
{
"enable_cluster_resize",
PGC_SUSET,
XC_HOUSEKEEPING_OPTIONS,
gettext_noop("Enables redistribute at nodes mis-match."),
NULL
},
&u_sess->attr.attr_sql.enable_cluster_resize,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"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.")
},
&u_sess->attr.attr_sql.lo_compat_privileges,
false,
NULL,
NULL,
NULL
},
{
{
"quote_all_identifiers",
PGC_USERSET,
COMPAT_OPTIONS_PREVIOUS,
gettext_noop("When generating SQL fragments, quotes all identifiers."),
NULL,
},
&u_sess->attr.attr_sql.quote_all_identifiers,
false,
NULL,
NULL,
NULL
},
{
{
"enforce_a_behavior",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("GUC parameter of enforcing adapting to A DB."),
NULL
},
&u_sess->attr.attr_sql.enforce_a_behavior,
true,
NULL,
NULL
},
{
{
"support_batch_bind",
PGC_SIGHUP,
CLIENT_CONN_LOCALE,
gettext_noop("Sets to use batch bind-execute for PBE."),
NULL
},
&u_sess->attr.attr_common.support_batch_bind,
true,
NULL,
NULL,
NULL
},
{
{
"enableSeparationOfDuty",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Enables the user's separation of privileges."),
NULL
},
&g_instance.attr.attr_security.enablePrivilegesSeparate,
false,
NULL,
NULL,
NULL
},
{
{
"enable_nonsysadmin_execute_direct",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("Enables non-sysadmin users execute direct on CN/DN."),
NULL
},
&g_instance.attr.attr_security.enable_nonsysadmin_execute_direct,
false,
NULL,
NULL,
NULL
},
{
{
"use_workload_manager",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Enables workload manager in the system. "),
NULL
},
&u_sess->attr.attr_resource.use_workload_manager,
true,
check_use_workload_manager,
assign_use_workload_manager,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"bypass_workload_manager",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("bypass workload manager in the system. "),
NULL
},
&u_sess->attr.attr_resource.bypass_workload_manager,
false,
NULL,
NULL,
NULL
},
{
{
"enable_dynamic_workload",
PGC_POSTMASTER,
RESOURCES_WORKLOAD,
gettext_noop("Enables dynamic workload manager in the system. "),
NULL
},
&g_instance.attr.attr_resource.enable_dynamic_workload,
true,
NULL,
NULL,
show_enable_dynamic_workload
},
{
{
"enable_acceleration_cluster_wlm",
PGC_POSTMASTER,
RESOURCES_WORKLOAD,
gettext_noop("Enables dynamic workload management in acceleration cluster. "
"Just for the compute pool, it doesn't work to enable the option for the DWS cluster."),
NULL
},
&g_instance.attr.attr_sql.enable_acceleration_cluster_wlm,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_slot_log",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables create slot log"),
NULL
},
&u_sess->attr.attr_sql.enable_slot_log,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_control_group",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Enables control group in the system. "),
NULL
},
&u_sess->attr.attr_resource.enable_control_group,
true,
NULL,
assign_control_group,
NULL
},
{
{
"enable_backend_control",
PGC_POSTMASTER,
RESOURCES_WORKLOAD,
gettext_noop("Enables workload manager to control backend thread. "),
NULL
},
&g_instance.attr.attr_resource.enable_backend_control,
true,
NULL,
NULL,
NULL
},
{
{
"enable_vacuum_control",
PGC_POSTMASTER,
RESOURCES_WORKLOAD,
gettext_noop("Enables workload manager to control vacuum thread. "),
NULL
},
&g_instance.attr.attr_resource.enable_vacuum_control,
true,
NULL,
NULL,
NULL
},
{
{
"enable_cgroup_switch",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Enables cgroup switch to TopWD. "),
NULL
},
&u_sess->attr.attr_resource.enable_cgroup_switch,
false,
NULL,
assign_enable_cgroup_switch,
NULL
},
#endif
{
{
"enable_resource_track",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable resources tracking and recording functionality in the system. "),
NULL
},
&u_sess->attr.attr_resource.enable_resource_track,
true,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_verify_active_statements",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable verify active statements. "),
NULL
},
&u_sess->attr.attr_resource.enable_verify_statements,
true,
NULL,
NULL,
NULL
},
{
{
"enable_force_memory_control",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable the resource pool memory control regardless of simple query. "),
NULL
},
&u_sess->attr.attr_resource.enable_force_memory_control,
false,
NULL,
NULL,
NULL
},
{
{
"enable_dywlm_adjust",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable dynamic adjust inaccurate resource value. "),
NULL
},
&u_sess->attr.attr_resource.enable_dywlm_adjust,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_resource_record",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable insert the session info into the user table. "),
NULL
},
&u_sess->attr.attr_resource.enable_resource_record,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_reaper_backend",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable reaper backend threads in a signal thread, not postmaster thread. "),
NULL
},
&u_sess->attr.attr_resource.enable_reaper_backend,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_bbox_dump",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Enables bbox_handler to create core dump. "),
NULL
},
&u_sess->attr.attr_common.enable_bbox_dump,
false,
NULL,
assign_bbox_coredump,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_perm_space",
PGC_POSTMASTER,
RESOURCES_WORKLOAD,
gettext_noop("enable perm space functionality in the system. "),
NULL
},
&g_instance.attr.attr_resource.enable_perm_space,
true,
NULL,
NULL,
NULL
},
{
{
"enable_transaction_parctl",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("consider transaction or stored procedure as simple or not. "),
NULL
},
&u_sess->attr.attr_resource.enable_transaction_parctl,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_thread_pool",
PGC_POSTMASTER,
CLIENT_CONN,
gettext_noop("enable to use thread pool. "),
NULL
},
&g_instance.attr.attr_common.enable_thread_pool,
false,
NULL,
NULL,
NULL
},
{
{
"enable_global_plancache",
PGC_POSTMASTER,
CLIENT_CONN,
gettext_noop("enable to use global plan cache. "),
NULL
},
&g_instance.attr.attr_common.enable_global_plancache,
false,
NULL,
NULL,
NULL
},
/* Database Security: Support database audit */
/* add guc option about audit */
{
{
"audit_enabled",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("Starts a subprocess to capture audit output into audit files."),
NULL
},
&u_sess->attr.attr_security.Audit_enabled,
true,
NULL,
NULL,
NULL
},
/* Database Security: Support database audit */
/* add guc option about audit */
{
{
"audit_resource_policy",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("the policy is used to determine how to cleanup the audit files;"
" True means to cleanup the audit files based on space limitation and"
" False means to cleanup the audit files when the remained time is arriving."),
NULL
},
&u_sess->attr.attr_security.Audit_CleanupPolicy,
true,
NULL,
NULL,
NULL
},
{
{
"modify_initial_password",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("modify the initial password of the initial user."),
NULL
},
&u_sess->attr.attr_security.Modify_initial_password,
false,
NULL,
NULL,
NULL
},
{
{
"most_available_sync",
PGC_POSTMASTER,
REPLICATION_MASTER,
gettext_noop("Enables master to continue as standalone on sync standbys failure."),
NULL,
},
&g_instance.attr.attr_storage.gucMostAvailableSync,
false,
NULL,
NULL,
NULL
},
{
{
"convert_string_to_digit",
PGC_USERSET,
UNGROUPED,
gettext_noop("Convert string to digit when comparing string and digit"),
NULL,
},
&u_sess->attr.attr_sql.convert_string_to_digit,
true,
NULL,
assign_convert_string_to_digit,
NULL
},
// Stream communication
{
{
"comm_tcp_mode",
PGC_POSTMASTER,
CLIENT_CONN,
gettext_noop("Whether use tcp commucation mode for stream"),
NULL,
},
&g_instance.attr.attr_network.comm_tcp_mode,
true,
check_sctp_support,
NULL,
NULL
},
{
{
"comm_debug_mode",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Whether use libcomm debug mode for print debug information"),
NULL,
},
&u_sess->attr.attr_network.comm_debug_mode,
#ifdef ENABLE_LLT
true,
#else
false,
#endif
NULL,
assign_comm_debug_mode,
NULL
},
{
{
"comm_stat_mode",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Whether use libcomm stat mode for print stat data"),
NULL,
},
&u_sess->attr.attr_network.comm_stat_mode,
#ifdef ENABLE_LLT
true,
#else
false,
#endif
NULL,
assign_comm_stat_mode,
NULL
},
{
{
"comm_timer_mode",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Whether use libcomm timer debug mode for print timer data"),
NULL,
},
&u_sess->attr.attr_network.comm_timer_mode,
#ifdef ENABLE_LLT
true,
#else
false,
#endif
NULL,
assign_comm_timer_mode,
NULL
},
{
{
"comm_no_delay",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Whether set NO_DELAY option for libcomm socket"),
NULL,
},
&u_sess->attr.attr_network.comm_no_delay,
false,
NULL,
assign_comm_no_delay,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
/* logic connection between cn & dn */
{
{
"comm_cn_dn_logic_conn",
PGC_POSTMASTER,
CLIENT_CONN,
gettext_noop("Whether use logic connection between cn and dn"),
NULL,
},
&g_instance.attr.attr_storage.comm_cn_dn_logic_conn,
false,
check_cn_dn_logic_support,
NULL,
NULL
},
{
{
"agg_redistribute_enhancement",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Whether choosing of agg redistribute key is enhanced"),
NULL,
},
&u_sess->attr.attr_sql.agg_redistribute_enhancement,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_show_any_tuples",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("This parameter is just valid when it's a read-only transction, just for analyse."
"The default_transaction_read_only and transaction_read_only should be true."
"You'd better keep enable_indexscan and enable_bitmapscan be false to keep seqscan occurs."
"When enable_show_any_tuples is true, all versions of the tuples are visible, including "
"dirty versions."),
NULL,
},
&u_sess->attr.attr_storage.enable_show_any_tuples,
false,
NULL,
NULL,
NULL
},
{
{
"enable_broadcast",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables the planner's use of broadcast stream plans."),
NULL
},
&u_sess->attr.attr_sql.enable_broadcast,
true,
NULL,
NULL,
NULL
},
{
{
"enable_debug_vacuum",
PGC_SIGHUP,
DEVELOPER_OPTIONS,
gettext_noop("This parameter is just used for logging some vacuum info."),
NULL,
},
&u_sess->attr.attr_storage.enable_debug_vacuum,
false,
NULL,
NULL,
NULL
},
{
{
"ngram_punctuation_ignore",
PGC_USERSET,
TEXT_SEARCH,
gettext_noop("Enables N-gram ignore punctuation."),
NULL,
},
&u_sess->attr.attr_sql.ngram_punctuation_ignore,
true,
NULL,
NULL,
NULL
},
{
{
"ngram_grapsymbol_ignore",
PGC_USERSET,
TEXT_SEARCH,
gettext_noop("Enables N-gram ignore grapsymbol."),
NULL,
},
&u_sess->attr.attr_sql.ngram_grapsymbol_ignore,
false,
NULL,
NULL,
NULL
},
{
{
"enable_fast_allocate",
PGC_SUSET,
UNGROUPED,
gettext_noop(
"enable fallocate to improve file extend performance, make sure filesystem support it, ep:XFS"),
NULL,
},
&u_sess->attr.attr_sql.enable_fast_allocate,
false,
NULL,
NULL,
NULL
},
{
{
"enable_adio_debug",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("Enable log debug adio function."),
NULL
},
&u_sess->attr.attr_storage.enable_adio_debug,
false,
NULL,
NULL,
NULL
},
{
{
"enable_adio_function",
PGC_POSTMASTER,
DEVELOPER_OPTIONS,
gettext_noop("Enable adio function."),
NULL
},
&g_instance.attr.attr_storage.enable_adio_function,
false,
NULL,
NULL,
NULL
},
{
{
"td_compatible_truncation",
PGC_USERSET,
QUERY_TUNING_OTHER,
gettext_noop("Enable string automatically truncated during insertion."),
NULL
},
&u_sess->attr.attr_sql.td_compatible_truncation,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"gds_debug_mod",
PGC_USERSET,
LOGGING_WHEN,
gettext_noop("Enable GDS-related troubleshoot-logging."),
NULL
},
&u_sess->attr.attr_storage.gds_debug_mod,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_upgrade_merge_lock_mode",
PGC_USERSET,
QUERY_TUNING_OTHER,
gettext_noop("If true, use Exclusive Lock mode for deltamerge."),
NULL
},
&u_sess->attr.attr_sql.enable_upgrade_merge_lock_mode,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_orc_cache",
PGC_POSTMASTER,
QUERY_TUNING_METHOD,
gettext_noop("Enable orc metadata cache."),
NULL
},
&g_instance.attr.attr_sql.enable_orc_cache,
true,
NULL,
NULL,
NULL
},
{
{
"acceleration_with_compute_pool",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("If true, agg/scan may run in compute pool."),
NULL
},
&u_sess->attr.attr_sql.acceleration_with_compute_pool,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_extrapolation_stats",
PGC_SUSET,
QUERY_TUNING_METHOD,
gettext_noop("Enable extrapolation stats for date datatype."),
NULL
},
&u_sess->attr.attr_sql.enable_extrapolation_stats,
false,
NULL,
NULL,
NULL
},
{
{
"data_sync_retry",
PGC_POSTMASTER,
ERROR_HANDLING_OPTIONS,
gettext_noop("Whether to continue running after a failure to sync data files."),
},
&g_instance.attr.attr_common.data_sync_retry,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_trigger_shipping",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Ship a trigger to DN if possible."),
NULL
},
&u_sess->attr.attr_sql.enable_trigger_shipping,
true,
NULL,
NULL,
NULL
},
{
{
"enable_agg_pushdown_for_ca",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Enable agg node pushdown for cooperation analysis."),
NULL
},
&u_sess->attr.attr_sql.enable_agg_pushdown_for_cooperation_analysis,
true,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_save_datachanged_timestamp",
PGC_USERSET,
UNGROUPED,
gettext_noop("If true, save the timestamp when the data of the table changes."),
NULL
},
&u_sess->attr.attr_sql.enable_save_datachanged_timestamp,
true,
NULL,
NULL,
NULL
},
{
{
"enable_online_ddl_waitlock",
PGC_SIGHUP,
UNGROUPED,
gettext_noop("Enable ddl wait advisory lock in online expansion."),
NULL
},
&u_sess->attr.attr_sql.enable_online_ddl_waitlock,
false,
NULL,
NULL,
NULL
},
{
{
"show_acce_estimate_detail",
PGC_USERSET,
UNGROUPED,
gettext_noop("If true, show details whether plan is pushed down to the compute pool."),
NULL
},
&u_sess->attr.attr_sql.show_acce_estimate_detail,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_cbm_tracking",
PGC_SIGHUP,
WAL,
gettext_noop("Turn on cbm tracking function. "),
NULL
},
&u_sess->attr.attr_storage.enable_cbm_tracking,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_copy_server_files",
PGC_SIGHUP,
UNGROUPED,
gettext_noop("enable sysadmin to copy from/to file"),
NULL
},
&u_sess->attr.attr_storage.enable_copy_server_files,
false,
NULL,
NULL,
NULL
},
{
{
"enable_user_metric_persistent",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable user resource info persistent function."),
NULL
},
&u_sess->attr.attr_resource.enable_user_metric_persistent,
true,
NULL,
NULL,
NULL
},
{
{
"enable_instance_metric_persistent",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable instance resource info persistent function."),
NULL
},
&u_sess->attr.attr_resource.enable_instance_metric_persistent,
true,
NULL,
NULL,
NULL
},
{
{
"enable_logical_io_statistics",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("enable logical io statistics function."),
NULL
},
&u_sess->attr.attr_resource.enable_logical_io_statistics,
true,
NULL,
NULL,
NULL
},
{
{
"enable_access_server_directory",
PGC_SIGHUP,
UNGROUPED,
gettext_noop("enable sysadmin to create directory"),
NULL
},
&g_instance.attr.attr_storage.enable_access_server_directory,
false,
NULL,
NULL,
NULL
},
{
{
"enable_opfusion",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables opfusion."),
NULL
},
&u_sess->attr.attr_sql.enable_opfusion,
true,
NULL,
NULL,
NULL
},
{
{
"enable_beta_opfusion",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables beta opfusion features."),
NULL
},
&u_sess->attr.attr_sql.enable_beta_opfusion,
false,
NULL,
NULL,
NULL
},
{
{
"enable_beta_nestloop_fusion",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Enables beta nestloop opfusion features."),
NULL
},
&u_sess->attr.attr_sql.enable_beta_nestloop_fusion,
false,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"enable_tsdb",
PGC_SIGHUP,
TSDB,
gettext_noop("Enables control tsdb feature."),
NULL
},
&u_sess->attr.attr_common.enable_tsdb,
false,
NULL,
NULL,
NULL
},
#endif
{
{
"enable_prevent_job_task_startup",
PGC_SIGHUP,
JOB,
gettext_noop("enable control whether the job task thread can be started."),
NULL
},
&u_sess->attr.attr_sql.enable_prevent_job_task_startup,
false,
NULL,
NULL,
NULL
},
{
{
"check_implicit_conversions",
PGC_USERSET,
UNGROUPED,
gettext_noop("check whether there is an implicit conversion on index column"),
NULL
},
&u_sess->attr.attr_common.check_implicit_conversions_for_indexcol,
false,
NULL,
NULL,
NULL
},
{
{
"enable_incremental_checkpoint",
PGC_POSTMASTER,
WAL_CHECKPOINTS,
gettext_noop("Enable master incremental checkpoint."),
NULL,
},
&g_instance.attr.attr_storage.enableIncrementalCheckpoint,
true,
NULL,
NULL,
NULL
},
{
{
"enable_double_write",
PGC_POSTMASTER,
WAL_CHECKPOINTS,
gettext_noop("Enable master double write."),
NULL,
},
&g_instance.attr.attr_storage.enable_double_write,
true,
NULL,
NULL,
NULL
},
{
{
"log_pagewriter",
PGC_SIGHUP,
LOGGING_WHAT,
gettext_noop("Logs pagewriter thread."),
NULL
},
&u_sess->attr.attr_storage.log_pagewriter,
false,
NULL,
NULL,
NULL
},
{
{
"enable_page_lsn_check",
PGC_POSTMASTER,
WAL,
gettext_noop("Enable check page lsn when redo"),
NULL,
},
&g_instance.attr.attr_storage.enableWalLsnCheck,
true,
NULL,
NULL,
NULL
},
{
{
"enable_xlog_prune",
PGC_SIGHUP,
WAL,
gettext_noop("xlog keep for all standbys even through they are not connect and donnot created replslot."),
NULL
},
&u_sess->attr.attr_storage.enable_xlog_prune,
true,
NULL,
NULL,
NULL
},
/* End-of-list marker */
{
{
NULL,
(GucContext)0,
(config_group)0,
NULL,
NULL
},
NULL,
false,
NULL,
NULL,
NULL
}
};
int num_of_bool_option = sizeof(local_configure_names_bool) / sizeof(config_bool);
for (int i = 0; i < num_of_bool_option - 1; i++) {
if (strcasecmp(local_configure_names_bool[i].gen.name, "enable_save_datachanged_timestamp") == 0 &&
get_product_version() == PRODUCT_VERSION_DBHTAP) {
local_configure_names_bool[i].boot_val = false;
break;
}
}
Size bytes = sizeof(local_configure_names_bool);
u_sess->utils_cxt.ConfigureNamesBool = (struct config_bool*)MemoryContextAlloc(u_sess->top_mem_cxt, bytes);
int rc = memcpy_s(u_sess->utils_cxt.ConfigureNamesBool, bytes, local_configure_names_bool, bytes);
securec_check(rc, "", "");
}
#ifdef ENABLE_QUNIT
/*
* This function is used to store an integer for every thread. we can use __thread to do this, but when we use it,
* GDB complains that it can not find thread local variables sometimes. So, we use this function to bind the integer to
* a thread.
*
* The main idea is that we store an integer on the thread's stack. Actually, the value is stored outside the stack,
* but next to the stack. So the value will not be overwritten when gaussdb is running.
*
* When a thread is started up, we set its stack's boundary to addresses ALIGNED with 16MB. So, no matter how much stack
* space a thread uses, we can find its stack's boundary easily. Just do this: (rsp/16MB + 1)*16MB. We store the value
* here.
*
* In Linux kernel, this method is used to implement current_thread_info(), please refer to the Linux kernel source code
* for more information.
*
* ____
* (K+1)*16MB -> |____| <- (rsp/16MB + 1)*16MB points here, we store the value here
* | |
* | | <- rsp may point here
* | |
* | |
* K*16MB -> |____|
*
* [K*16MB, (K+1)*16MB) is used by the stack. [(K+1)*16MB, (K+1)*16MB)+4] is not used by the stack, so we store
* the value at [(K+1)*16MB, (K+1)*16MB)+4].
*
* When we start a new thread, we allocate a space from K*16MB to (K+1)*16MB+4, and then [K*16MB, (K+1)*16MB) is
* used for the stack of the thread, [(K+1)*16MB, (K+1)*16MB)+4] is used for storing the integer bound to the stack.
* So, the stack's space and the integer's space are not overlapped.
*/
void set_qunit_case_number_hook(int newval, void* extra)
{
if (!IsUnderPostmaster)
return;
size_t size = DEFUALT_STACK_SIZE * 1024L;
Assert(!(size & (size - 1)));
long rsp;
__asm__("movq %%rsp, %0" : "=r"(rsp) :);
rsp = rsp / size + 1;
rsp = rsp * size;
*(int*)rsp = newval;
}
#endif
static void init_configure_names_int()
{
struct config_int local_configure_names_int[] = {
{
{
"max_active_global_temporary_table",
PGC_USERSET,
UNGROUPED,
gettext_noop("max active global temporary table."),
NULL
},
&u_sess->attr.attr_storage.max_active_gtt,
1000,
0,
1000000,
NULL,
NULL,
NULL
},
{
{
"vacuum_gtt_defer_check_age",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("The defer check age of GTT, used to check expired data after vacuum."),
NULL
},
&u_sess->attr.attr_storage.vacuum_gtt_defer_check_age,
10000,
0,
1000000,
NULL,
NULL,
NULL
},
{
{
"archive_timeout",
PGC_SIGHUP,
WAL_ARCHIVING,
gettext_noop("Forces a switch to the next xlog file if a "
"new file has not been started within N seconds."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_common.XLogArchiveTimeout,
0,
0,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"post_auth_delay",
PGC_BACKEND,
DEVELOPER_OPTIONS,
gettext_noop("Waits N seconds on connection startup after authentication."),
gettext_noop("This allows attaching a debugger to the process."),
GUC_NOT_IN_SAMPLE | GUC_UNIT_S
},
&u_sess->attr.attr_security.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 < 0 means using percent to set statistics.")
},
&u_sess->attr.attr_sql.default_statistics_target,
100,
-100,
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.")
},
&u_sess->attr.attr_sql.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.")
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.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.")
},
&u_sess->attr.attr_sql.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.")
},
&u_sess->attr.attr_sql.Geqo_generations,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"cost_param",
PGC_USERSET,
QUERY_TUNING_OTHER,
gettext_noop("Bitmap controls the use of alternative cost model."),
NULL
},
&u_sess->attr.attr_sql.cost_param,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"wait_dummy_time",
PGC_SIGHUP,
CUSTOM_OPTIONS,
gettext_noop("Wait for dummy starts or bcm file list received when catchup."),
},
&u_sess->attr.attr_storage.wait_dummy_time,
300,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"max_recursive_times",
PGC_USERSET,
QUERY_TUNING_OTHER,
gettext_noop("max recursive times when execute query with recursive-clause."),
NULL
},
&u_sess->attr.attr_sql.max_recursive_times,
200,
0,
INT_MAX,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"schedule_splits_threshold",
PGC_USERSET,
QUERY_TUNING_OTHER,
gettext_noop("The Max count of splits which can be scheduled in memory."),
NULL
},
&u_sess->attr.attr_sql.schedule_splits_threshold,
60000,
1,
INT_MAX,
NULL,
NULL,
NULL
},
#endif
{
/* 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
},
&u_sess->attr.attr_storage.DeadlockTimeout,
1000,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
/* This is PGC_SUSET to prevent hiding from log_lock_waits. */
{
"lockwait_timeout",
PGC_SUSET,
LOCK_MANAGEMENT,
gettext_noop("Sets the max time to wait on a lock acquire."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.LockWaitTimeout,
3000,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
/* This is PGC_SUSET to prevent hiding from log_lock_waits. */
{
"update_lockwait_timeout",
PGC_SUSET,
LOCK_MANAGEMENT,
gettext_noop("Sets the max time to wait on a lock acquire when concurrently update same tuple."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.LockWaitUpdateTimeout,
120000,
0,
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
},
&u_sess->attr.attr_storage.max_standby_archive_delay,
3 * 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
},
&u_sess->attr.attr_storage.max_standby_streaming_delay,
3 * 1000,
-1,
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 primary."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.wal_receiver_status_interval,
5,
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 master."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.wal_receiver_timeout,
6 * 1000,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"wal_receiver_connect_timeout",
PGC_SIGHUP,
REPLICATION_STANDBY,
gettext_noop("Sets the maximum wait time to connect master."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.wal_receiver_connect_timeout,
2,
0,
INT_MAX / 1000,
NULL,
NULL,
NULL
},
{
{
"wal_receiver_connect_retries",
PGC_SIGHUP,
REPLICATION_STANDBY,
gettext_noop("Sets the maximum retries to connect master."),
NULL
},
&u_sess->attr.attr_storage.wal_receiver_connect_retries,
1,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"wal_receiver_buffer_size",
PGC_POSTMASTER,
REPLICATION_STANDBY,
gettext_noop("Sets the buffer size to receive data from master."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_storage.WalReceiverBufSize,
64 * 1024,
4 * 1024,
1023 * 1024,
NULL,
NULL,
NULL
},
{
{
"data_replicate_buffer_size",
PGC_POSTMASTER,
REPLICATION_SENDING,
gettext_noop("Sets the buffer size of data replication."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_storage.DataQueueBufSize,
16 * 1024,
4 * 1024,
1023 * 1024,
NULL,
NULL,
NULL
},
{
{
"max_connections",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the maximum number of concurrent connections for clients."),
NULL
},
&g_instance.attr.attr_network.MaxConnections,
100,
1,
MAX_BACKENDS,
check_maxconnections,
NULL,
NULL
},
{
{
"max_inner_tool_connections",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the maximum number of concurrent connections for inner tools."),
NULL
},
&g_instance.attr.attr_network.maxInnerToolConnections,
10,
1,
MAX_BACKENDS,
CheckMaxInnerToolConnections,
NULL,
NULL
},
{
{
"sysadmin_reserved_connections",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the number of connection slots reserved for system admin."),
NULL
},
&g_instance.attr.attr_network.ReservedBackends,
3,
0,
MAX_BACKENDS,
NULL,
NULL,
NULL
},
{
{
"alarm_report_interval",
PGC_SIGHUP,
UNGROUPED,
gettext_noop("Sets the interval time between two alarm report."),
NULL
},
&u_sess->attr.attr_common.AlarmReportInterval,
10,
0,
INT_MAX,
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
},
&g_instance.attr.attr_storage.NBuffers,
1024,
16,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"hashagg_table_size",
PGC_USERSET,
QUERY_TUNING_OTHER,
gettext_noop("Sets the number of slot in the hash table."),
NULL
},
&u_sess->attr.attr_sql.hashagg_table_size,
0,
0,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"memorypool_size",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Sets the number of memory pool used by the server."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_memory.memorypool_size,
1024 * 512,
128 * 1024,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"max_process_memory",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Sets the maximum number of memory used by the process."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_memory.max_process_memory,
12 * 1024 * 1024,
2 * 1024 * 1024,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"session_statistics_memory",
PGC_SIGHUP,
RESOURCES_MEM,
gettext_noop("Sets the maximum number of session statistics memory used by the process."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_resource.session_statistics_memory,
5 * 1024,
5 * 1024,
INT_MAX,
check_statistics_memory_limit,
assign_statistics_memory,
NULL
},
{
{
"session_history_memory",
PGC_SIGHUP,
RESOURCES_MEM,
gettext_noop("Sets the maximum number of session history memory used by the process."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_resource.session_history_memory,
10 * 1024,
10 * 1024,
INT_MAX,
check_history_memory_limit,
assign_history_memory,
NULL
},
{
{
"udf_memory_limit",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Sets the maximum number of memory used by UDF Master and UDF Workers."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_sql.udf_memory_limit,
200 * 1024,
200 * 1024,
INT_MAX,
check_udf_memory_limit,
NULL,
NULL
},
{
{
"cstore_buffers",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Sets the number of CStore buffers used by the server."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_storage.cstore_buffers,
131072,
16384,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"max_loaded_cudesc",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the number of loaded cudesc per column."),
NULL
},
&u_sess->attr.attr_storage.max_loaded_cudesc,
1024,
100,
INT_MAX / 2,
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
},
&u_sess->attr.attr_storage.num_temp_buffers,
128,
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
},
&g_instance.attr.attr_network.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).)")
},
&g_instance.attr.attr_network.Unix_socket_permissions,
0700,
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).)")
},
&u_sess->attr.attr_common.Log_file_mode,
0600,
0000,
0777,
NULL,
NULL,
show_log_file_mode
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"hll_default_log2m",
PGC_USERSET,
UNGROUPED,
gettext_noop("Set parameter log2m in hll."),
gettext_noop("It's related to numbers of register and relative error.")
},
&u_sess->attr.attr_sql.g_default_log2m,
DEFAULT_LOG2M,
HLL_MIN_LOG2M,
HLL_MAX_LOG2M,
NULL,
NULL,
NULL
},
{
{
"hll_default_regwidth",
PGC_USERSET,
UNGROUPED,
gettext_noop("Set parameter regwidth in hll."),
gettext_noop("It's related to number of bits used per register, max cardinality and memory of hll.")
},
&u_sess->attr.attr_sql.g_default_regwidth,
DEFAULT_REGWIDTH,
HLL_MIN_REGWIDTH,
HLL_MAX_REGWIDTH,
NULL,
NULL,
NULL
},
{
{
"hll_default_sparseon",
PGC_USERSET,
UNGROUPED,
gettext_noop("Set parameter sparseon for hll."),
gettext_noop("hll use sparseon mode or not.")
},
&u_sess->attr.attr_sql.g_default_sparseon,
DEFAULT_SPARSEON,
HLL_MIN_SPARSEON,
HLL_MAX_SPARSEON,
NULL,
NULL,
NULL
},
{
{
"hll_max_sparse",
PGC_USERSET,
UNGROUPED,
gettext_noop("Set parameter max_sparse for hll"),
NULL
},
&u_sess->attr.attr_sql.g_max_sparse,
MAX_SPARSE,
HLL_MIN_MAX_SPARSE,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"max_active_statements",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets the maximum global active statements to be used for query."),
gettext_noop("This value is set to -1 as default. "),
},
&u_sess->attr.attr_resource.max_active_statements,
60,
-1,
INT_MAX,
NULL,
assign_active_statements,
NULL
},
{
{
"dynamic_memory_quota",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets the maximum memory quota for dynamic workload."),
gettext_noop("This value is set to 80 as default. "),
},
&u_sess->attr.attr_resource.dynamic_memory_quota,
80,
1,
100,
NULL,
assign_memory_quota,
NULL
},
{
{
"memory_fault_percent",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets the percent when memory allocation is failed."),
gettext_noop("This value is set to 0 as default and is used in debug version. "),
},
&u_sess->attr.attr_resource.memory_fault_percent,
0,
0,
MAX_MEMORY_FAULT_PERCENT,
NULL,
NULL,
NULL
},
#endif
{
{
"parctl_min_cost",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets the minimum cost to do parallel control."),
gettext_noop("This value is set to 1000000 as default. "),
},
&u_sess->attr.attr_resource.parctl_min_cost,
100000,
-1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"resource_track_cost",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets the minimum cost to do resource track."),
gettext_noop("This value is set to 1000000 as default."),
},
&u_sess->attr.attr_resource.resource_track_cost,
100000,
-1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"topsql_retention_time",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("the retention time of TopSql"),
gettext_noop("This value is set to 7 as default. "),
},
&u_sess->attr.attr_resource.topsql_retention_time,
0,
0,
3650,
NULL,
NULL,
NULL
},
{
{
"resource_track_duration",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets the minimum duration to record history session info."),
gettext_noop("This value is set to 60 secs as default."),
GUC_UNIT_S
},
&u_sess->attr.attr_resource.resource_track_duration,
60,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"user_metric_retention_time",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("the user resource info retention time."),
gettext_noop("This value is set to 7 as default. "),
},
&u_sess->attr.attr_resource.user_metric_retention_time,
7,
0,
3650,
NULL,
NULL,
NULL
},
{
{
"instance_metric_retention_time",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("the instance resource info retention time."),
gettext_noop("This value is set to 7 as default. "),
},
&u_sess->attr.attr_resource.instance_metric_retention_time,
7,
0,
3650,
NULL,
NULL,
NULL
},
{
{
"cpu_collect_timer",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets the maximum cpu collect time."),
gettext_noop("This value is set to 30 secs as default."),
},
&u_sess->attr.attr_resource.cpu_collect_timer,
30,
1,
INT_MAX,
NULL,
assign_collect_timer,
NULL
},
{
{
"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
},
&u_sess->attr.attr_memory.work_mem,
64 * 1024,
64,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
{
{
"UDFWorkerMemHardLimit",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Sets the hard memory limit to be used for fenced UDF."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_sql.UDFWorkerMemHardLimit,
1 * 1024 * 1024,
0,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
{
{
"FencedUDFMemoryLimit",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the maximum memory to be used for fenced UDF by user."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_sql.FencedUDFMemoryLimit,
0,
0,
MAX_KILOBYTES,
check_fencedUDFMemoryLimit,
NULL,
NULL
},
{
{
"query_mem",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the memory to be reserved for a statement."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_sql.statement_mem,
0,
0,
MAX_KILOBYTES,
check_statement_mem,
NULL,
NULL
},
{
{
"query_max_mem",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the max memory to be reserved for a statement."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_sql.statement_max_mem,
0,
0,
MAX_KILOBYTES,
check_statement_max_mem,
NULL,
NULL
},
{
{
"bbox_dump_count",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets the maximum number of core dump created by bbox_handler."),
gettext_noop("This value is set to 8 as default. "),
},
&u_sess->attr.attr_common.bbox_dump_count,
8,
1,
20,
NULL,
NULL,
NULL
},
{
{
"io_limits",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets io_limit for each query."),
gettext_noop("This value is set to 0 as default. "),
},
&u_sess->attr.attr_resource.iops_limits,
0,
0,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"io_control_unit",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets the io control unit for reading or writing row tuple."),
gettext_noop("This value is set to 6000 as default. "),
},
&u_sess->attr.attr_resource.io_control_unit,
IOCONTROL_UNIT,
1000,
1000000,
NULL,
NULL,
NULL
},
{
{
"autovacuum_io_limits",
PGC_SIGHUP,
RESOURCES_WORKLOAD,
gettext_noop("Sets io_limit for autovacum."),
gettext_noop("This value is set to 0 as default. "),
},
&u_sess->attr.attr_resource.autovac_iops_limits,
-1,
-1,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"transaction_pending_time",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets pend_time for transaction or Stored Procedure."),
gettext_noop("This value is set to 60 as default. "),
},
&u_sess->attr.attr_resource.transaction_pending_time,
0,
-1,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"psort_work_mem",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the maximum memory to be used for partial sort."),
gettext_noop("This much memory can be used by each internal "
"partial sort operation before switching to "
"temporary disk files."),
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.psort_work_mem,
512 * 1024,
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
},
&u_sess->attr.attr_memory.maintenance_work_mem,
16384,
1024,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
{
{
"bulk_write_ring_size",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Size of bulk write buffer ring."),
gettext_noop("size of bulk write buffer ring, default values is "
"16M."),
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.bulk_write_ring_size,
16384,
16384,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
{
{
"bulk_read_ring_size",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Size of bulk read buffer ring."),
gettext_noop("size of bulk read buffer ring, default values is "
"256K."),
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.bulk_read_ring_size,
16384,
256,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
{
{
"partition_mem_batch",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Number of partition in-memory batch"),
gettext_noop("number of partition in-memory batch, default values is "
"256.")
},
&u_sess->attr.attr_storage.partition_mem_batch,
256,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"partition_max_cache_size",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("The max partition cache size for cstore when do insert"),
gettext_noop("the max partition cache size for cstore when do insert, default values is "
"2097152KB."),
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.partition_max_cache_size,
2097152,
4096,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"walsender_max_send_size",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Size of walsender max send size."),
gettext_noop("size of walsender max send size, default values is "
"8M."),
GUC_UNIT_KB
},
&g_instance.attr.attr_storage.MaxSendSize,
8192,
8,
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
},
&u_sess->attr.attr_common.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 session."),
gettext_noop("-1 means no limit."),
GUC_UNIT_KB
},
&u_sess->attr.attr_sql.temp_file_limit,
-1,
-1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"sql_use_spacelimit",
PGC_USERSET,
RESOURCES_DISK,
gettext_noop("Limit the single sql used space on a single DN."),
gettext_noop("-1 means no limit."),
GUC_UNIT_KB
},
&u_sess->attr.attr_resource.sqlUseSpaceLimit,
NO_LIMIT_SIZE,
NO_LIMIT_SIZE,
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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.VacuumCostPageMiss,
10,
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
},
&u_sess->attr.attr_storage.VacuumCostPageDirty,
20,
0,
10000,
NULL,
NULL,
NULL
},
{
{
"vacuum_cost_limit",
PGC_USERSET,
RESOURCES_VACUUM_DELAY,
gettext_noop("Vacuum cost amount available before napping."),
NULL
},
&u_sess->attr.attr_storage.VacuumCostLimit,
200,
1,
10000,
NULL,
NULL,
NULL
},
{
{
"vacuum_cost_delay",
PGC_USERSET,
RESOURCES_VACUUM_DELAY,
gettext_noop("Vacuum cost delay in milliseconds."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.autovacuum_vac_cost_delay,
20,
-1,
100,
NULL,
NULL,
NULL
},
{
{
"autovacuum_vacuum_cost_limit",
PGC_SIGHUP,
AUTOVACUUM,
gettext_noop("Vacuum cost amount available before napping, for autovacuum."),
NULL
},
&u_sess->attr.attr_storage.autovacuum_vac_cost_limit,
-1,
-1,
10000,
NULL,
NULL,
NULL
},
{
{
"gs_clean_timeout",
PGC_SIGHUP,
STATS_MONITORING,
gettext_noop("Sets the timeout to call gs_clean."),
gettext_noop("A value of 0 turns off the timeout."),
GUC_UNIT_S
},
&u_sess->attr.attr_storage.gs_clean_timeout,
300,
0,
INT_MAX / 1000,
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
},
&g_instance.attr.attr_common.max_files_per_process,
1000,
25,
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
},
&g_instance.attr.attr_storage.max_prepared_xacts,
#ifdef PGXC
10,
0,
INT_MAX / 4,
NULL,
NULL,
NULL
#else
0,
0,
MAX_BACKENDS,
NULL,
NULL,
NULL
#endif
},
{
{
"twophase_clean_workers",
PGC_SIGHUP,
RESOURCES_KERNEL,
gettext_noop("Sets the parallel job number of gs_clean to clean prepared transactions."),
NULL
},
&u_sess->attr.attr_storage.twophase_clean_workers,
3,
1,
10,
NULL,
NULL,
NULL
},
#ifdef LOCK_DEBUG
{
{
"trace_lock_oidmin",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("No description available."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.Trace_lock_oidmin,
FirstNormalObjectId,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"trace_lock_table",
PGC_SUSET,
DEVELOPER_OPTIONS,
gettext_noop("No description available."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.Trace_lock_table,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
#endif
{
{
"max_query_retry_times",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Sets the maximum sql retry times."),
gettext_noop("A value of 0 turns off the retry."),
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.max_query_retry_times,
0,
0,
20,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"RepOriginId",
PGC_USERSET,
REPLICATION_STANDBY,
gettext_noop("RepOriginId."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.replorigin_sesssion_origin,
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
},
&u_sess->attr.attr_common.StatementTimeout,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"session_timeout",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Set the maximum allowed duration of any unused session."),
gettext_noop("A value of 0 turns off the timeout."),
GUC_UNIT_S
},
&u_sess->attr.attr_common.SessionTimeout,
600,
0,
MAX_SESSION_TIMEOUT,
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.")
},
&g_instance.attr.attr_storage.max_locks_per_xact,
256,
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.")
},
&g_instance.attr.attr_storage.max_predicate_locks_per_xact,
64,
10,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"authentication_timeout",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("Sets the maximum allowed time to complete client authentication."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_security.AuthenticationTimeout,
60,
1,
600,
NULL,
NULL,
NULL
},
{
/* Not for general use */
{
"pre_auth_delay",
PGC_SIGHUP,
DEVELOPER_OPTIONS,
gettext_noop("Waits N seconds on connection startup before authentication."),
gettext_noop("This allows attaching a debugger to the process."),
GUC_NOT_IN_SAMPLE | GUC_UNIT_S
},
&u_sess->attr.attr_security.PreAuthDelay,
0,
0,
60,
NULL,
NULL,
NULL
},
{
{
"wal_keep_segments",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the number of WAL files held for standby servers."),
NULL
},
&u_sess->attr.attr_storage.wal_keep_segments,
16,
2,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"checkpoint_segments",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Sets the maximum distance in log segments between automatic WAL checkpoints."),
NULL
},
&u_sess->attr.attr_storage.CheckPointSegments,
64,
1,
INT_MAX - 1,
NULL,
NULL,
NULL
},
{
{
"checkpoint_timeout",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Sets the maximum time between automatic WAL checkpoints."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.fullCheckPointTimeout,
900,
30,
3600,
NULL,
NULL,
NULL
},
{
{
"checkpoint_warning",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Enables warnings if checkpoint segments are filled more "
"frequently than this."),
gettext_noop("Writes a message to the server log if checkpoints "
"caused by the filling of checkpoint segment files happens more "
"frequently than this number of seconds. Zero turns off the warning."),
GUC_UNIT_S
},
&u_sess->attr.attr_storage.CheckPointWarning,
300,
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
},
&u_sess->attr.attr_storage.checkpoint_flush_after,
DEFAULT_CHECKPOINT_FLUSH_AFTER,
0,
WRITEBACK_MAX_PENDING_FLUSHES,
NULL,
NULL,
NULL
},
{
{
"xloginsert_locks",
PGC_POSTMASTER,
WAL_SETTINGS,
gettext_noop("Sets the number of locks used for concurrent xlog insertions."),
NULL,
GUC_NOT_IN_SAMPLE
},
&g_instance.attr.attr_storage.num_xloginsert_locks,
8,
1,
1000,
NULL,
NULL,
NULL
},
{
{
"advance_xlog_file_num",
PGC_POSTMASTER,
WAL_SETTINGS,
gettext_noop("Sets the number of xlog files to be initialized in advance."),
NULL,
GUC_NOT_IN_SAMPLE
},
&g_instance.attr.attr_storage.advance_xlog_file_num,
0,
0,
100,
NULL,
NULL,
NULL
},
{
{
"checkpoint_wait_timeout",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Sets the maximum wait timeout for checkpointer to start."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.CheckPointWaitTimeOut,
60,
2,
3600,
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
},
&g_instance.attr.attr_storage.XLOGbuffers,
2048,
-1,
(INT_MAX / XLOG_BLCKSZ),
check_wal_buffers,
NULL,
NULL
},
{
{
"wal_writer_delay",
PGC_SIGHUP,
WAL_SETTINGS,
gettext_noop("WAL writer sleep time between WAL flushes."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.WalWriterDelay,
200,
1,
10000,
NULL,
NULL,
NULL
},
{
/* see max_connections */
{
"max_wal_senders",
PGC_POSTMASTER,
REPLICATION_SENDING,
gettext_noop("Sets the maximum number of simultaneously running WAL sender processes."),
NULL
},
&g_instance.attr.attr_storage.max_wal_senders,
4,
0,
MAX_BACKENDS,
NULL,
NULL,
NULL
},
{
/* see max_connections */
{
"max_replication_slots",
PGC_POSTMASTER,
REPLICATION_SENDING,
gettext_noop("Sets the maximum number of simultaneously defined replication slots."),
NULL
},
&g_instance.attr.attr_storage.max_replication_slots,
8,
0,
MAX_BACKENDS /* XXX? */,
NULL,
NULL,
NULL
},
{
{
"recovery_time_target",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("The target redo time in seconds for recovery"),
NULL
},
&u_sess->attr.attr_storage.target_rto,
0,
0,
3600,
NULL,
NULL,
NULL
},
{
{
"wal_sender_timeout",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the maximum time to wait for WAL replication."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.wal_sender_timeout,
6 * 1000,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"replication_type",
PGC_POSTMASTER,
WAL_SETTINGS,
gettext_noop("Sets the dn's HA mode."),
NULL
},
&g_instance.attr.attr_storage.replication_type,
RT_WITH_DUMMY_STANDBY,
RT_WITH_DUMMY_STANDBY,
RT_NUM,
check_replication_type,
NULL,
NULL
},
{
{
"commit_delay",
PGC_USERSET,
WAL_SETTINGS,
gettext_noop("Sets the delay in microseconds between transaction commit and "
"flushing WAL to disk."),
NULL
},
&u_sess->attr.attr_storage.CommitDelay,
0,
0,
100000,
NULL,
NULL,
NULL
},
{
{
"partition_lock_upgrade_timeout",
PGC_USERSET,
LOCK_MANAGEMENT,
gettext_noop("Sets the timeout for partition lock upgrade, in seconds"),
NULL
},
&u_sess->attr.attr_storage.partition_lock_upgrade_timeout,
1800,
-1,
3000,
NULL,
NULL,
NULL
},
{
{
"track_thread_wait_status_interval",
PGC_SUSET,
STATS_COLLECTOR,
gettext_noop("Sets the interval for collecting thread status in pgstat thread, in minute"),
NULL,
GUC_UNIT_MIN
},
&u_sess->attr.attr_common.pgstat_collect_thread_status_interval,
30,
0,
24 * 60,
NULL,
NULL,
NULL
},
{
{
"instr_rt_percentile_interval",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Sets the interval for calculating percentile in pgstat thread, in seconds"),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_common.instr_rt_percentile_interval,
10,
0,
60 * 60,
NULL,
NULL,
NULL
},
{
{
"wdr_snapshot_interval",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Sets the interval for wdr snapshot in snapshot thread, in min"),
NULL,
GUC_UNIT_MIN
},
&u_sess->attr.attr_common.wdr_snapshot_interval,
60,
10,
60,
NULL,
NULL,
NULL
},
{
{
"wdr_snapshot_retention_days",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Sets the max time span for wdr snapshot, in seconds"),
NULL
},
&u_sess->attr.attr_common.wdr_snapshot_retention_days,
8,
1,
8,
NULL,
NULL,
NULL
},
{
{
"wdr_snapshot_query_timeout",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Sets the timeout for wdr snapshot query, in seconds"),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_common.wdr_snapshot_query_timeout,
100,
100,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"commit_siblings",
PGC_USERSET,
WAL_SETTINGS,
gettext_noop("Sets the minimum concurrent open transactions before performing "
"commit_delay."),
NULL
},
&u_sess->attr.attr_storage.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. "
"The parameter value is added to the standard number of digits "
"(FLT_DIG or DBL_DIG as appropriate).")
},
&u_sess->attr.attr_common.extra_float_digits,
0,
-15,
3,
NULL,
NULL,
NULL
},
{
{
"log_min_duration_statement",
PGC_SUSET,
LOGGING_WHEN,
gettext_noop("Sets the minimum execution time above which "
"statements will be logged."),
gettext_noop("Zero prints all queries. -1 turns this feature off."),
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.Log_autovacuum_min_duration,
-1,
-1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"bgwriter_delay",
PGC_SIGHUP,
RESOURCES_BGWRITER,
gettext_noop("Background writer sleep time between rounds."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.BgWriterDelay,
10000,
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
},
&u_sess->attr.attr_storage.bgwriter_lru_maxpages,
100,
0,
1000,
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
},
&u_sess->attr.attr_storage.bgwriter_flush_after,
DEFAULT_BGWRITER_FLUSH_AFTER,
0,
WRITEBACK_MAX_PENDING_FLUSHES,
NULL,
NULL,
NULL
},
{
{
"effective_io_concurrency",
#ifdef USE_PREFETCH
PGC_USERSET,
#else
PGC_INTERNAL,
#endif
RESOURCES_ASYNCHRONOUS,
gettext_noop("Number of simultaneous requests that can be handled efficiently by the disk subsystem."),
gettext_noop("For RAID arrays, this should be approximately the number of drive spindles in the array.")
},
&u_sess->attr.attr_common.effective_io_concurrency,
#ifdef USE_PREFETCH
1,
0,
1000,
#else
0,
0,
0,
#endif
check_effective_io_concurrency,
assign_effective_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
},
&u_sess->attr.attr_common.backend_flush_after,
DEFAULT_BACKEND_FLUSH_AFTER,
0,
WRITEBACK_MAX_PENDING_FLUSHES,
NULL,
NULL,
NULL
},
{
{
"log_rotation_age",
PGC_SIGHUP,
LOGGING_WHERE,
gettext_noop("Automatic log file rotation will occur after N minutes."),
NULL,
GUC_UNIT_MIN
},
&u_sess->attr.attr_common.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("Automatic log file rotation will occur after N kilobytes."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.max_identifier_length,
NAMEDATALEN - 1,
NAMEDATALEN - 1,
NAMEDATALEN - 1,
NULL,
NULL,
NULL
},
{
{
"max_user_defined_exception",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("GUC parameter of max_user_defined_exception."),
NULL
},
&u_sess->attr.attr_common.max_user_defined_exception,
1000,
1000,
1000,
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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.wal_block_size,
XLOG_BLCKSZ,
XLOG_BLCKSZ,
XLOG_BLCKSZ,
NULL,
NULL,
NULL
},
{
{
"wal_segment_size",
PGC_INTERNAL,
PRESET_OPTIONS,
gettext_noop("Shows the number of pages per write ahead log segment."),
NULL,
GUC_UNIT_XBLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_storage.wal_segment_size,
(XLOG_SEG_SIZE / XLOG_BLCKSZ),
(XLOG_SEG_SIZE / XLOG_BLCKSZ),
(XLOG_SEG_SIZE / XLOG_BLCKSZ),
NULL,
NULL,
NULL
},
{
{
"autovacuum_naptime",
PGC_SIGHUP,
AUTOVACUUM,
gettext_noop("Time to sleep between autovacuum runs."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.autovacuum_naptime,
600,
1,
INT_MAX / 1000,
NULL,
NULL,
NULL
},
{
{
"autoanalyze_timeout",
PGC_SIGHUP,
AUTOVACUUM,
gettext_noop("Sets the timeout for auto-analyze action."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.autoanalyze_timeout,
300,
0,
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
},
&u_sess->attr.attr_storage.autovacuum_vac_thresh,
50,
0,
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
},
&u_sess->attr.attr_storage.autovacuum_anl_thresh,
50,
0,
INT_MAX,
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
},
&g_instance.attr.attr_storage.autovacuum_max_workers,
3,
0,
MAX_BACKENDS,
check_autovacuum_max_workers,
NULL,
NULL
},
{
{
"job_queue_processes",
PGC_POSTMASTER,
JOB,
gettext_noop("Number of concurrent jobs, optional: [1...1000], default: 10."),
NULL
},
&g_instance.attr.attr_sql.job_queue_processes,
DEFAULT_JOB_QUEUE_PROCESSES,
MIN_JOB_QUEUE_PROCESSES,
MAX_JOB_QUEUE_PROCESSES,
check_job_max_workers,
NULL,
NULL
},
{
{
"tcp_keepalives_idle",
PGC_USERSET,
CLIENT_CONN_OTHER,
gettext_noop("Time between issuing TCP keepalives."),
gettext_noop("A value of 0 uses the system default."),
GUC_UNIT_S
},
&u_sess->attr.attr_common.tcp_keepalives_idle,
60,
0,
3600,
NULL,
NULL,
NULL
},
{
{
"tcp_keepalives_interval",
PGC_USERSET,
CLIENT_CONN_OTHER,
gettext_noop("Time between TCP keepalive retransmits."),
gettext_noop("A value of 0 uses the system default."),
GUC_UNIT_S
},
&u_sess->attr.attr_common.tcp_keepalives_interval,
30,
0,
180,
NULL,
NULL,
NULL
},
{
{
"tcp_recv_timeout",
PGC_USERSET,
CLIENT_CONN_OTHER,
gettext_noop("Specify the receiving timeouts until reporting an error."),
gettext_noop("A value of 0 means never timeout."),
GUC_UNIT_S
},
&u_sess->attr.attr_common.tcpRecvTimeout,
0,
0,
86400,
NULL,
NULL,
NULL
},
{
{
"ssl_renegotiation_limit",
PGC_USERSET,
CONN_AUTH_SECURITY,
gettext_noop("SSL renegotiation is no longer supported, no matter what value is set."),
NULL,
GUC_UNIT_KB,
},
&u_sess->attr.attr_security.ssl_renegotiation_limit,
0,
0,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
{
{
"tcp_keepalives_count",
PGC_USERSET,
CLIENT_CONN_OTHER,
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."),
},
&u_sess->attr.attr_common.tcp_keepalives_count,
20,
0,
100,
NULL,
NULL,
NULL
},
{
{
"password_policy",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("The password complexity-policy of the database system."),
gettext_noop("This controls the complexity-policy of database system. "
"A value of 1 uses the system default."),
},
&u_sess->attr.attr_security.Password_policy,
1,
0,
1,
check_int_parameter,
NULL,
NULL
},
{
{
"password_encryption_type",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("The encryption method of password."),
gettext_noop("This controls the encryption type of the password. "
"A value of 2 uses the system default."),
},
&u_sess->attr.attr_security.Password_encryption_type,
2,
0,
2,
check_int_parameter,
NULL,
NULL
},
{
{
"gin_fuzzy_search_limit",
PGC_USERSET,
CLIENT_CONN_OTHER,
gettext_noop("Sets the maximum allowed result for exact search by GIN."),
NULL,
0
},
&u_sess->attr.attr_common.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 size of the disk cache."),
gettext_noop("That is, the portion of the kernel's disk cache that "
"will be used for PostgreSQL data files. This is measured in disk "
"pages, which are normally 8 kB each."),
GUC_UNIT_BLOCKS,
},
&u_sess->attr.attr_sql.effective_cache_size,
DEFAULT_EFFECTIVE_CACHE_SIZE,
1,
INT_MAX,
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
},
&u_sess->attr.attr_common.server_version_num,
PG_VERSION_NUM,
PG_VERSION_NUM,
PG_VERSION_NUM,
NULL,
NULL,
NULL
},
{
{
"log_temp_files",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("Logs 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
},
&u_sess->attr.attr_common.log_temp_files,
-1,
-1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"track_activity_query_size",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("Sets the size reserved for pg_stat_activity.query, in bytes."),
NULL,
},
&g_instance.attr.attr_common.pgstat_track_activity_query_size,
1024,
100,
102400,
NULL,
NULL,
NULL
},
{
{
"password_reuse_max",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("max times password can reuse."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_reuse_max,
0,
0,
MAX_PASSWORD_REUSE_MAX,
check_int_parameter,
NULL,
NULL
},
{
{
"failed_login_attempts",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("max number of login attempts."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Failed_login_attempts,
10,
0,
MAX_FAILED_LOGIN_ATTAMPTS,
check_int_parameter,
NULL,
NULL
},
{
{
"password_min_uppercase",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("min number of upper character in password."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_min_upper,
0,
0,
MAX_PASSWORD_ASSIGNED_CHARACTER,
check_int_parameter,
NULL,
NULL
},
{
{
"password_min_lowercase",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("min number of lower character in password."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_min_lower,
0,
0,
MAX_PASSWORD_ASSIGNED_CHARACTER,
check_int_parameter,
NULL,
NULL
},
{
{
"password_min_digital",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("min number of digital character in password."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_min_digital,
0,
0,
MAX_PASSWORD_ASSIGNED_CHARACTER,
check_int_parameter,
NULL,
NULL
},
{
{
"password_min_special",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("min number of special character in password."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_min_special,
0,
0,
MAX_PASSWORD_ASSIGNED_CHARACTER,
check_int_parameter,
NULL,
NULL
},
{
{
"password_min_length",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("min length of password."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_min_length,
8,
6,
MAX_PASSWORD_LENGTH,
check_int_parameter,
NULL,
NULL
},
{
{
"password_max_length",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("max length of password."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.Password_max_length,
32,
6,
MAX_PASSWORD_LENGTH,
check_int_parameter,
NULL,
NULL
},
{
{
"password_notify_time",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("password deadline notice time."),
NULL
},
&u_sess->attr.attr_security.Password_notify_time,
7,
0,
MAX_PASSWORD_NOTICE_TIME,
check_int_parameter,
NULL,
NULL
},
/* Database Security: Support database audit */
/* add guc option about audit */
{
{
"audit_rotation_interval",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("Automatic audit file rotation will occur after N minutes."),
NULL,
GUC_UNIT_MIN
},
&u_sess->attr.attr_security.Audit_RotationAge,
HOURS_PER_DAY * MINS_PER_HOUR,
1,
INT_MAX / MINS_PER_HOUR,
NULL,
NULL,
NULL
},
{
{
"audit_rotation_size",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("Automatic audit file rotation will occur after N kilobytes."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_security.Audit_RotationSize,
10 * 1024,
1024,
1024 * 1024,
NULL,
NULL,
NULL
},
{
{
"audit_space_limit",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit data space limit in MB unit"),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_security.Audit_SpaceLimit,
1024 * 1024,
1024,
1024 * 1024 * 1024,
NULL,
NULL,
NULL
},
{
{
"audit_file_remain_time",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("the days of the audit files can be remained"),
NULL,
0
},
&u_sess->attr.attr_security.Audit_RemainAge,
90,
0,
730,
NULL,
NULL,
NULL
},
/*
* Audit_file_remain_threshold is a parameter which is no need and shouldn't be changed for these reason:
* 1. If customer want to control audit log space, use audit_space_limit is enough.
* 2. Two limit with audit_space_limit and audit_file_remain_time will serious conflict with this parameter
* and always set audit_file_remain_threshold will cause these parameters very difficult to use.
*/
{
{
"audit_file_remain_threshold",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit file remain threshold."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_RemainThreshold,
1024 * 1024,
1,
1024 * 1024,
NULL,
NULL,
NULL
},
{
{
"audit_login_logout",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit user login logout."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_Session,
7,
0,
7,
NULL,
NULL,
NULL
},
{
{
"audit_database_process",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit database start, stop, recover and switchover."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_ServerAction,
1,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_user_locked",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit lock and unlock user."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_LockUser,
1,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_user_violation",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit user violation."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_UserViolation,
0,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_grant_revoke",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit grant and revoke privilege."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_PrivilegeAdmin,
1,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_system_object",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit DDL operation on system object."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_DDL,
12295,
0,
524287,
NULL,
NULL,
NULL
},
{
{
"audit_dml_state",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit DML operation."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_DML,
0,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_dml_state_select",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit DML select operation."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_DML_SELECT,
0,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_function_exec",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit function execution."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_Exec,
0,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_copy_exec",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit copy execution."),
NULL,
0
},
&u_sess->attr.attr_security.Audit_Copy,
0,
0,
1,
NULL,
NULL,
NULL
},
{
{
"audit_set_parameter",
PGC_SIGHUP,
AUDIT_OPTIONS,
gettext_noop("audit set operation."),
NULL
},
&u_sess->attr.attr_security.Audit_Set,
1,
0,
1,
NULL,
NULL,
NULL
},
#ifdef PGXC
{
{
"pooler_maximum_idle_time",
PGC_USERSET,
DATA_NODES,
gettext_noop("Maximum idle time of the pooler links."),
NULL,
GUC_UNIT_MIN
},
&g_instance.attr.attr_network.PoolerMaxIdleTime,
60,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"minimum_pool_size",
PGC_USERSET,
DATA_NODES,
gettext_noop("Initial pool size."),
gettext_noop("If number of active connections decreased below this value, "
"new connections are established")
},
&g_instance.attr.attr_network.MinPoolSize,
200,
1,
65535,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"max_pool_size",
PGC_POSTMASTER,
DATA_NODES,
gettext_noop("Max pool size."),
gettext_noop("If number of active connections reaches this value, "
"other connection requests will be refused")
},
&g_instance.attr.attr_network.MaxPoolSize,
400,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"pooler_port",
PGC_POSTMASTER,
COORDINATORS,
gettext_noop(
"Legacy port of the Pool Manager. Now it is used for cn HA port for build and replication "
"under thread pool mode."),
NULL
},
&g_instance.attr.attr_network.PoolerPort,
6667,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"pooler_timeout",
PGC_SIGHUP,
DATA_NODES,
gettext_noop("Timeout of the Pool Communication with Other Nodes."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_network.PoolerTimeout,
600,
0,
7200,
NULL,
NULL,
NULL
},
{
{
"pooler_connect_max_loops",
PGC_USERSET,
DATA_NODES,
gettext_noop("Max retries of the Pooler Connecting to Other Nodes."),
NULL
},
&u_sess->attr.attr_network.PoolerConnectMaxLoops,
1,
0,
20,
NULL,
NULL,
NULL
},
{
{
"pooler_connect_interval_time",
PGC_USERSET,
DATA_NODES,
gettext_noop("Indicates the interval for each retry."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_network.PoolerConnectIntervalTime,
15,
0,
7200,
NULL,
NULL,
NULL
},
{
{
"pooler_connect_timeout",
PGC_SIGHUP,
DATA_NODES,
gettext_noop("Timeout of the Pooler Connecting to Other Nodes."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_network.PoolerConnectTimeout,
60,
0,
7200,
NULL,
NULL,
NULL
},
{
{
"pooler_cancel_timeout",
PGC_SIGHUP,
DATA_NODES,
gettext_noop("Timeout of the Pooler Cancel Connections to Other Nodes."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_network.PoolerCancelTimeout,
15,
0,
7200,
NULL,
NULL,
NULL
},
{
{
"gtm_port",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[0],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port1",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[1],
6665,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port2",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[2],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port3",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[3],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port4",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[4],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port5",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[5],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port6",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[6],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"gtm_port7",
PGC_POSTMASTER,
GTM,
gettext_noop("Port of GTM."),
NULL
},
&g_instance.attr.attr_common.GtmHostPortArray[7],
6666,
1,
65535,
NULL,
NULL,
NULL
},
{
{
"max_datanodes",
PGC_POSTMASTER,
DATA_NODES,
gettext_noop("Maximum number of Datanodes in the cluster."),
gettext_noop("It is not possible to create more Datanodes in the cluster than "
"this maximum number.")
},
&g_instance.attr.attr_common.MaxDataNodes,
64,
2,
65535,
NULL,
NULL,
NULL
},
{
{
"max_coordinators",
PGC_POSTMASTER,
DATA_NODES,
gettext_noop("Maximum number of Coordinators in the cluster."),
gettext_noop("It is not possible to create more Coordinators in the cluster than "
"this maximum number.")
},
&g_instance.attr.attr_network.MaxCoords,
1024,
2,
MAX_CN_NODE_NUM,
check_max_coordnode,
comm_change_coordnode,
show_max_coordnode
},
{
{
"best_agg_plan",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Specify which path to do aggregation in stream environment."),
NULL
},
&u_sess->attr.attr_sql.best_agg_plan,
0,
0,
3,
NULL,
NULL,
NULL
},
{
{
"gtm_option",
PGC_POSTMASTER,
GTM,
gettext_noop("Set gtm option, 0 for GTM ,1 GTMLite and 2 GTMFree"),
NULL
},
&g_instance.attr.attr_storage.gtm_option,
GTMOPTION_GTM,
GTMOPTION_GTM,
GTMOPTION_GTMFREE,
NULL,
NULL,
NULL
},
#endif
/* This is PGC_SIGHUP to set the interval time to push cut_off_csn_num. 0 means never do cleanup */
{
{
"defer_csn_cleanup_time",
PGC_SIGHUP, DATA_NODES,
gettext_noop("Sets the interval time to push cut off csn num."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.defer_csn_cleanup_time,
5000,
0,
INT_MAX,
NULL,
NULL,
NULL
},
#endif
// user defind max_compile_functions
{
{
"max_compile_functions",
PGC_POSTMASTER,
RESOURCES_MEM,
gettext_noop("max compile results in postmaster"),
gettext_noop("max compile results in postmaster, default values is "
"1000, min is 1"),
0
},
&g_instance.attr.attr_sql.max_compile_functions,
1000,
1,
INT_MAX,
NULL,
NULL,
NULL
},
// Stream communication
//
{
{
"comm_sctp_port",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the STCP port the server listens on."),
NULL
},
&g_instance.attr.attr_network.comm_sctp_port,
7000,
0,
65535,
NULL,
NULL,
NULL
},
{
{
"comm_control_port",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the stream control port the server listens on."),
NULL
},
&g_instance.attr.attr_network.comm_control_port,
7001,
0,
65535,
NULL,
NULL,
NULL
},
{
{
"comm_quota_size",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the stream quota size in kB."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_network.comm_quota_size,
1024,
0,
2048000,
NULL,
NULL,
NULL
},
{
{
"comm_usable_memory",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the total usable memory for communication(in kB)."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_network.comm_usable_memory,
4000 * 1024,
100 * 1024,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"comm_memory_pool",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the memory pool size for communication(in kB)."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_network.comm_memory_pool,
2000 * 1024,
100 * 1024,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"comm_memory_pool_percent",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the percent of comm_memory_pool for dynamic workload."),
NULL
},
&g_instance.attr.attr_network.comm_memory_pool_percent,
0,
0,
100,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"comm_max_datanode",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Currently number of Datanodes."),
NULL
},
&u_sess->attr.attr_network.comm_max_datanode,
256,
1,
MAX_DN_NODE_NUM,
check_max_datanode,
comm_change_datanode,
show_max_datanode
},
{
{
"comm_max_stream",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Maximum number of streams."),
NULL
},
&g_instance.attr.attr_network.comm_max_stream,
1024,
1,
60000,
NULL,
NULL,
NULL
},
#endif
{
{
"comm_ackchk_time",
PGC_USERSET,
QUERY_TUNING,
gettext_noop("Send ack check package to stream sender periodically."),
NULL
},
&u_sess->attr.attr_network.comm_ackchk_time,
2000,
0,
20000,
NULL,
assign_comm_ackchk_time,
NULL
},
#ifdef LIBCOMM_SPEED_TEST_ENABLE
{
{
"comm_test_thread_num",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm performance testing framework thread number of streams."),
NULL
},
&u_sess->attr.attr_network.comm_test_thread_num,
0,
0,
65535,
NULL,
assign_comm_test_thread_num,
NULL
},
{
{
"comm_test_msg_len",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm performance testing framework message len."),
NULL
},
&u_sess->attr.attr_network.comm_test_msg_len,
8192,
1,
65535,
NULL,
assign_comm_test_msg_len,
NULL
},
{
{
"comm_test_send_sleep",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm performance testing framework producer thread sleep time."),
NULL
},
&u_sess->attr.attr_network.comm_test_send_sleep,
0,
0,
INT_MAX,
NULL,
assign_comm_test_send_sleep,
NULL
},
{
{
"comm_test_send_once",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm performance testing framework producer thread send message size once time."),
NULL
},
&u_sess->attr.attr_network.comm_test_send_once,
8192,
1,
INT_MAX,
NULL,
assign_comm_test_send_once,
NULL
},
{
{
"comm_test_recv_sleep",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm performance testing framework consumer thread sleep time."),
NULL
},
&u_sess->attr.attr_network.comm_test_recv_sleep,
0,
0,
INT_MAX,
NULL,
assign_comm_test_recv_sleep,
NULL
},
{
{
"comm_test_rcv_once",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm performance testing framework consumer thread recv message size once time."),
NULL
},
&u_sess->attr.attr_network.comm_test_recv_once,
8192,
1,
INT_MAX,
NULL,
assign_comm_test_recv_once,
NULL
},
#endif
#ifdef LIBCOMM_FAULT_INJECTION_ENABLE
{
{
"comm_fault_injection",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Libcomm fault injection framework."),
NULL
},
&u_sess->attr.attr_network.comm_fault_injection,
0,
-10,
INT_MAX,
NULL,
assign_comm_fault_injection,
NULL
},
#endif
#ifdef ENABLE_MULTIPLE_NODES
{
{
"query_dop",
PGC_USERSET,
QUERY_TUNING,
gettext_noop("User-defined degree of parallelism."),
NULL
},
&u_sess->attr.attr_sql.query_dop_tmp,
#if defined(USE_ASSERT_CHECKING) || defined(FASTCHECK)
1,
MIN_QUERY_DOP,
INT_MAX,
#else
1,
MIN_QUERY_DOP,
MAX_QUERY_DOP,
#endif
parse_query_dop,
AssignQueryDop,
NULL
},
#endif
{
{
"comm_max_receiver",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Maximum number of internal receiver threads."),
NULL
},
&g_instance.attr.attr_network.comm_max_receiver,
4,
1,
50,
NULL,
NULL,
NULL
},
{
{
"plan_mode_seed",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Specify which plan mode and seed the optimizer generation used."),
NULL
},
&u_sess->attr.attr_sql.plan_mode_seed,
0,
-1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"transaction_sync_naptime",
PGC_USERSET,
STATS_MONITORING,
gettext_noop("Sets the timeout to call gs_clean when sync transaction with GTM."),
gettext_noop("A value of 0 turns off the timeout."),
GUC_UNIT_S
},
&u_sess->attr.attr_common.transaction_sync_naptime,
30,
0,
INT_MAX / 1000,
NULL,
NULL,
NULL
},
{
{
"ngram_gram_size",
PGC_USERSET,
TEXT_SEARCH,
gettext_noop("N-value for N-gram parser"),
NULL
},
&u_sess->attr.attr_common.ngram_gram_size,
2,
1,
4,
NULL,
NULL,
NULL
},
{
{
"prefetch_quantity",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the IO quantity of prefetch buffers used by async dirct IO interface."),
NULL,
GUC_UNIT_BLOCKS
},
&u_sess->attr.attr_storage.prefetch_quantity,
4096,
128,
131072,
NULL,
NULL,
NULL
},
{
{
"backwrite_quantity",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the IO quantity of backwrite buffers used by async dirct IO interface."),
NULL,
GUC_UNIT_BLOCKS
},
&u_sess->attr.attr_storage.backwrite_quantity,
1024,
128,
131072,
NULL,
NULL,
NULL
},
{
{
"cstore_prefetch_quantity",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the IO quantity of prefetch CUs used by async dirct IO interface for column store."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.cstore_prefetch_quantity,
32768,
1024,
1048576,
NULL,
NULL,
NULL
},
{
{
"cstore_backwrite_max_threshold",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Cu cache threshold for cstore when do insert by async dirct IO"),
gettext_noop("Cu cache threshold for cstore when do insert by async dirct IO , default values is "
"2097152KB."),
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.cstore_backwrite_max_threshold,
2097152,
4096,
INT_MAX / 2,
NULL,
NULL,
NULL
},
{
{
"cstore_backwrite_quantity",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Each column write threshold for cstore when do insert by async dirct IO"),
gettext_noop(
"Each column write threshold for cstore when do insert by async dirct IO , default values is "
"8192KB."),
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.cstore_backwrite_quantity,
8192,
1024,
1048576,
NULL,
NULL,
NULL
},
{
{
"fast_extend_file_size",
PGC_SUSET,
RESOURCES_MEM,
gettext_noop("Set fast extend file size used by async dirct IO interface for row store."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_storage.fast_extend_file_size,
8192,
1024,
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
},
&u_sess->attr.attr_storage.gin_pending_list_limit,
4096,
64,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"gtm_connect_timeout",
PGC_SIGHUP,
GTM,
gettext_noop("Sets the max wait time in seconds to connect GTM."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_common.gtm_connect_timeout,
2,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"gtm_connect_retries",
PGC_SIGHUP,
GTM,
gettext_noop("Sets the max retry times to connect GTM."),
NULL
},
&u_sess->attr.attr_storage.gtm_connect_retries,
30,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"gtm_rw_timeout",
PGC_SIGHUP,
GTM,
gettext_noop("Sets the max time in seconds to wait for a reponse from GTM."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_common.gtm_rw_timeout,
60,
1,
INT_MAX,
NULL,
assign_gtm_rw_timeout,
NULL
},
{
{
"gtm_conn_check_interval",
PGC_SIGHUP,
STATS_MONITORING,
gettext_noop("Sets the interval in seconds to cancel those backends "
"connected to a demoted GTM."),
gettext_noop("A value of 0 turns off the function."),
GUC_UNIT_S
},
&u_sess->attr.attr_storage.gtm_conn_check_interval,
10,
0,
INT_MAX / 1000,
NULL,
NULL,
NULL
},
#endif
{
{
"transaction_sync_timeout",
PGC_USERSET,
STATS_MONITORING,
gettext_noop("Sets the timeout when sync every transaction with GTM to avoid deadlock sync."),
gettext_noop("A value of 0 turns off the timeout. Please make sure it larger than gs_clean_timeout."),
GUC_UNIT_S
},
&u_sess->attr.attr_common.transaction_sync_timeout,
600,
0,
INT_MAX / 1000,
NULL,
NULL,
NULL
},
/*
* set threshold to check if codegen is allowed or not, codegen_cost_threshold
* represents the number of rows. This will be changed in future.
*/
{
{
"codegen_cost_threshold",
PGC_USERSET,
QUERY_TUNING_COST,
gettext_noop("Decided to use LLVM optimization or not."),
NULL
},
&u_sess->attr.attr_sql.codegen_cost_threshold,
10000,
0,
INT_MAX,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"dfs_partition_directory_length",
PGC_USERSET,
UNGROUPED,
gettext_noop("The max length of the value partition directory."),
NULL
},
&u_sess->attr.attr_storage.dfs_max_parsig_length,
512,
92,
7999, /* 7999 is the max value of dfs.namenode.fs-limits.max-component-length in HDFS of FI */
NULL,
NULL,
NULL
},
#endif
/* profile log GUC, disable profile logs in single-node mode by default */
{
{
"plog_merge_age",
PGC_USERSET,
LOGGING_WHEN,
gettext_noop("how long to aggregate profile logs."),
gettext_noop("0 disable logging. suggest setting value is 1000 times."),
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.plog_merge_age,
#ifdef ENABLE_MULTIPLE_NODES
3000,
#else
0,
#endif
0,
INT_MAX,
NULL,
plog_merge_age_assign,
NULL
},
{
{
"auth_iteration_count",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("The iteration count used in RFC5802 authenication."),
NULL
},
&u_sess->attr.attr_security.auth_iteration_count,
10000,
2048,
134217728, /* 134217728 is the max iteration count supported. */
NULL,
NULL,
NULL
},
{
{
"fault_mon_timeout",
PGC_SIGHUP,
STATS_MONITORING,
gettext_noop("how many miniutes to monitor lwlock. 0 will disable that"),
NULL,
GUC_UNIT_MIN /* minute */
},
&u_sess->attr.attr_common.fault_mon_timeout,
5,
0,
(24 * 60), /* 1 min ~ 1 day, 0 will disable this thread starting */
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"max_resource_package",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("The maximum number of the resource package(RP) for DN in the compute pool."),
gettext_noop("0 means that the cluster is NOT as the compute pool."),
},
&g_instance.attr.attr_sql.max_resource_package,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"acce_min_datasize_per_thread",
PGC_USERSET,
UNGROUPED,
gettext_noop("Used to estimate whether pushdown the plan to the compute pool."),
gettext_noop("0 means that plan always runs in the compute pool."),
GUC_UNIT_KB
},
&u_sess->attr.attr_sql.acce_min_datasize_per_thread,
500000,
0,
MAX_KILOBYTES,
NULL,
NULL,
NULL
},
#endif
{
{
"max_cn_temp_file_size",
PGC_SIGHUP,
CLIENT_CONN_STATEMENT,
gettext_noop("Sets the maximum tempfile size used in CN, unit in MB."),
NULL,
GUC_UNIT_KB
},
&u_sess->attr.attr_sql.max_cn_temp_file_size,
5 * 1024 * 1024,
0,
10 * 1024 * 1024,
NULL,
NULL,
NULL
},
{
{
"cn_send_buffer_size",
PGC_POSTMASTER,
CLIENT_CONN_STATEMENT,
gettext_noop("Sets the send buffer size used in CN, unit in KB."),
NULL,
GUC_UNIT_KB
},
&g_instance.attr.attr_network.cn_send_buffer_size,
8,
8,
128,
NULL,
NULL,
NULL
},
{
{
"max_changes_in_memory",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("how many memory a transaction can use in reorderbuffer."),
NULL
},
&g_instance.attr.attr_common.max_changes_in_memory,
4096,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"max_cached_tuplebufs",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("how many memory reorderbuffer can use."),
NULL
},
&g_instance.attr.attr_common.max_cached_tuplebufs,
8192,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"table_skewness_warning_rows",
PGC_USERSET,
STATS,
gettext_noop("Sets the number of rows returned by DN to enable warning of table skewness."),
NULL
},
&u_sess->attr.attr_sql.table_skewness_warning_rows,
100000,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"recovery_max_workers",
PGC_POSTMASTER,
RESOURCES_RECOVERY,
gettext_noop("The max number of recovery threads allowed to run in parallel."),
gettext_noop("Zero lets the system determine this value.")
},
&g_instance.attr.attr_storage.max_recovery_parallelism,
1,
0,
MOST_FAST_RECOVERY_LIMIT,
NULL,
NULL,
NULL
},
{
{
"recovery_parallelism",
PGC_POSTMASTER,
RESOURCES_RECOVERY,
gettext_noop("The actual number of recovery threads running in parallel."),
NULL
},
&g_instance.attr.attr_storage.real_recovery_parallelism,
1,
1,
INT_MAX,
NULL,
NULL,
NULL
},
#ifdef ENABLE_QUNIT
{
{
"qunit_case_number",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Sets the qunit_case_number."),
gettext_noop("Only QUnit framework uses this guc parameter.")
},
&u_sess->utils_cxt.qunit_case_number,
0,
0,
INT_MAX,
NULL,
set_qunit_case_number_hook,
NULL
},
#endif
{
{
"incremental_checkpoint_timeout",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Sets the maximum time between automatic WAL checkpoints."),
NULL,
GUC_UNIT_S
},
&u_sess->attr.attr_storage.incrCheckPointTimeout,
60,
1,
3600,
NULL,
NULL,
NULL
},
{
{
"pagewriter_sleep",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("PageWriter sleep time."),
NULL,
GUC_UNIT_MS
},
&u_sess->attr.attr_storage.pageWriterSleep,
100,
0,
3600 * 1000,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"max_datanode_for_plan",
PGC_USERSET,
UNGROUPED,
gettext_noop("The max number of DN datanodes to show plan, 0 means just CN plan."),
NULL
},
&u_sess->attr.attr_common.max_datanode_for_plan,
0,
0,
MAX_DN_NODE_NUM,
NULL,
NULL,
NULL
},
#endif
{
{
"pagewriter_threshold",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Lower limit for triggering the pagewriter to flush the dirty page."),
NULL,
0
},
&u_sess->attr.attr_storage.pagewriter_threshold,
818,
1,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"pagewriter_thread_num",
PGC_POSTMASTER,
WAL_CHECKPOINTS,
gettext_noop("Sets the number of page writer threads."),
NULL,
0
},
&g_instance.attr.attr_storage.pagewriter_thread_num,
2,
1,
8,
NULL,
NULL,
NULL
},
{
{
"datanode_heartbeat_interval",
PGC_SIGHUP,
WAL_CHECKPOINTS,
gettext_noop("Sets the heartbeat interval of the standby nodes."),
gettext_noop(
"The value is best configured less than half of the wal_receiver_timeout and wal_sender_timeout."),
GUC_UNIT_MS
},
&u_sess->attr.attr_common.dn_heartbeat_interval,
1000,
1000,
60 * 1000,
NULL,
NULL,
NULL
},
{
{
"upgrade_mode",
PGC_SIGHUP,
UPGRADE_OPTIONS,
gettext_noop("Indicate the upgrade mode: inplace upgrade mode, grey upgrade mode or not in upgrade."),
NULL,
0
},
&u_sess->attr.attr_common.upgrade_mode,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
{
{
"instr_unique_sql_count",
PGC_SIGHUP,
INSTRUMENTS_OPTIONS,
gettext_noop("Sets the number of entries collected in gs_instr_unique_sql."),
NULL
},
&u_sess->attr.attr_common.instr_unique_sql_count,
100,
0,
INT_MAX,
NULL,
assign_instr_unique_sql_count,
NULL
},
{
{
"recovery_parse_workers",
PGC_POSTMASTER,
RESOURCES_RECOVERY,
gettext_noop("The number of recovery threads to do xlog parse."),
gettext_noop("Zero lets the system determine this value.")
},
&g_instance.attr.attr_storage.recovery_parse_workers,
1,
1,
MAX_PARSE_WORKERS,
NULL,
NULL,
NULL
},
{
{
"recovery_redo_workers",
PGC_POSTMASTER,
RESOURCES_RECOVERY,
gettext_noop("The number belonging to one parse worker to do xlog redo."),
gettext_noop("Zero lets the system determine this value.")
},
&g_instance.attr.attr_storage.recovery_redo_workers_per_paser_worker,
1,
1,
MAX_REDO_WORKERS_PER_PARSE,
NULL,
NULL,
NULL
},
{
{
"max_keep_log_seg",
PGC_SUSET,
WAL,
gettext_noop("Sets the threshold for implementing logical replication flow control."),
NULL
},
&g_instance.attr.attr_storage.max_keep_log_seg,
0,
0,
INT_MAX,
NULL,
NULL,
NULL
},
/* End-of-list marker */
{
{
NULL,
(GucContext)0,
(config_group)0,
NULL,
NULL
},
NULL,
0,
0,
0,
NULL,
NULL,
NULL
}
};
Size bytes = sizeof(local_configure_names_int);
u_sess->utils_cxt.ConfigureNamesInt = (struct config_int*)MemoryContextAlloc(u_sess->top_mem_cxt, bytes);
int rc = memcpy_s(u_sess->utils_cxt.ConfigureNamesInt, bytes, local_configure_names_int, bytes);
securec_check(rc, "", "");
}
static void init_configure_names_real()
{
struct config_real local_configure_names_real[] = {
{
{
"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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.cpu_tuple_cost,
DEFAULT_CPU_TUPLE_COST,
0,
DBL_MAX,
NULL,
NULL,
NULL
},
{
{
"allocate_mem_cost",
PGC_USERSET,
QUERY_TUNING_COST,
gettext_noop("Sets the planner's estimate of the cost of "
"allocate memory."),
NULL
},
&u_sess->attr.attr_sql.allocate_mem_cost,
DEFAULT_ALLOCATE_MEM_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
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.cpu_operator_cost,
DEFAULT_CPU_OPERATOR_COST,
0,
DBL_MAX,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"stream_multiple",
PGC_USERSET,
QUERY_TUNING_COST,
gettext_noop("Sets the planner's estimate of the cost of "
"stream multiple."),
NULL
},
&u_sess->attr.attr_sql.stream_multiple,
DEFAULT_STREAM_MULTIPLE,
0,
DBL_MAX,
NULL,
NULL,
NULL
},
#endif
{
{
"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
},
&u_sess->attr.attr_sql.cursor_tuple_fraction,
DEFAULT_CURSOR_TUPLE_FRACTION,
0.0,
1.0,
NULL,
NULL,
NULL
},
{
{
"connection_alarm_rate",
PGC_SIGHUP,
UNGROUPED,
gettext_noop("Reports alarm if connection rate overload."),
NULL
},
&u_sess->attr.attr_common.ConnectionAlarmRate,
0.9,
0.0,
1.0,
NULL,
NULL,
NULL
},
{
{
"geqo_selection_bias",
PGC_USERSET,
QUERY_TUNING_GEQO,
gettext_noop("GEQO: selective pressure within the population."),
NULL
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_sql.Geqo_seed,
0.0,
0.0,
1.0,
NULL,
NULL,
NULL
},
{
{
"bgwriter_lru_multiplier",
PGC_SIGHUP,
RESOURCES_BGWRITER,
gettext_noop("Multiple of the average buffer usage to free per round."),
NULL
},
&u_sess->attr.attr_storage.bgwriter_lru_multiplier,
2.0,
0.0,
10.0,
NULL,
NULL,
NULL
},
{
{
"standby_shared_buffers_fraction",
PGC_SIGHUP,
RESOURCES_MEM,
gettext_noop("The max fraction of shared_buffers usage to standby."),
NULL
},
&u_sess->attr.attr_storage.shared_buffers_fraction,
0.3,
0.1,
1.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
},
&u_sess->attr.attr_sql.phony_random_seed,
0.0,
-1.0,
1.0,
check_random_seed,
assign_random_seed,
show_random_seed
},
{
{
"autovacuum_vacuum_scale_factor",
PGC_SIGHUP,
AUTOVACUUM,
gettext_noop("Number of tuple updates or deletes prior to vacuum as a fraction of reltuples."),
NULL
},
&u_sess->attr.attr_storage.autovacuum_vac_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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.CheckPointCompletionTarget,
0.5,
0.0,
1.0,
NULL,
NULL,
NULL
},
/* defalut values is 60 days */
{
{
"password_reuse_time",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("max days password can reuse."),
NULL
},
&u_sess->attr.attr_security.Password_reuse_time,
60.0,
0.0,
MAX_PASSWORD_REUSE_TIME,
check_double_parameter,
NULL,
NULL
},
{
{
"password_effect_time",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("password effective time."),
NULL
},
&u_sess->attr.attr_security.Password_effect_time,
90.0,
0.0,
MAX_PASSWORD_EFFECTIVE_TIME,
check_double_parameter,
NULL,
NULL
},
{
{
"password_lock_time",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("password lock time"),
NULL
},
&u_sess->attr.attr_security.Password_lock_time,
1.0,
0.0,
MAX_ACCOUNT_LOCK_TIME,
check_double_parameter,
NULL,
NULL
},
{
{
"table_skewness_warning_threshold",
PGC_USERSET, STATS,
gettext_noop("table skewness threthold"),
NULL
},
&u_sess->attr.attr_sql.table_skewness_warning_threshold,
1.0,
0.0,
1.0,
check_double_parameter,
NULL,
NULL
},
/* End-of-list marker */
{
{
NULL,
(GucContext)0,
(config_group)0,
NULL,
NULL
},
NULL,
0.0,
0.0,
0.0,
NULL,
NULL,
NULL
}
};
Size bytes = sizeof(local_configure_names_real);
u_sess->utils_cxt.ConfigureNamesReal = (struct config_real*)MemoryContextAlloc(u_sess->top_mem_cxt, bytes);
int rc = memcpy_s(u_sess->utils_cxt.ConfigureNamesReal, bytes, local_configure_names_real, bytes);
securec_check(rc, "", "");
}
static void init_configure_names_int64()
{
struct config_int64 local_configure_names_int64[] = {
{
{
"vacuum_freeze_min_age",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Minimum age at which VACUUM should freeze a table row."),
NULL
},
&u_sess->attr.attr_storage.vacuum_freeze_min_age,
INT64CONST(5000000000),
INT64CONST(0),
INT64CONST(0x7FFFFFFFFFFFFFF),
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"hll_default_expthresh",
PGC_USERSET,
UNGROUPED,
gettext_noop("Set parameter expthresh in hll."),
gettext_noop("It could change promotion hierarchy for hll.")
},
&u_sess->attr.attr_sql.g_default_expthresh,
DEFAULT_EXPTHRESH,
HLL_MIN_EXPTHRESH,
HLL_MAX_EXPTHRESH,
NULL,
NULL,
NULL
},
#endif
{
{
"vacuum_freeze_table_age",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
NULL
},
&u_sess->attr.attr_storage.vacuum_freeze_table_age,
INT64CONST(15000000000),
INT64CONST(0),
INT64CONST(0x7FFFFFFFFFFFFFF),
NULL,
NULL,
NULL
},
{
{
"vacuum_defer_cleanup_age",
PGC_SIGHUP,
REPLICATION_MASTER,
gettext_noop("Number of transactions by which VACUUM and HOT cleanup should be deferred, if any."),
NULL
},
&u_sess->attr.attr_storage.vacuum_defer_cleanup_age,
INT64CONST(0),
INT64CONST(0),
INT64CONST(1000000),
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."),
NULL
},
&g_instance.attr.attr_storage.autovacuum_freeze_max_age,
/* see pg_resetxlog if you change the upper-limit value */
INT64CONST(20000000000),
INT64CONST(100000),
INT64CONST(0x7FFFFFFFFFFFFFF),
NULL,
NULL,
NULL
},
/* End-of-list marker */
{
{
NULL,
(GucContext)0,
(config_group)0,
NULL,
NULL
},
NULL,
0,
0,
0,
NULL,
NULL,
NULL
}
};
Size bytes = sizeof(local_configure_names_int64);
u_sess->utils_cxt.ConfigureNamesInt64 = (struct config_int64*)MemoryContextAlloc(u_sess->top_mem_cxt,
bytes);
int rc = memcpy_s(u_sess->utils_cxt.ConfigureNamesInt64, bytes, local_configure_names_int64, bytes);
securec_check(rc, "", "");
};
static void init_configure_names_string()
{
struct config_string local_configure_names_string[] = {
{
{
"archive_command",
PGC_SIGHUP,
WAL_ARCHIVING,
gettext_noop("Sets the shell command that will be called to archive a WAL file."),
NULL
},
&u_sess->attr.attr_storage.XLogArchiveCommand,
"",
NULL,
NULL,
show_archive_command
},
{
{
"client_encoding",
PGC_USERSET,
CLIENT_CONN_LOCALE,
gettext_noop("Sets the client's character set encoding."),
NULL,
GUC_IS_NAME | GUC_REPORT
},
&u_sess->attr.attr_common.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.")
},
&u_sess->attr.attr_common.Log_line_prefix,
"",
NULL,
NULL,
NULL
},
{
{
"log_timezone",
PGC_SIGHUP,
LOGGING_WHAT,
gettext_noop("Sets the time zone to use in log messages."),
NULL
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.datestyle_string,
"ISO, MDY",
check_datestyle,
assign_datestyle,
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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_common.Dynamic_library_path,
"$libdir",
NULL,
NULL,
NULL
},
{
{
"krb_server_keyfile",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("Sets the location of the Kerberos server key file."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_security.pg_krb_server_keyfile,
"",
NULL,
NULL,
NULL
},
{
{
"krb_srvname",
PGC_SIGHUP,
CONN_AUTH_SECURITY,
gettext_noop("Sets the name of the Kerberos service."),
NULL
},
&u_sess->attr.attr_security.pg_krb_srvnam,
PG_KRB_SRVNAM,
NULL,
NULL,
NULL
},
#ifdef USE_BONJOUR
{
{
"bonjour_name",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the Bonjour service name."),
NULL
},
&g_instance.attr.attr_common.bonjour_name,
"",
NULL,
NULL,
NULL
},
#endif
/* See main.c about why defaults for LC_foo are not all alike */
{
{
"lc_collate",
PGC_INTERNAL,
CLIENT_CONN_LOCALE,
gettext_noop("Shows the collation order locale."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.locale_collate,
"C",
NULL,
NULL,
NULL
},
{
{
"lc_ctype",
PGC_INTERNAL,
CLIENT_CONN_LOCALE,
gettext_noop("Shows the character classification and case conversion locale."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.locale_ctype,
"C",
NULL,
NULL,
NULL
},
{
{
"lc_messages",
PGC_SUSET,
CLIENT_CONN_LOCALE,
gettext_noop("Sets the language in which messages are displayed."),
NULL
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.locale_time,
"C",
check_locale_time,
assign_locale_time,
NULL
},
{
{
"shared_preload_libraries",
PGC_POSTMASTER,
RESOURCES_KERNEL,
gettext_noop("Lists shared libraries to preload into server."),
NULL,
GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.shared_preload_libraries_string,
"",
NULL,
NULL,
NULL
},
{
{
"thread_pool_attr",
PGC_POSTMASTER,
CLIENT_CONN,
gettext_noop("Spare Cpu that can not be used in thread pool."),
NULL,
GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.thread_pool_attr,
"16, 2, (nobind)",
NULL,
NULL,
NULL
},
{
{
"local_preload_libraries",
PGC_BACKEND,
CLIENT_CONN_OTHER,
gettext_noop("Lists shared libraries to preload into each backend."),
NULL,
GUC_LIST_INPUT | GUC_LIST_QUOTE
},
&u_sess->attr.attr_common.local_preload_libraries_string,
"",
NULL,
NULL,
NULL
},
{
{
"expected_computing_nodegroup",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Computing node group mode or expected node group for query processing."),
NULL,
},
&u_sess->attr.attr_sql.expected_computing_nodegroup,
CNG_OPTION_QUERY,
NULL,
NULL,
NULL
},
{
{
"default_storage_nodegroup",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Default storage group for create table."),
NULL,
},
&u_sess->attr.attr_sql.default_storage_nodegroup,
INSTALLATION_MODE,
NULL,
NULL,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
/* Can't be set in postgresql.conf */
{
"current_logic_cluster",
PGC_INTERNAL,
UNGROUPED,
gettext_noop("Shows current logic cluster."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.current_logic_cluster_name,
NULL,
NULL,
NULL,
show_lcgroup_name
},
{
/* Can't be set in postgresql.conf */
{
"node_group_mode",
PGC_INTERNAL,
UNGROUPED,
gettext_noop("Shows node group mode."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.node_group_mode,
"node group",
NULL,
NULL,
show_nodegroup_mode
},
#endif
{
{
"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
},
&u_sess->attr.attr_common.namespace_search_path,
"\"$user\",public",
check_search_path,
assign_search_path,
NULL
},
{
{
"percentile",
PGC_INTERNAL,
INSTRUMENTS_OPTIONS,
gettext_noop("Sets the percentile of sql responstime that DBA want to know."),
NULL,
GUC_LIST_INPUT | GUC_LIST_QUOTE
},
&u_sess->attr.attr_common.percentile_values,
"80,95",
check_percentile,
NULL,
NULL
},
/* for pljava */
{
{
"pljava_vmoptions",
PGC_SUSET,
CUSTOM_OPTIONS,
gettext_noop("Options sent to the JVM when it is created"),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_sql.pljava_vmoptions,
"",
NULL,
NULL,
NULL
},
{
{
"nls_timestamp_format",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("defines the default timestamp format to use with the TO_TIMESTAMP functions."),
NULL,
},
&u_sess->attr.attr_common.nls_timestamp_format_string,
"DD-Mon-YYYY HH:MI:SS.FF AM",
NULL,
NULL,
NULL
},
{
{
"current_schema",
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
},
&u_sess->attr.attr_common.namespace_current_schema,
"\"$user\",public",
check_search_path,
assign_search_path,
NULL
},
{
/* Can't be set in postgresql.conf */
{
"server_encoding",
PGC_INTERNAL,
CLIENT_CONN_LOCALE,
gettext_noop("Sets the server (database) character set encoding."),
NULL,
GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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\", and \"eventlog\", "
"depending on the platform."),
GUC_LIST_INPUT
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.Log_directory,
"pg_log",
check_canonical_path,
NULL,
NULL
},
{
{
"explain_dna_file",
PGC_USERSET,
LOGGING_WHERE,
gettext_noop("Sets the destination file for explain performance data."),
gettext_noop("Must be specified as an absolute directory + .csv filename."),
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.Perf_log,
NULL,
check_perf_log,
NULL,
NULL
},
{
{
"log_filename",
PGC_SIGHUP,
LOGGING_WHERE,
gettext_noop("Sets the file name pattern for log files."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_common.Log_filename,
"postgresql-%Y-%m-%d_%H%M%S.log",
NULL,
NULL,
NULL
},
{
{
"bbox_dump_path",
PGC_SIGHUP,
LOGGING_WHERE,
gettext_noop("Sets the path of core dump created by bbox_handler."),
NULL
},
&u_sess->attr.attr_common.bbox_dump_path,
"",
check_bbox_corepath,
assign_bbox_corepath,
show_bbox_dump_path
},
{
{
"alarm_component",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("Sets the component for alarm function."),
NULL,
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.Alarm_component,
"/opt/huawei/snas/bin/snas_cm_cmd",
NULL,
NULL,
NULL
},
{
{
"syslog_ident",
PGC_SIGHUP,
LOGGING_WHERE,
gettext_noop("Sets the program name used to identify PostgreSQL "
"messages in syslog."),
NULL
},
&u_sess->attr.attr_common.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
},
&g_instance.attr.attr_common.event_source,
"PostgreSQL",
NULL,
NULL,
NULL
},
{
{
"TimeZone",
PGC_USERSET,
CLIENT_CONN_LOCALE,
gettext_noop("Sets the time zone for displaying and interpreting time stamps."),
NULL,
GUC_REPORT
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.timezone_abbreviations_string,
NULL,
check_timezone_abbreviations,
assign_timezone_abbreviations,
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
},
&u_sess->attr.attr_storage.XactIsoLevel_string,
"default",
check_XactIsoLevel,
assign_XactIsoLevel,
show_XactIsoLevel
},
{
{
"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.")
},
&g_instance.attr.attr_network.Unix_socket_group,
"",
NULL,
NULL,
NULL
},
{
{
"unix_socket_directory",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the directory where the Unix-domain socket will be created."),
NULL,
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_network.UnixSocketDir,
"",
check_canonical_path,
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
},
&g_instance.attr.attr_network.ListenAddresses,
"localhost",
NULL,
NULL,
NULL
},
{
{
"local_bind_address",
PGC_POSTMASTER,
CONN_AUTH_SETTINGS,
gettext_noop("Sets the host name or IP address(es) to connect to for sctp."),
NULL,
GUC_LIST_INPUT
},
&g_instance.attr.attr_network.sctp_link_addr,
"0.0.0.0",
NULL,
NULL,
NULL
},
{
{
"data_directory",
PGC_POSTMASTER,
FILE_LOCATIONS,
gettext_noop("Sets the server's data directory."),
NULL,
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.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
},
&g_instance.attr.attr_common.ConfigFileName,
NULL,
NULL,
NULL,
NULL
},
{
{
"mot_config_file",
PGC_POSTMASTER,
FILE_LOCATIONS,
gettext_noop("Sets mot main configuration file."),
NULL,
GUC_DISALLOW_IN_FILE | GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.MOTConfigFileName,
NULL,
NULL,
NULL,
NULL
},
{
{
"hba_file",
PGC_POSTMASTER,
FILE_LOCATIONS,
gettext_noop("Sets the server's \"hba\" configuration file."),
NULL,
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.HbaFileName,
NULL,
NULL,
NULL,
NULL
},
{
{
"ident_file",
PGC_POSTMASTER,
FILE_LOCATIONS,
gettext_noop("Sets the server's \"ident\" configuration file."),
NULL,
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_common.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
},
&g_instance.attr.attr_common.external_pid_file,
NULL,
check_canonical_path,
NULL,
NULL
},
{
{
"ssl_cert_file",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Location of the SSL server certificate file."),
NULL
},
&g_instance.attr.attr_security.ssl_cert_file,
"server.crt",
NULL,
NULL,
NULL
},
{
{
"ssl_key_file",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Location of the SSL server private key file."),
NULL
},
&g_instance.attr.attr_security.ssl_key_file,
"server.key",
NULL,
NULL,
NULL
},
{
{
"ssl_ca_file",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Location of the SSL certificate authority file."),
NULL
},
&g_instance.attr.attr_security.ssl_ca_file,
"",
NULL,
NULL,
NULL
},
{
{
"ssl_crl_file",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Location of the SSL certificate revocation list file."),
NULL
},
&g_instance.attr.attr_security.ssl_crl_file,
"",
NULL,
NULL,
NULL
},
{
{
"stats_temp_directory",
PGC_SIGHUP,
STATS_COLLECTOR,
gettext_noop("Writes temporary statistics files to the specified directory."),
NULL,
GUC_SUPERUSER_ONLY
},
&u_sess->attr.attr_common.pgstat_temp_directory,
"pg_stat_tmp",
check_canonical_path,
assign_pgstat_temp_directory,
NULL
},
{
{
"synchronous_standby_names",
PGC_SIGHUP,
REPLICATION_MASTER,
gettext_noop("List of names of potential synchronous standbys."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_common.TSCurrentConfig,
"pg_catalog.simple",
check_TSCurrentConfig,
assign_TSCurrentConfig,
NULL
},
#ifdef PGXC
{
{
"qrw_inlist2join_optmode",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("Specify inlist2join opimitzation mode."),
NULL
},
&u_sess->attr.attr_sql.inlist2join_optmode,
"cost_base",
check_inlist2joininfo,
assign_inlist2joininfo,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"gtm_host",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[0],
"localhost",
check_gtmhostconninfo,
assign_gtmhostconninfo0,
NULL
},
#endif
{
{
"behavior_compat_options",
PGC_USERSET,
COMPAT_OPTIONS,
gettext_noop("compatibility options"),
NULL,
GUC_LIST_INPUT | GUC_REPORT
},
&u_sess->attr.attr_sql.behavior_compat_string,
"",
check_behavior_compat_options,
assign_behavior_compat_options,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
{
{
"gtm_host1",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[1],
"localhost",
check_gtmhostconninfo,
assign_gtmhostconninfo1,
NULL
},
{
{
"gtm_host2",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[2],
"",
check_gtmhostconninfo,
assign_gtmhostconninfo2,
NULL
},
{
{
"gtm_host3",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[3],
"",
check_gtmhostconninfo,
assign_gtmhostconninfo3,
NULL
},
{
{
"gtm_host4",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[4],
"",
check_gtmhostconninfo,
assign_gtmhostconninfo4,
NULL
},
{
{
"gtm_host5",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[5],
"",
check_gtmhostconninfo,
assign_gtmhostconninfo5,
NULL
},
{
{
"gtm_host6",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[6],
"",
check_gtmhostconninfo,
assign_gtmhostconninfo6,
NULL
},
{
{
"gtm_host7",
PGC_SIGHUP,
GTM,
gettext_noop("Host name or address of GTM"),
NULL
},
&u_sess->attr.attr_common.GtmHostInfoStringArray[7],
"",
check_gtmhostconninfo,
assign_gtmhostconninfo7,
NULL
},
#endif
{
{
"pgxc_node_name",
PGC_POSTMASTER,
GTM,
gettext_noop("The database node name."),
NULL,
GUC_NO_RESET_ALL | GUC_IS_NAME
},
&g_instance.attr.attr_common.PGXCNodeName,
"",
NULL,
NULL,
NULL
},
#ifdef ENABLE_DISTRIBUTE_TEST
{
{
"distribute_test_param",
PGC_USERSET,
DEVELOPER_OPTIONS,
gettext_noop("Sets the parameters of distributed test framework."),
NULL,
GUC_LIST_INPUT | GUC_REPORT | GUC_NO_SHOW_ALL
},
&u_sess->attr.attr_common.test_param_str,
"-1, default, default",
check_distribute_test_param,
assign_distribute_test_param,
NULL
},
#endif
#endif
{
{
"ssl_ciphers",
PGC_POSTMASTER,
CONN_AUTH_SECURITY,
gettext_noop("Sets the list of allowed SSL ciphers."),
NULL,
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_security.SSLCipherSuites,
#ifdef USE_SSL
"ALL",
#else
"none",
#endif
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
},
&u_sess->attr.attr_common.application_name,
"",
check_application_name,
assign_application_name,
NULL
},
{
{
"connection_info",
PGC_USERSET,
LOGGING_WHAT,
gettext_noop("Sets the connection info to be reported in statistics and logs."),
NULL,
GUC_REPORT | GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_sql.connection_info,
"",
NULL,
assign_connection_info,
NULL
},
{
{
"cgroup_name",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets the cgroup name to control the queries resource."),
NULL,
GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_resource.cgroup_name,
"",
check_cgroup_name,
assign_cgroup_name,
show_cgroup_name
},
{
{
"query_band",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets query band."),
NULL,
GUC_REPORT | GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_resource.query_band,
"",
check_query_band_name,
NULL,
NULL
},
{
{
"session_respool",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets the session resource pool to control the queries resource."),
NULL,
GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_resource.session_resource_pool,
"invalid_pool",
check_session_respool,
assign_session_respool,
show_session_respool
},
{
{
"memory_detail_tracking",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the operator name and peak size for triggering the memory logging "
"in that time."),
NULL,
GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_memory.memory_detail_tracking,
"",
check_memory_detail_tracking,
assign_memory_detail_tracking,
show_memory_detail_tracking
},
/* Database Security: Support database audit */
{
{
"audit_directory",
PGC_POSTMASTER,
AUDIT_OPTIONS,
gettext_noop("Sets the destination directory for audit files."),
gettext_noop("Can be specified as relative to the data directory "
"or as absolute path."),
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_security.Audit_directory,
"pg_audit",
check_canonical_path,
NULL,
NULL
},
{
{
"audit_data_format",
PGC_POSTMASTER,
AUDIT_OPTIONS,
gettext_noop("Sets the data format for audit files."),
gettext_noop("Currently can be specified as binary only."),
GUC_SUPERUSER_ONLY
},
&g_instance.attr.attr_security.Audit_data_format,
"binary",
NULL,
NULL,
NULL
},
/* Get the ReplConnInfo1 from postgresql.conf and assign to ReplConnArray1. */
{
{
"replconninfo1",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo1 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[1],
"",
check_replconninfo,
assign_replconninfo1,
NULL
},
/* Get the ReplConnInfo2 from postgresql.conf and assign to ReplConnArray2. */
{
{
"replconninfo2",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo2 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[2],
"",
check_replconninfo,
assign_replconninfo2,
NULL
},
/* Get the ReplConnInfo3 from postgresql.conf and assign to ReplConnArray3. */
{
{
"replconninfo3",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo3 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[3],
"",
check_replconninfo,
assign_replconninfo3,
NULL
},
/* Get the ReplConnInfo4 from postgresql.conf and assign to ReplConnArray4. */
{
{
"replconninfo4",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo4 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[4],
"",
check_replconninfo,
assign_replconninfo4,
NULL
},
#ifdef ENABLE_MULTIPLE_NODES
/* Get the ReplConnInfo5 from postgresql.conf and assign to ReplConnArray5. */
{
{
"replconninfo5",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo5 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[5],
"",
check_replconninfo,
assign_replconninfo5,
NULL
},
/* Get the ReplConnInfo6 from postgresql.conf and assign to ReplConnArray6. */
{
{
"replconninfo6",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo6 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[6],
"",
check_replconninfo,
assign_replconninfo6,
NULL
},
/* Get the ReplConnInfo7 from postgresql.conf and assign to ReplConnArray7. */
{
{
"replconninfo7",
PGC_SIGHUP,
REPLICATION_SENDING,
gettext_noop("Sets the replconninfo7 of the HA to listen and authenticate."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.ReplConnInfoArr[7],
"",
check_replconninfo,
assign_replconninfo7,
NULL
},
#endif
{
{
"primary_slotname",
PGC_SIGHUP,
REPLICATION_STANDBY,
gettext_noop("Set the primary slot name."),
NULL,
GUC_NO_RESET_ALL | GUC_IS_NAME
},
&u_sess->attr.attr_storage.PrimarySlotName,
NULL,
NULL,
NULL,
NULL
},
/* control for logging backend modules */
{
{
"logging_module",
PGC_USERSET,
LOGGING_WHAT,
gettext_noop("enable/disable module logging."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_storage.logging_module,
"off(ALL)",
logging_module_check,
logging_module_guc_assign,
logging_module_guc_show
},
{
{
"inplace_upgrade_next_system_object_oids",
PGC_SUSET,
UPGRADE_OPTIONS,
gettext_noop("Sets oids for the system object to be added next during inplace upgrade."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_SUPERUSER_ONLY | GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.Inplace_upgrade_next_system_object_oids,
NULL,
check_inplace_upgrade_next_oids,
NULL,
NULL
},
/* analysis options for dfx */
{
{
"analysis_options",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("enable/disable sql dfx option."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_common.analysis_options,
"off(ALL)",
analysis_options_check,
analysis_options_guc_assign,
analysis_options_guc_show
},
/* End-of-list marker */
{
{
"transparent_encrypted_string",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("The encrypted string to test the transparent encryption key."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_NO_RESET_ALL
},
&g_instance.attr.attr_security.transparent_encrypted_string,
NULL,
NULL,
NULL,
NULL
},
{
{
"transparent_encrypt_kms_url",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("The URL to get transparent encryption key."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_NO_RESET_ALL
},
&g_instance.attr.attr_common.transparent_encrypt_kms_url,
"",
transparent_encrypt_kms_url_region_check,
NULL,
NULL
},
{
{
"transparent_encrypt_kms_region",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("The region to get transparent encryption key."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_NO_RESET_ALL
},
&g_instance.attr.attr_security.transparent_encrypt_kms_region,
"",
transparent_encrypt_kms_url_region_check,
NULL,
NULL
},
/* uncontrolled_memory_context is a white list of MemoryContext allocation. */
{
{
"uncontrolled_memory_context",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Sets the white list of MemoryContext allocation."),
NULL
},
&u_sess->attr.attr_memory.uncontrolled_memory_context,
"",
check_uncontrolled_memory_context,
assign_uncontrolled_memory_context,
show_uncontrolled_memory_context
},
{
{
"retry_ecode_list",
PGC_USERSET,
COORDINATORS,
gettext_noop("Set error code list for CN Retry."),
NULL,
GUC_NOT_IN_SAMPLE
},
&u_sess->attr.attr_sql.retry_errcode_list,
"YY001 YY002 YY003 YY004 YY005 YY006 YY007 YY008 YY009 YY010 YY011 YY012 YY013 YY014 YY015 53200 08006 "
"08000 57P01 XX003 XX009 YY016",
check_errcode_list,
NULL,
NULL
},
{
{
"numa_distribute_mode",
PGC_POSTMASTER,
RESOURCES,
gettext_noop("Sets the NUMA node distribution mode."),
NULL
},
&g_instance.attr.attr_common.numa_distribute_mode,
"none",
check_numa_distribute_mode,
NULL,
NULL
},
{
{
NULL,
(GucContext)0,
(config_group)0,
NULL,
NULL
},
NULL,
NULL,
NULL,
NULL,
NULL
}
};
Size bytes = sizeof(local_configure_names_string);
u_sess->utils_cxt.ConfigureNamesString = (struct config_string*)MemoryContextAlloc(u_sess->top_mem_cxt, bytes);
int rc = memcpy_s(u_sess->utils_cxt.ConfigureNamesString, bytes, local_configure_names_string, bytes);
securec_check(rc, "", "");
}
static void init_configure_names_enum()
{
struct config_enum local_configure_names_enum[] = {
{
{
"backslash_quote",
PGC_USERSET,
COMPAT_OPTIONS_PREVIOUS,
gettext_noop("Sets whether \"\\'\" is allowed in string literals."),
NULL
},
&u_sess->attr.attr_sql.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
},
&u_sess->attr.attr_common.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.")
},
&u_sess->attr.attr_common.client_min_messages,
NOTICE,
client_message_level_options,
check_client_min_messages,
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.")
},
&u_sess->attr.attr_sql.constraint_exclusion,
CONSTRAINT_EXCLUSION_PARTITION,
constraint_exclusion_options,
NULL,
NULL,
NULL
},
{
{
"default_transaction_isolation",
PGC_USERSET,
CLIENT_CONN_STATEMENT,
gettext_noop("Sets the transaction isolation level of each new transaction."),
NULL
},
&u_sess->attr.attr_common.DefaultXactIsoLevel,
XACT_READ_COMMITTED,
isolation_level_options,
NULL,
NULL,
NULL
},
{
{
"IntervalStyle",
PGC_USERSET,
CLIENT_CONN_LOCALE,
gettext_noop("Sets the display format for interval values."),
NULL,
GUC_REPORT
},
&u_sess->attr.attr_common.IntervalStyle,
INTSTYLE_POSTGRES,
intervalstyle_options,
NULL,
NULL,
NULL
},
{
{
"log_error_verbosity",
PGC_SUSET,
LOGGING_WHAT,
gettext_noop("Sets the verbosity of logged messages."),
NULL
},
&u_sess->attr.attr_common.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.")
},
&u_sess->attr.attr_common.log_min_messages,
WARNING,
server_message_level_options,
NULL,
NULL,
NULL
},
{
{
"backtrace_min_messages",
PGC_SUSET,
LOGGING_WHEN,
gettext_noop("Sets the message levels for print backtrace that are logged."),
gettext_noop("Each level includes all the levels that follow it. The later"
" the level, the fewer messages are sent.")
},
&u_sess->attr.attr_common.backtrace_min_messages,
PANIC,
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.")
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.log_statement,
LOGSTMT_NONE,
log_statement_options,
NULL,
NULL,
NULL
},
{
{
"rewrite_rule",
PGC_USERSET,
QUERY_TUNING,
gettext_noop("Sets the rewrite rule."),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_sql.rewrite_rule,
MAGIC_SET,
rewrite_options,
NULL,
NULL,
NULL
},
{
{
"resource_track_log",
PGC_USERSET,
QUERY_TUNING,
gettext_noop("Sets resource track log level"),
NULL,
GUC_LIST_INPUT
},
&u_sess->attr.attr_storage.resource_track_log,
SUMMARY,
resource_track_log_options,
NULL,
NULL,
NULL
},
{
{
"syslog_facility",
PGC_SIGHUP,
LOGGING_WHERE,
gettext_noop("Sets the syslog \"facility\" to be used when syslog enabled."),
NULL
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_storage.guc_synchronous_commit,
SYNCHRONOUS_COMMIT_ON,
synchronous_commit_options,
NULL,
assign_synchronous_commit,
NULL
},
{
{
"sql_compatibility",
PGC_INTERNAL,
UNGROUPED,
gettext_noop("Choose which SQL format to adapt."),
NULL,
GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&u_sess->attr.attr_sql.sql_compatibility,
A_FORMAT,
adapt_database,
NULL,
NULL,
NULL
},
{
{
"explain_perf_mode",
PGC_USERSET,
UNGROUPED,
gettext_noop("Choose which style to print the explain info."),
NULL
},
&u_sess->attr.attr_sql.guc_explain_perf_mode,
EXPLAIN_NORMAL,
explain_option,
NULL,
NULL,
NULL
},
{
{
"skew_option",
PGC_USERSET,
UNGROUPED,
gettext_noop("Choose data skew optimization strategy."),
NULL
},
&u_sess->attr.attr_sql.skew_strategy_store,
SKEW_OPT_NORMAL,
skew_strategy_option,
NULL,
NULL,
NULL
},
{
{
"resource_track_level",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Choose which level info to be collected. "),
NULL
},
&u_sess->attr.attr_resource.resource_track_level,
RESOURCE_TRACK_QUERY,
resource_track_option,
NULL,
NULL,
NULL
},
{
{
"codegen_strategy",
PGC_USERSET,
QUERY_TUNING,
gettext_noop("Choose whether it is allowed to call C-function in codegen."),
NULL
},
&u_sess->attr.attr_sql.codegen_strategy,
CODEGEN_PARTIAL,
codegen_strategy_option,
NULL,
NULL,
NULL
},
{
{
"memory_tracking_mode",
PGC_USERSET,
RESOURCES_MEM,
gettext_noop("Choose which style to track the memory usage."),
NULL
},
&u_sess->attr.attr_memory.memory_tracking_mode,
MEMORY_TRACKING_NONE,
memory_tracking_option,
NULL,
NULL,
NULL
},
{
{
"io_priority",
PGC_USERSET,
RESOURCES_WORKLOAD,
gettext_noop("Sets the IO priority for queries."),
NULL
},
&u_sess->attr.attr_resource.io_priority,
IOPRIORITY_NONE,
io_priority_level_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.")
},
&u_sess->attr.attr_common.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_COLLECTOR,
gettext_noop("Collects function-level statistics on database activity."),
NULL
},
&u_sess->attr.attr_common.pgstat_track_functions,
TRACK_FUNC_OFF,
track_function_options,
NULL,
NULL,
NULL
},
{
{
"wal_level",
PGC_POSTMASTER,
WAL_SETTINGS,
gettext_noop("Sets the level of information written to the WAL."),
NULL
},
&g_instance.attr.attr_storage.wal_level,
WAL_LEVEL_MINIMAL,
wal_level_options,
NULL,
NULL,
NULL
},
{
{
"wal_sync_method",
PGC_SIGHUP,
WAL_SETTINGS,
gettext_noop("Selects the method used for forcing WAL updates to disk."),
NULL
},
&u_sess->attr.attr_storage.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
},
&u_sess->attr.attr_common.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
},
&u_sess->attr.attr_common.xmloption,
XMLOPTION_CONTENT,
xmloption_options,
NULL,
NULL,
NULL
},
#ifdef PGXC
{
{
"remotetype",
PGC_BACKEND,
CONN_AUTH,
gettext_noop("Sets the type of Postgres-XC remote connection"),
NULL
},
&u_sess->attr.attr_common.remoteConnType,
REMOTE_CONN_APP,
pgxc_conn_types,
NULL,
NULL,
NULL
},
{
{
"autovacuum_mode",
PGC_SIGHUP,
AUTOVACUUM,
gettext_noop("Sets the behavior of autovacuum"),
NULL
},
&u_sess->attr.attr_storage.autovacuum_mode,
AUTOVACUUM_DO_ANALYZE_VACUUM,
autovacuum_mode_options,
NULL,
NULL,
NULL
},
#endif
#ifdef ENABLE_MULTIPLE_NODES
{
{
"cstore_insert_mode",
PGC_USERSET,
UNGROUPED,
gettext_noop("decide destination of data inserted"),
NULL
},
&u_sess->attr.attr_storage.cstore_insert_mode,
TO_AUTO,
cstore_insert_mode_options,
NULL,
NULL,
NULL
},
#endif
{
{
"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.")
},
&u_sess->attr.attr_sql.g_planCacheMode,
PLAN_CACHE_MODE_AUTO,
plan_cache_mode_options,
NULL,
NULL,
NULL
},
{
{
"opfusion_debug_mode",
PGC_USERSET,
QUERY_TUNING_METHOD,
gettext_noop("opfusion debug mode."),
NULL
},
&u_sess->attr.attr_sql.opfusion_debug_mode,
BYPASS_OFF,
opfusion_debug_level_options,
NULL,
NULL,
NULL
},
{
{
"instr_unique_sql_track_type",
PGC_INTERNAL,
INSTRUMENTS_OPTIONS,
gettext_noop("unique sql track type"),
NULL
},
&u_sess->attr.attr_common.unique_sql_track_type,
UNIQUE_SQL_TRACK_TOP,
unique_sql_track_option,
NULL,
NULL,
NULL
},
{
{
"remote_read_mode",
PGC_POSTMASTER,
UNGROUPED,
gettext_noop("decide way of remote read"),
NULL
},
&g_instance.attr.attr_storage.remote_read_mode,
REMOTE_READ_AUTH,
remote_read_options,
NULL,
NULL,
NULL
},
/* End-of-list marker */
{
{
NULL,
(GucContext)0,
(config_group)0,
NULL,
NULL
},
NULL,
0,
NULL,
NULL,
NULL,
NULL
}
};
Size bytes = sizeof(local_configure_names_enum);
u_sess->utils_cxt.ConfigureNamesEnum = (struct config_enum*)MemoryContextAlloc(u_sess->top_mem_cxt, bytes);
int rc = memcpy_s(u_sess->utils_cxt.ConfigureNamesEnum, bytes, local_configure_names_enum, bytes);
securec_check(rc, "", "");
}
/** start dealing with uncontrolled_memory_context GUC parameter **/
void free_memory_context_list(memory_context_list* head_node)
{
memory_context_list* last = NULL;
while (head_node != NULL) {
last = head_node;
head_node = head_node->next;
pfree(last);
last = NULL;
}
}
/* This function splits a string into substrings by character ','.
* And these substrings will be appended to a memory_context_list.
* Referenced by GUC uncontrolled_memory_context.
*/
memory_context_list* split_string_into_list(const char* source)
{
int string_length = strlen(source) + 1;
int first_ch_length = 0;
char* str = (char*)MemoryContextAlloc(u_sess->top_mem_cxt, string_length);
errno_t rc = strcpy_s(str, string_length, source);
securec_check_errno(rc, pfree(str), NULL);
memory_context_list* head_node =
(memory_context_list*)MemoryContextAlloc(u_sess->top_mem_cxt, sizeof(memory_context_list));
memory_context_list* current_node = head_node;
current_node->next = NULL;
current_node->value = NULL;
char* first_ch = str;
size_t len = 0;
for (int i = 0; i < string_length; i++, len++) {
if (str[i] == ',' || str[i] == '\0') {
if (current_node->value != NULL) {
/* append a new node to list */
current_node->next =
(memory_context_list*)MemoryContextAlloc(u_sess->top_mem_cxt, sizeof(memory_context_list));
current_node = current_node->next;
current_node->next = NULL;
current_node->value = NULL;
}
first_ch[len] = '\0'; // replace ',' with '\0'
first_ch_length = strlen(first_ch) + 1;
// 'strlen(first_ch) + 1' means including '\0'.
current_node->value = (char*)MemoryContextAlloc(u_sess->top_mem_cxt, first_ch_length);
rc = strcpy_s(current_node->value, first_ch_length, first_ch);
securec_check_errno(rc, pfree(str); free_memory_context_list(head_node), NULL);
/* reset variables so that split next string.
* 'i++' and 'first_ch += len + 1' means skipping '\0'
*/
first_ch += len + 1;
i++;
len = 0;
}
}
return head_node;
}
static bool check_uncontrolled_memory_context(char** newval, void** extra, GucSource source)
{
for (char* p = *newval; *p; p++) {
if (*p < 32 || *p > 126) {
ereport(ERROR,
(errcode(ERRCODE_UNTRANSLATABLE_CHARACTER), errmsg("The text entered contains illegal characters!")));
return false;
}
}
return true;
}
static void assign_uncontrolled_memory_context(const char* newval, void* extra)
{
if (u_sess->utils_cxt.memory_context_limited_white_list) {
free_memory_context_list(u_sess->utils_cxt.memory_context_limited_white_list);
u_sess->utils_cxt.memory_context_limited_white_list = NULL;
}
u_sess->utils_cxt.memory_context_limited_white_list = split_string_into_list(newval);
}
/* show the guc parameter -- uncontrolled_memory_context */
static const char* show_uncontrolled_memory_context(void)
{
const size_t length = 1024;
char* buff = (char*)MemoryContextAllocZero(u_sess->top_mem_cxt, length);
size_t len;
errno_t rc = strcpy_s(buff, length, "MemoryContext white list:\n");
securec_check_errno(rc, buff[length - 1] = '\0', buff); // truncate string and return it.
for (memory_context_list* iter = u_sess->utils_cxt.memory_context_limited_white_list; iter && iter->value;
iter = iter->next) {
rc = strcat_s(buff, length, iter->value);
securec_check_errno(rc, buff[length - 1] = '\0', buff);
len = strlen(buff);
if (len < (length - 1)) {
buff[len] = '\n';
buff[len + 1] = '\0'; // replace '\0' with '\n\0'
}
}
return buff;
} /** end of dealing with uncontrolled_memory_context GUC parameter **/
/*
* 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};
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 initialize_one_guc_option(struct config_generic* gconf);
static void push_old_value(struct config_generic* gconf, GucAction action);
static void report_guc_option(struct config_generic* record);
static void reapply_stacked_values(struct config_generic* variable, struct config_string* holder, GucStack* stack,
const char* curvalue, GucContext curscontext, GucSource cursource);
static void show_guc_config_option(const char* name, DestReceiver* dest);
static void show_all_guc_config(DestReceiver* dest);
static char* _show_option(struct config_generic* record, bool use_units);
static bool validate_option_array_item(const char* name, const char* value, bool skip_if_no_permissions);
/*
* Some infrastructure for checking malloc/strdup/realloc calls
*/
static void* guc_malloc(int elevel, size_t size)
{
void* data = NULL;
/* Avoid unportable behavior of malloc(0) */
if (size == 0) {
size = 1;
}
#ifdef FRONTEND
data = malloc(size);
#else
data = MemoryContextAlloc(u_sess->top_mem_cxt, size);
#endif
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 = NULL;
/* Avoid unportable behavior of realloc(NULL, 0) */
if (old == NULL && size == 0) {
size = 1;
}
#ifdef FRONTEND
data = realloc(old, size);
#else
data = repalloc(old, size);
#endif
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 = NULL;
#ifdef FRONTEND
data = strdup(src);
#else
data = MemoryContextStrdup(u_sess->top_mem_cxt, src);
#endif
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 = NULL;
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)) {
pfree(oldval);
oldval = NULL;
}
}
/*
* 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 = NULL;
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_INT64:
if (extra == ((struct config_int64*)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;
default:
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)) {
pfree(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_INT64:
val->val.int64val = *((struct config_int64*)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;
default:
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_INT64:
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;
default:
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 u_sess->guc_variables;
}
#ifndef ENABLE_MULTIPLE_NODES
static void init_single_node_unsupport_guc()
{
/* for Bool Guc Variables */
u_sess->attr.attr_sql.enable_remotejoin = true;
u_sess->attr.attr_sql.enable_fast_query_shipping = true;
u_sess->attr.attr_sql.enable_remotegroup = true;
u_sess->attr.attr_sql.enable_remotesort = true;
u_sess->attr.attr_sql.enable_remotelimit = true;
u_sess->attr.attr_sql.gtm_backup_barrier = false;
u_sess->attr.attr_sql.enable_stream_operator = true;
u_sess->attr.attr_sql.enable_unshipping_log = true;
u_sess->attr.attr_sql.enable_stream_concurrent_update = true;
u_sess->attr.attr_sql.enable_stream_recursive = true;
u_sess->attr.attr_sql.enable_random_datanode = true;
u_sess->attr.attr_sql.enable_fstream = false;
u_sess->attr.attr_common.PersistentConnections = false;
u_sess->attr.attr_network.PoolerForceReuse = false;
u_sess->attr.attr_network.comm_client_bind = false;
u_sess->attr.attr_common.enable_redistribute = false;
u_sess->attr.attr_sql.enable_cluster_resize = false;
u_sess->attr.attr_resource.bypass_workload_manager = false;
u_sess->attr.attr_resource.enable_control_group = false;
u_sess->attr.attr_resource.enable_cgroup_switch = false;
u_sess->attr.attr_resource.enable_verify_statements = false;
u_sess->attr.attr_resource.enable_force_memory_control = false;
u_sess->attr.attr_resource.enable_dywlm_adjust = false;
u_sess->attr.attr_resource.enable_reaper_backend = true;
u_sess->attr.attr_resource.enable_transaction_parctl = true;
u_sess->attr.attr_sql.agg_redistribute_enhancement = false;
u_sess->attr.attr_sql.enable_agg_pushdown_for_cooperation_analysis = true;
u_sess->attr.attr_common.enable_tsdb = false;
u_sess->attr.attr_sql.acceleration_with_compute_pool = false;
u_sess->attr.attr_storage.enable_cbm_tracking = false;
u_sess->attr.attr_sql.enable_constraint_optimization = true;
u_sess->attr.attr_sql.enable_csqual_pushdown = true;
u_sess->attr.attr_sql.enable_hadoop_env = false;
u_sess->attr.attr_sql.enable_hdfs_predicate_pushdown = true;
u_sess->attr.attr_sql.enable_trigger_shipping = true;
u_sess->attr.attr_storage.gds_debug_mod = false;
u_sess->attr.attr_sql.enable_slot_log = false;
u_sess->attr.attr_storage.enable_twophase_commit = false;
/* for Int Guc Variables */
u_sess->attr.attr_resource.max_active_statements = -1;
u_sess->attr.attr_resource.dynamic_memory_quota = 80;
u_sess->attr.attr_network.PoolerTimeout = 600;
u_sess->attr.attr_network.PoolerConnectTimeout = 60;
u_sess->attr.attr_network.PoolerCancelTimeout = 15;
u_sess->attr.attr_sql.best_agg_plan = 0;
u_sess->attr.attr_network.comm_max_datanode = 256;
u_sess->attr.attr_common.gtm_connect_timeout = 2;
u_sess->attr.attr_storage.gtm_connect_retries = 30;
u_sess->attr.attr_common.gtm_rw_timeout = 60;
u_sess->attr.attr_storage.gtm_conn_check_interval = 10;
u_sess->attr.attr_common.max_datanode_for_plan = 0;
u_sess->attr.attr_common.max_datanode_for_plan = 0;
u_sess->attr.attr_sql.acce_min_datasize_per_thread = 500000;
u_sess->attr.attr_storage.cstore_insert_mode = TO_AUTO;
u_sess->attr.attr_storage.dfs_max_parsig_length = 512;
u_sess->attr.attr_sql.schedule_splits_threshold = 60000;
u_sess->attr.attr_storage.replorigin_sesssion_origin = 0;
u_sess->attr.attr_sql.query_dop_tmp = 1;
/* for Double Guc Variables */
u_sess->attr.attr_sql.stream_multiple = DEFAULT_STREAM_MULTIPLE;
/* for String Guc Variables */
u_sess->attr.attr_common.node_group_mode = (char *)"node group";
u_sess->attr.attr_common.GtmHostInfoStringArray[0] = (char *)"localhost";
u_sess->attr.attr_common.GtmHostInfoStringArray[1] = (char *)"localhost";
u_sess->attr.attr_common.GtmHostInfoStringArray[2] = (char *)"";
u_sess->attr.attr_common.GtmHostInfoStringArray[3] = (char *)"";
u_sess->attr.attr_common.GtmHostInfoStringArray[4] = (char *)"";
u_sess->attr.attr_common.GtmHostInfoStringArray[5] = (char *)"";
u_sess->attr.attr_common.GtmHostInfoStringArray[6] = (char *)"";
u_sess->attr.attr_common.GtmHostInfoStringArray[7] = (char *)"";
u_sess->attr.attr_common.current_logic_cluster_name = (char *)"";
if (!IsUnderPostmaster) {
g_instance.attr.attr_network.PoolerStatelessReuse = false;
g_instance.attr.attr_storage.enable_gtm_free = true;
g_instance.attr.attr_resource.enable_dynamic_workload = false;
g_instance.attr.attr_sql.enable_acceleration_cluster_wlm = false;
g_instance.attr.attr_resource.enable_backend_control = false;
g_instance.attr.attr_resource.enable_vacuum_control = false;
g_instance.attr.attr_resource.enable_perm_space = false;
g_instance.attr.attr_storage.comm_cn_dn_logic_conn = false;
g_instance.attr.attr_network.MaxPoolSize = 400;
g_instance.attr.attr_network.PoolerPort = 6667;
g_instance.attr.attr_common.GtmHostPortArray[0] = 6666;
g_instance.attr.attr_common.GtmHostPortArray[1] = 6665;
g_instance.attr.attr_common.GtmHostPortArray[2] = 6666;
g_instance.attr.attr_common.GtmHostPortArray[3] = 6666;
g_instance.attr.attr_common.GtmHostPortArray[4] = 6666;
g_instance.attr.attr_common.GtmHostPortArray[5] = 6666;
g_instance.attr.attr_common.GtmHostPortArray[6] = 6666;
g_instance.attr.attr_common.GtmHostPortArray[7] = 6666;
g_instance.attr.attr_common.MaxDataNodes = 64;
g_instance.attr.attr_network.MaxCoords = 1024;
g_instance.attr.attr_storage.gtm_option = GTMOPTION_GTMFREE;
g_instance.attr.attr_network.comm_max_stream = 1024;
g_instance.attr.attr_sql.enable_orc_cache = true;
g_instance.attr.attr_common.lastval_supported = false;
g_instance.attr.attr_storage.max_replication_slots = 8;
g_instance.attr.attr_sql.max_resource_package = 0;
g_instance.attr.attr_common.max_cached_tuplebufs = 8192;
g_instance.attr.attr_common.max_changes_in_memory = 4096;
}
return;
}
#endif
/*
* Build the sorted array. This is split out so that it could be
* re-executed after startup (eg, 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;
/* Bind thread local GUC variables to their names */
init_configure_names_bool();
init_configure_names_int();
init_configure_names_int64();
init_configure_names_real();
init_configure_names_string();
init_configure_names_enum();
for (i = 0; u_sess->utils_cxt.ConfigureNamesBool[i].gen.name; i++) {
struct config_bool* conf = &u_sess->utils_cxt.ConfigureNamesBool[i];
/* Rather than requiring vartype to be filled in by hand, do this: */
conf->gen.vartype = PGC_BOOL;
num_vars++;
}
for (i = 0; u_sess->utils_cxt.ConfigureNamesInt[i].gen.name; i++) {
struct config_int* conf = &u_sess->utils_cxt.ConfigureNamesInt[i];
conf->gen.vartype = PGC_INT;
num_vars++;
}
for (i = 0; u_sess->utils_cxt.ConfigureNamesInt64[i].gen.name; i++) {
struct config_int64* conf = &u_sess->utils_cxt.ConfigureNamesInt64[i];
conf->gen.vartype = PGC_INT64;
num_vars++;
}
for (i = 0; u_sess->utils_cxt.ConfigureNamesReal[i].gen.name; i++) {
struct config_real* conf = &u_sess->utils_cxt.ConfigureNamesReal[i];
conf->gen.vartype = PGC_REAL;
num_vars++;
}
for (i = 0; u_sess->utils_cxt.ConfigureNamesString[i].gen.name; i++) {
struct config_string* conf = &u_sess->utils_cxt.ConfigureNamesString[i];
conf->gen.vartype = PGC_STRING;
num_vars++;
}
for (i = 0; u_sess->utils_cxt.ConfigureNamesEnum[i].gen.name; i++) {
struct config_enum* conf = &u_sess->utils_cxt.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; u_sess->utils_cxt.ConfigureNamesBool[i].gen.name; i++)
guc_vars[num_vars++] = &u_sess->utils_cxt.ConfigureNamesBool[i].gen;
for (i = 0; u_sess->utils_cxt.ConfigureNamesInt[i].gen.name; i++)
guc_vars[num_vars++] = &u_sess->utils_cxt.ConfigureNamesInt[i].gen;
for (i = 0; u_sess->utils_cxt.ConfigureNamesInt64[i].gen.name; i++)
guc_vars[num_vars++] = &u_sess->utils_cxt.ConfigureNamesInt64[i].gen;
for (i = 0; u_sess->utils_cxt.ConfigureNamesReal[i].gen.name; i++)
guc_vars[num_vars++] = &u_sess->utils_cxt.ConfigureNamesReal[i].gen;
for (i = 0; u_sess->utils_cxt.ConfigureNamesString[i].gen.name; i++)
guc_vars[num_vars++] = &u_sess->utils_cxt.ConfigureNamesString[i].gen;
for (i = 0; u_sess->utils_cxt.ConfigureNamesEnum[i].gen.name; i++)
guc_vars[num_vars++] = &u_sess->utils_cxt.ConfigureNamesEnum[i].gen;
if (u_sess->guc_variables) {
pfree(u_sess->guc_variables);
}
u_sess->guc_variables = guc_vars;
u_sess->num_guc_variables = num_vars;
u_sess->utils_cxt.size_guc_variables = size_vars;
qsort((void*)u_sess->guc_variables, u_sess->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 (u_sess->num_guc_variables + 1 >= u_sess->utils_cxt.size_guc_variables) {
/*
* Increase the vector by 25%
*/
int size_vars = u_sess->utils_cxt.size_guc_variables + u_sess->utils_cxt.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, u_sess->guc_variables, size_vars * sizeof(struct config_generic*));
}
if (guc_vars == NULL) {
return false; /* out of memory */
}
u_sess->guc_variables = guc_vars;
u_sess->utils_cxt.size_guc_variables = size_vars;
}
u_sess->guc_variables[u_sess->num_guc_variables++] = var;
qsort((void*)u_sess->guc_variables, u_sess->num_guc_variables, sizeof(struct config_generic*), guc_var_compare);
return true;
}
/*
* 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 = NULL;
struct config_generic* gen = NULL;
var = (struct config_string*)guc_malloc(elevel, sz);
if (var == NULL) {
return NULL;
}
errno_t rc = memset_s(var, sz, 0, sz);
securec_check(rc, "\0", "\0");
gen = &var->gen;
gen->name = guc_strdup(elevel, name);
if (gen->name == NULL) {
pfree(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)) {
pfree((void*)gen->name);
pfree(var);
return NULL;
}
return gen;
}
/*
* Look up option NAME. If it exists, return a pointer to its record,
* else return NULL. If create_placeholders is TRUE, we'll create a
* placeholder record for a valid-looking custom variable name.
*/
static struct config_generic* find_option(const char* name, bool create_placeholders, int elevel)
{
const char** key = &name;
struct config_generic** res;
int i;
Assert(name);
/*
* By equating const char ** with struct config_generic *, we are assuming
* the name field is first in config_generic.
*/
res = (struct config_generic**)bsearch((void*)&key,
(void*)u_sess->guc_variables,
u_sess->num_guc_variables,
sizeof(struct config_generic*),
guc_var_compare);
if (res != NULL) {
return *res;
}
/*
* See if the name is an obsolete name for a variable. We assume that the
* set of supported old names is short enough that a brute-force search is
* the best way.
*/
for (i = 0; map_old_guc_names[i] != NULL; i += 2) {
if (guc_name_compare(name, map_old_guc_names[i]) == 0) {
return find_option(map_old_guc_names[i + 1], false, elevel);
}
}
if (create_placeholders) {
/*
* Check if the name is qualified, and if so, add a placeholder.
*/
if (strchr(name, GUC_QUALIFIER_SEPARATOR) != NULL) {
return add_placeholder_variable(name, elevel);
}
}
/* Unknown name */
return NULL;
}
/*
* comparator for qsorting and bsearching guc_variables array
*/
static int guc_var_compare(const void* a, const void* b)
{
const struct config_generic* confa = *(struct config_generic* const*)a;
const struct config_generic* confb = *(struct config_generic* const*)b;
return guc_name_compare(confa->name, confb->name);
}
/*
* the bare comparison function for GUC names
*/
static int guc_name_compare(const char* namea, const char* nameb)
{
/*
* The temptation to use strcasecmp() here must be resisted, because the
* array ordering has to remain stable across setlocale() calls. So, build
* our own with a simple ASCII-only downcasing.
*/
while (*namea && *nameb) {
char cha = *namea++;
char chb = *nameb++;
if (cha >= 'A' && cha <= 'Z') {
cha += 'a' - 'A';
}
if (chb >= 'A' && chb <= 'Z') {
chb += 'a' - 'A';
}
if (cha != chb) {
return cha - chb;
}
}
if (*namea) {
return 1; /* a is longer */
}
if (*nameb) {
return -1; /* b is longer */
}
return 0;
}
/*
* Initiaize Postmaster level GUC options during postmaster proc.
*
* Note that some guc can't get right value because of some global var not init,
* so need this function to init postmaster level guc.
*/
void InitializePostmasterGUC()
{
#ifdef ENABLE_MULTIPLE_NODES
(void)check_enable_gtm_free(&g_instance.attr.attr_storage.enable_gtm_free, NULL, PGC_S_DEFAULT);
#else
g_instance.attr.attr_storage.enable_gtm_free = true;
#endif
g_instance.attr.attr_network.PoolerPort = g_instance.attr.attr_network.PostPortNumber + 1;
}
static void AdjustDefaultGUC()
{
if (g_instance.attr.attr_storage.enable_double_write == false) {
u_sess->attr.attr_storage.pagewriter_threshold = g_instance.attr.attr_storage.NBuffers;
}
}
/*
* Initialize GUC options during program startup.
*
* Note that we cannot read the config file yet, since we have not yet
* processed command-line switches.
*/
void InitializeGUCOptions(void)
{
int i;
/*
* Before log_line_prefix could possibly receive a nonempty setting, make
* sure that timezone processing is minimally alive (see elog.c).
*/
pg_timezone_initialize();
/*
* Build sorted array of all GUC variables.
*/
build_guc_variables();
/*
* Load all variables with their compiled-in defaults, and initialize
* status fields as needed.
*/
for (i = 0; i < u_sess->num_guc_variables; i++) {
initialize_one_guc_option(u_sess->guc_variables[i]);
}
#ifndef ENABLE_MULTIPLE_NODES
init_single_node_unsupport_guc();
#endif
u_sess->utils_cxt.guc_dirty = false;
u_sess->utils_cxt.reporting_enabled = false;
/*
* Prevent any attempt to override the transaction modes from
* non-interactive sources.
*/
SetConfigOption("transaction_isolation", "default", PGC_POSTMASTER, PGC_S_OVERRIDE);
SetConfigOption("transaction_read_only", "no", PGC_POSTMASTER, PGC_S_OVERRIDE);
SetConfigOption("transaction_deferrable", "no", PGC_POSTMASTER, PGC_S_OVERRIDE);
/*
* For historical reasons, some GUC parameters can receive defaults from
* environment variables. Process those settings.
*/
InitializeGUCOptionsFromEnvironment();
AdjustDefaultGUC();
}
/*
* Assign any GUC values that can come from the server's environment.
*
* This is called from InitializeGUCOptions, and also from ProcessConfigFile
* to deal with the possibility that a setting has been removed from
* postgresql.conf and should now get a value from the environment.
* (The latter is a kludge that should probably go away someday; if so,
* fold this back into InitializeGUCOptions.)
*/
static void InitializeGUCOptionsFromEnvironment(void)
{
char* env = NULL;
long stack_rlimit;
env = gs_getenv_r("PGPORT");
if (env != NULL) {
check_backend_env(env);
SetConfigOption("port", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
}
env = gs_getenv_r("PGDATESTYLE");
if (env != NULL) {
check_backend_env(env);
SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
}
env = gs_getenv_r("PGCLIENTENCODING");
if (env != NULL) {
check_backend_env(env);
SetConfigOption("client_encoding", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
}
/*
* rlimit isn't exactly an "environment variable", but it behaves about
* the same. If we can identify the platform stack depth rlimit, increase
* default stack depth setting up to whatever is safe (but at most 2MB).
*/
stack_rlimit = DEFUALT_STACK_SIZE * 1024L;
if (stack_rlimit > 0) {
long new_limit = (stack_rlimit - STACK_DEPTH_SLOP) / 1024L;
if (new_limit > 100) {
char limbuf[16];
new_limit = Min(new_limit, 2048);
int rcs = snprintf_s(limbuf, sizeof(limbuf), sizeof(limbuf) - 1, "%ld", new_limit);
securec_check_ss(rcs, "\0", "\0");
SetConfigOption("max_stack_depth", limbuf, PGC_POSTMASTER, PGC_S_ENV_VAR);
}
}
}
/*
* Initialize one GUC option variable to its compiled-in default.
*
* Note: the reason for calling check_hooks is not that we think the boot_val
* might fail, but that the hooks might wish to compute an "extra" struct.
*/
static void initialize_one_guc_option(struct config_generic* gconf)
{
gconf->status = 0;
gconf->source = PGC_S_DEFAULT;
gconf->reset_source = PGC_S_DEFAULT;
gconf->scontext = PGC_INTERNAL;
gconf->reset_scontext = PGC_INTERNAL;
gconf->stack = NULL;
gconf->extra = NULL;
gconf->sourcefile = NULL;
gconf->sourceline = 0;
switch (gconf->vartype) {
case PGC_BOOL: {
struct config_bool* conf = (struct config_bool*)gconf;
bool newval = conf->boot_val;
void* extra = NULL;
if (!call_bool_check_hook(conf, &newval, &extra, PGC_S_DEFAULT, LOG)) {
ereport(FATAL, (errmsg("failed to initialize %s to %d", conf->gen.name, (int)newval)));
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, extra);
}
if (!IsUnderPostmaster || gconf->context != PGC_POSTMASTER) {
*conf->variable = conf->reset_val = newval;
}
conf->gen.extra = conf->reset_extra = extra;
break;
}
case PGC_INT: {
struct config_int* conf = (struct config_int*)gconf;
int newval = conf->boot_val;
void* extra = NULL;
Assert(newval >= conf->min);
Assert(newval <= conf->max);
if (!call_int_check_hook(conf, &newval, &extra, PGC_S_DEFAULT, LOG)) {
ereport(FATAL, (errmsg("failed to initialize %s to %d", conf->gen.name, newval)));
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, extra);
}
if (!IsUnderPostmaster || gconf->context != PGC_POSTMASTER) {
*conf->variable = conf->reset_val = newval;
}
conf->gen.extra = conf->reset_extra = extra;
break;
}
case PGC_INT64: {
struct config_int64* conf = (struct config_int64*)gconf;
int64 newval = conf->boot_val;
void* extra = NULL;
Assert(newval >= conf->min);
Assert(newval <= conf->max);
if (!call_int64_check_hook(conf, &newval, &extra, PGC_S_DEFAULT, LOG)) {
ereport(FATAL, (errmsg("failed to initialize %s to " INT64_FORMAT, conf->gen.name, newval)));
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, extra);
}
if (!IsUnderPostmaster || gconf->context != PGC_POSTMASTER) {
*conf->variable = conf->reset_val = newval;
}
conf->gen.extra = conf->reset_extra = extra;
break;
}
case PGC_REAL: {
struct config_real* conf = (struct config_real*)gconf;
double newval = conf->boot_val;
void* extra = NULL;
Assert(newval >= conf->min);
Assert(newval <= conf->max);
if (!call_real_check_hook(conf, &newval, &extra, PGC_S_DEFAULT, LOG)) {
ereport(FATAL, (errmsg("failed to initialize %s to %g", conf->gen.name, newval)));
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, extra);
}
if (!IsUnderPostmaster || gconf->context != PGC_POSTMASTER) {
*conf->variable = conf->reset_val = newval;
}
conf->gen.extra = conf->reset_extra = extra;
break;
}
case PGC_STRING: {
struct config_string* conf = (struct config_string*)gconf;
char* newval = NULL;
void* extra = NULL;
/* non-NULL boot_val must always get strdup'd */
if (conf->boot_val != NULL) {
newval = guc_strdup(FATAL, conf->boot_val);
} else {
newval = NULL;
}
if (!call_string_check_hook(conf, &newval, &extra, PGC_S_DEFAULT, LOG)) {
ereport(FATAL, (errmsg("failed to initialize %s to \"%s\"", conf->gen.name, newval ? newval : "")));
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, extra);
}
if (!IsUnderPostmaster || gconf->context != PGC_POSTMASTER) {
*conf->variable = conf->reset_val = newval;
}
conf->gen.extra = conf->reset_extra = extra;
break;
}
case PGC_ENUM: {
struct config_enum* conf = (struct config_enum*)gconf;
int newval = conf->boot_val;
void* extra = NULL;
if (!call_enum_check_hook(conf, &newval, &extra, PGC_S_DEFAULT, LOG)) {
ereport(FATAL, (errmsg("failed to initialize %s to %d", conf->gen.name, newval)));
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, extra);
}
if (!IsUnderPostmaster || gconf->context != PGC_POSTMASTER) {
*conf->variable = conf->reset_val = newval;
}
conf->gen.extra = conf->reset_extra = extra;
break;
}
default:
break;
}
}
/* initialize guc variables which need to be sended to stream threads */
void init_sync_guc_variables()
{
int i;
struct config_generic** res;
int sync_guc_number = lengthof(sync_guc_variable_namelist);
u_sess->utils_cxt.sync_guc_variables =
(struct config_generic**)palloc(sizeof(struct config_generic*) * sync_guc_number);
for (i = 0; i < sync_guc_number; i++) {
const char** key = &sync_guc_variable_namelist[i];
res = (struct config_generic**)bsearch((void*)&key,
(void*)u_sess->guc_variables,
u_sess->num_guc_variables,
sizeof(struct config_generic*),
guc_var_compare);
Assert(res);
u_sess->utils_cxt.sync_guc_variables[i] = *res;
}
}
/*repair the guc variables in stream thread*/
void repair_guc_variables()
{
int i;
struct config_generic** res;
int sync_guc_number = lengthof(sync_guc_variable_namelist);
for (i = 0; i < sync_guc_number; i++) {
const char** key = &sync_guc_variable_namelist[i];
res = (struct config_generic**)bsearch((void*)&key,
(void*)u_sess->guc_variables,
u_sess->num_guc_variables,
sizeof(struct config_generic*),
guc_var_compare);
Assert(res);
switch ((*res)->vartype) {
case PGC_BOOL: {
struct config_bool* destination = (struct config_bool*)(*res);
struct config_bool* source = (struct config_bool*)u_sess->utils_cxt.sync_guc_variables[i];
bool newval = false;
void* newextra = NULL;
if (*destination->variable == *source->variable) {
break;
}
newval = *source->variable;
if (destination->check_hook) {
if (!call_bool_check_hook(destination, &newval, &newextra, destination->gen.source, LOG)) {
ereport(LOG,
(errmsg("Failed to initialize %s to %s for stream thread",
destination->gen.name,
newval ? "true" : "false")));
break;
}
}
if (destination->assign_hook) {
(*destination->assign_hook)(newval, newextra);
}
*destination->variable = *source->variable;
set_extra_field(&destination->gen, &destination->gen.extra, newextra);
break;
}
case PGC_INT: {
struct config_int* destination = (struct config_int*)(*res);
struct config_int* source = (struct config_int*)u_sess->utils_cxt.sync_guc_variables[i];
int newval;
void* newextra = NULL;
if (*destination->variable == *source->variable) {
break;
}
newval = *source->variable;
if (destination->check_hook) {
if (!call_int_check_hook(destination, &newval, &newextra, destination->gen.source, LOG)) {
ereport(LOG,
(errmsg("Failed to initialize %s to %d for stream thread", destination->gen.name, newval)));
break;
}
}
if (destination->assign_hook) {
(*destination->assign_hook)(newval, newextra);
}
*destination->variable = *source->variable;
set_extra_field(&destination->gen, &destination->gen.extra, newextra);
break;
}
case PGC_INT64: {
struct config_int64* destination = (struct config_int64*)(*res);
struct config_int64* source = (struct config_int64*)u_sess->utils_cxt.sync_guc_variables[i];
int64 newval;
void* newextra = NULL;
if (*destination->variable == *source->variable) {
break;
}
newval = *source->variable;
if (destination->check_hook) {
if (!call_int64_check_hook(destination, &newval, &newextra, destination->gen.source, LOG)) {
ereport(LOG,
(errmsg("Failed to initialize %s to " INT64_FORMAT " for stream thread",
destination->gen.name,
newval)));
break;
}
}
if (destination->assign_hook) {
(*destination->assign_hook)(newval, newextra);
}
*destination->variable = *source->variable;
set_extra_field(&destination->gen, &destination->gen.extra, newextra);
break;
}
case PGC_REAL: {
struct config_real* destination = (struct config_real*)(*res);
struct config_real* source = (struct config_real*)u_sess->utils_cxt.sync_guc_variables[i];
double newval;
void* newextra = NULL;
if (*destination->variable == *source->variable) {
break;
}
newval = *source->variable;
if (destination->check_hook) {
if (!call_real_check_hook(destination, &newval, &newextra, destination->gen.source, LOG)) {
ereport(LOG,
(errmsg("Failed to initialize %s to %g for stream thread", destination->gen.name, newval)));
break;
}
}
if (destination->assign_hook) {
(*destination->assign_hook)(newval, newextra);
}
*destination->variable = *source->variable;
set_extra_field(&destination->gen, &destination->gen.extra, newextra);
break;
}
case PGC_STRING: {
struct config_string* destination = (struct config_string*)(*res);
struct config_string* source = (struct config_string*)u_sess->utils_cxt.sync_guc_variables[i];
char* newval = NULL;
void* newextra = NULL;
newval = guc_strdup(FATAL, *source->variable);
if (strlen(*destination->variable) == strlen(*source->variable) &&
0 == strncmp(*destination->variable, *source->variable, strlen(*destination->variable))) {
break;
}
if (destination->check_hook) {
if (!call_string_check_hook(destination, &newval, &newextra, destination->gen.source, LOG)) {
ereport(LOG,
(errmsg("Failed to initialize %s to \"%s\" for stream thread",
destination->gen.name,
newval ? newval : "")));
break;
}
}
if (destination->assign_hook) {
(*destination->assign_hook)(newval, newextra);
}
set_string_field(destination, destination->variable, newval);
set_extra_field(&destination->gen, &destination->gen.extra, newextra);
break;
}
case PGC_ENUM: {
struct config_enum* destination = (struct config_enum*)(*res);
struct config_enum* source = (struct config_enum*)u_sess->utils_cxt.sync_guc_variables[i];
int newval;
void* newextra = NULL;
if (*destination->variable == *source->variable) {
break;
}
newval = *source->variable;
if (destination->check_hook) {
if (!call_enum_check_hook(destination, &newval, &newextra, destination->gen.source, LOG)) {
ereport(LOG,
(errmsg("Failed to initialize %s to %d for stream thread", destination->gen.name, newval)));
break;
}
}
if (destination->assign_hook) {
(*destination->assign_hook)(newval, newextra);
}
*destination->variable = *source->variable;
set_extra_field(&destination->gen, &destination->gen.extra, newextra);
break;
}
default:
break;
}
}
SetThreadLocalGUC(u_sess);
}
/*
* Select the configuration files and data directory to be used, and
* do the initial read of postgresql.conf.
*
* This is called after processing command-line switches.
* userDoption is the -D switch value if any (NULL if unspecified).
* progname is just for use in error messages.
*
* Returns true on success; on failure, prints a suitable error message
* to stderr and returns false.
*/
bool SelectConfigFiles(const char* userDoption, const char* progname)
{
char* configdir = NULL;
char* fname = NULL;
struct stat stat_buf;
char* motfname = NULL;
char* TempConfigPath = NULL;
char TempConfigFile[MAXPGPATH] = {0};
char TempConfigFileName[MAXPGPATH] = {0};
int rc;
/* configdir is -D option, or $PGDATA if no -D */
if (userDoption != NULL) {
configdir = make_absolute_path(userDoption);
} else {
char* pgdata = gs_getenv_r("PGDATA");
if (pgdata != NULL) {
check_backend_env(pgdata);
}
configdir = make_absolute_path(pgdata);
}
/*
* Find the configuration file: if config_file was specified on the
* command line, use it, else use configdir/postgresql.conf. In any case
* ensure the result is an absolute path, so that it will be interpreted
* the same way by future backends.
*/
if (g_instance.attr.attr_common.ConfigFileName) {
fname = make_absolute_path(g_instance.attr.attr_common.ConfigFileName);
} else if (configdir != NULL) {
fname = (char*)guc_malloc(FATAL, strlen(configdir) + strlen(CONFIG_FILENAME) + 2);
rc = snprintf_s(fname,
strlen(configdir) + strlen(CONFIG_FILENAME) + 2,
strlen(configdir) + strlen(CONFIG_FILENAME) + 1,
"%s/%s",
configdir,
CONFIG_FILENAME);
securec_check_ss(rc, configdir, "\0");
} else {
write_stderr("%s does not know where to find the server configuration file.\n"
"You must specify the --config-file or -D invocation "
"option or set the PGDATA environment variable.\n",
progname);
return false;
}
/*
* Set the g_instance.attr.attr_common.ConfigFileName GUC variable to its final value, ensuring that
* it can't be overridden later.
*/
SetConfigOption("config_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
pfree(fname);
/*
* Now read the config file for the first time.
*/
if (g_instance.attr.attr_common.ConfigFileName != NULL &&
stat(g_instance.attr.attr_common.ConfigFileName, &stat_buf) != 0) {
int str_len = strlen(g_instance.attr.attr_common.ConfigFileName);
rc = strncpy_s(
TempConfigFile, MAXPGPATH, g_instance.attr.attr_common.ConfigFileName, Min(str_len, MAXPGPATH - 1));
securec_check(rc, "\0", "\0");
if (str_len > MAXPGPATH - 1) {
ereport(WARNING, (errmsg("strncpy_s failed")));
}
TempConfigPath = TempConfigFile;
get_parent_directory(TempConfigPath);
rc = snprintf_s(TempConfigFileName, MAXPGPATH, MAXPGPATH - 1, "%s/%s", TempConfigPath, CONFIG_BAK_FILENAME);
securec_check_ss(rc, configdir, "\0");
if (lstat(TempConfigFileName, &stat_buf) != 0) {
write_stderr("%s cannot access the server configuration file \"%s\": %s\n",
progname,
g_instance.attr.attr_common.ConfigFileName,
gs_strerror(errno));
pfree(configdir);
return false;
} else {
if (rename(TempConfigFileName, g_instance.attr.attr_common.ConfigFileName) != 0) {
write_stderr("%s: rename file %s to %s failed, errmsg: %s\n",
progname,
TempConfigFileName,
g_instance.attr.attr_common.ConfigFileName,
gs_strerror(errno));
pfree(configdir);
return false;
}
}
}
ProcessConfigFile(PGC_POSTMASTER);
synchronous_commit = (volatile int)u_sess->attr.attr_storage.guc_synchronous_commit;
most_available_sync = (volatile bool)g_instance.attr.attr_storage.gucMostAvailableSync;
/*
* If the data_directory GUC variable has been set, use that as t_thrd.proc_cxt.DataDir;
* otherwise use configdir if set; else punt.
*
* Note: SetDataDir will copy and absolute-ize its argument, so we don't
* have to.
*/
if (g_instance.attr.attr_common.data_directory) {
SetDataDir(g_instance.attr.attr_common.data_directory);
} else if (configdir != NULL) {
SetDataDir(configdir);
} else {
write_stderr("%s does not know where to find the database system data.\n"
"This can be specified as \"data_directory\" in \"%s\", "
"or by the -D invocation option, or by the "
"PGDATA environment variable.\n",
progname,
g_instance.attr.attr_common.ConfigFileName);
return false;
}
/*
* Reflect the final t_thrd.proc_cxt.DataDir value back into the data_directory GUC var.
* (If you are wondering why we don't just make them a single variable,
* it's because the EXEC_BACKEND case needs t_thrd.proc_cxt.DataDir to be transmitted to
* child backends specially. XXX is that still true? Given that we now
* chdir to t_thrd.proc_cxt.DataDir, EXEC_BACKEND can read the config file without knowing
* t_thrd.proc_cxt.DataDir in advance.)
*/
SetConfigOption("data_directory", t_thrd.proc_cxt.DataDir, PGC_POSTMASTER, PGC_S_OVERRIDE);
if (g_instance.attr.attr_common.MOTConfigFileName)
motfname = make_absolute_path(g_instance.attr.attr_common.MOTConfigFileName);
else if (configdir) {
motfname = (char*)guc_malloc(FATAL,strlen(configdir) + strlen(MOT_CONFIG_FILENAME) + 2);
rc = snprintf_s(motfname,
strlen(configdir) + strlen(MOT_CONFIG_FILENAME) + 2,
strlen(configdir) + strlen(MOT_CONFIG_FILENAME) + 1,
"%s/%s",
configdir,
MOT_CONFIG_FILENAME);
securec_check_ss(rc, configdir, "\0");
}
SetConfigOption("mot_config_file", motfname, PGC_POSTMASTER, PGC_S_OVERRIDE);
selfpfree(motfname);
/*
* If timezone_abbreviations wasn't set in the configuration file, install
* the default value. We do it this way because we can't safely install a
* "real" value until my_exec_path is set, which may not have happened
* when InitializeGUCOptions runs, so the bootstrap default value cannot
* be the real desired default.
*/
pg_timezone_abbrev_initialize();
/*
* Figure out where pg_hba.conf is, and make sure the path is absolute.
*/
if (g_instance.attr.attr_common.HbaFileName) {
fname = make_absolute_path(g_instance.attr.attr_common.HbaFileName);
} else if (configdir != NULL) {
fname = (char*)guc_malloc(FATAL, strlen(configdir) + strlen(HBA_FILENAME) + 2);
rc = snprintf_s(fname,
strlen(configdir) + strlen(HBA_FILENAME) + 2,
strlen(configdir) + strlen(HBA_FILENAME) + 1,
"%s/%s",
configdir,
HBA_FILENAME);
securec_check_ss(rc, configdir, "\0");
} else {
write_stderr("%s does not know where to find the \"hba\" configuration file.\n"
"This can be specified as \"hba_file\" in \"%s\", "
"or by the -D invocation option, or by the "
"PGDATA environment variable.\n",
progname,
g_instance.attr.attr_common.ConfigFileName);
return false;
}
SetConfigOption("hba_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
pfree(fname);
/*
* Likewise for pg_ident.conf.
*/
if (g_instance.attr.attr_common.IdentFileName) {
fname = make_absolute_path(g_instance.attr.attr_common.IdentFileName);
} else if (configdir != NULL) {
fname = (char*)guc_malloc(FATAL, strlen(configdir) + strlen(IDENT_FILENAME) + 2);
rc = snprintf_s(fname,
strlen(configdir) + strlen(IDENT_FILENAME) + 2,
strlen(configdir) + strlen(IDENT_FILENAME) + 1,
"%s/%s",
configdir,
IDENT_FILENAME);
securec_check_ss(rc, configdir, "\0");
} else {
write_stderr("%s does not know where to find the \"ident\" configuration file.\n"
"This can be specified as \"ident_file\" in \"%s\", "
"or by the -D invocation option, or by the "
"PGDATA environment variable.\n",
progname,
g_instance.attr.attr_common.ConfigFileName);
return false;
}
SetConfigOption("ident_file", fname, PGC_POSTMASTER, PGC_S_OVERRIDE);
pfree(fname);
pfree(configdir);
// shared_buffers is 32MB for dummyStandby
//
if (dummyStandbyMode) {
g_instance.attr.attr_storage.NBuffers = (int)(32 * 1024 * 1024 / BLCKSZ);
}
return true;
}
/*
* Reset all options to their saved default values (implements RESET ALL)
*/
void ResetAllOptions(void)
{
int i;
for (i = 0; i < u_sess->num_guc_variables; i++) {
struct config_generic* gconf = u_sess->guc_variables[i];
/* Don't reset non-SET-able values */
if (gconf->context != PGC_SUSET && gconf->context != PGC_USERSET) {
continue;
}
/* Don't reset if special exclusion from RESET ALL */
if (gconf->flags & GUC_NO_RESET_ALL) {
continue;
}
/* No need to reset if wasn't SET */
if (gconf->source <= PGC_S_OVERRIDE) {
continue;
}
/* Save old value to support transaction abort */
push_old_value(gconf, GUC_ACTION_SET);
switch (gconf->vartype) {
case PGC_BOOL: {
struct config_bool* conf = (struct config_bool*)gconf;
if (conf->assign_hook) {
(*conf->assign_hook)(conf->reset_val, conf->reset_extra);
}
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra, conf->reset_extra);
break;
}
case PGC_INT: {
struct config_int* conf = (struct config_int*)gconf;
if (conf->assign_hook) {
(*conf->assign_hook)(conf->reset_val, conf->reset_extra);
}
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra, conf->reset_extra);
break;
}
case PGC_INT64: {
struct config_int64* conf = (struct config_int64*)gconf;
if (conf->assign_hook) {
(*conf->assign_hook)(conf->reset_val, conf->reset_extra);
}
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra, conf->reset_extra);
break;
}
case PGC_REAL: {
struct config_real* conf = (struct config_real*)gconf;
if (conf->assign_hook) {
(*conf->assign_hook)(conf->reset_val, conf->reset_extra);
}
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra, conf->reset_extra);
break;
}
case PGC_STRING: {
struct config_string* conf = (struct config_string*)gconf;
if (conf->assign_hook) {
(*conf->assign_hook)(conf->reset_val, conf->reset_extra);
}
set_string_field(conf, conf->variable, conf->reset_val);
set_extra_field(&conf->gen, &conf->gen.extra, conf->reset_extra);
break;
}
case PGC_ENUM: {
struct config_enum* conf = (struct config_enum*)gconf;
if (conf->assign_hook) {
(*conf->assign_hook)(conf->reset_val, conf->reset_extra);
}
*conf->variable = conf->reset_val;
set_extra_field(&conf->gen, &conf->gen.extra, conf->reset_extra);
break;
}
default:
break;
}
gconf->source = gconf->reset_source;
gconf->scontext = gconf->reset_scontext;
if (gconf->flags & GUC_REPORT) {
report_guc_option(gconf);
}
}
}
/*
* push_old_value
* Push previous state during transactional assignment to a GUC variable.
*/
static void push_old_value(struct config_generic* gconf, GucAction action)
{
GucStack* stack = NULL;
/* If we're not inside a nest level, do nothing */
if (u_sess->utils_cxt.GUCNestLevel == 0) {
return;
}
/* Do we already have a stack entry of the current nest level? */
stack = gconf->stack;
if (stack != NULL && stack->nest_level >= u_sess->utils_cxt.GUCNestLevel) {
switch (action) {
case GUC_ACTION_SET:
/* SET overrides any prior action at same nest level */
if (stack->state == GUC_SET_LOCAL) {
/* must discard old masked value */
discard_stack_value(gconf, &stack->masked);
}
stack->state = GUC_SET;
break;
case GUC_ACTION_LOCAL:
if (stack->state == GUC_SET) {
/* SET followed by SET LOCAL, remember SET's value */
stack->masked_scontext = gconf->scontext;
set_stack_value(gconf, &stack->masked);
stack->state = GUC_SET_LOCAL;
}
/* in all other cases, no change to stack entry */
break;
case GUC_ACTION_SAVE:
/* Could only have a prior SAVE of same variable */
Assert(stack->state == GUC_SAVE);
break;
default:
break;
}
Assert(u_sess->utils_cxt.guc_dirty); /* must be set already */
return;
}
/*
* Push a new stack entry
*
* We keep all the stack entries in u_sess->top_transaction_mem_cxt for simplicity.
*/
stack = (GucStack*)MemoryContextAllocZero(u_sess->top_transaction_mem_cxt, sizeof(GucStack));
stack->prev = gconf->stack;
stack->nest_level = u_sess->utils_cxt.GUCNestLevel;
switch (action) {
case GUC_ACTION_SET:
stack->state = GUC_SET;
break;
case GUC_ACTION_LOCAL:
stack->state = GUC_LOCAL;
break;
case GUC_ACTION_SAVE:
stack->state = GUC_SAVE;
break;
default:
break;
}
stack->source = gconf->source;
stack->scontext = gconf->scontext;
set_stack_value(gconf, &stack->prior);
gconf->stack = stack;
/* Ensure we remember to pop at end of xact */
u_sess->utils_cxt.guc_dirty = true;
}
/*
* Do GUC processing at main transaction start.
*/
void AtStart_GUC(void)
{
/*
* The nest level should be 0 between transactions; if it isn't, somebody
* didn't call AtEOXact_GUC, or called it with the wrong nestLevel. We
* throw a warning but make no other effort to clean up.
*/
if (u_sess->utils_cxt.GUCNestLevel != 0) {
ereport(WARNING, (errmsg("GUC nest level = %d at transaction start", u_sess->utils_cxt.GUCNestLevel)));
}
u_sess->utils_cxt.GUCNestLevel = 1;
reset_set_message(false);
}
/*
* Enter a new nesting level for GUC values. This is called at subtransaction
* start, and when entering a function that has proconfig settings, and in
* some other places where we want to set GUC variables transiently.
* NOTE we must not risk error here, else subtransaction start will be unhappy.
*/
int NewGUCNestLevel(void)
{
return ++u_sess->utils_cxt.GUCNestLevel;
}
/*
* Do GUC processing at transaction or subtransaction commit or abort, or
* when exiting a function that has proconfig settings, or when undoing a
* transient assignment to some GUC variables. (The name is thus a bit of
* a misnomer; perhaps it should be ExitGUCNestLevel or some such.)
* During abort, we discard all GUC settings that were applied at nesting
* levels >= nestLevel. nestLevel == 1 corresponds to the main transaction.
*/
void AtEOXact_GUC(bool isCommit, int nestLevel)
{
bool still_dirty = false;
int i;
/*
* Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
* abort, if there is a failure during transaction start before
* AtStart_GUC is called.
*/
Assert(nestLevel > 0 && (nestLevel <= u_sess->utils_cxt.GUCNestLevel ||
(nestLevel == u_sess->utils_cxt.GUCNestLevel + 1 && !isCommit)));
/* Quick exit if nothing's changed in this transaction */
if (!u_sess->utils_cxt.guc_dirty) {
u_sess->utils_cxt.GUCNestLevel = nestLevel - 1;
return;
}
for (i = 0; i < u_sess->num_guc_variables; i++) {
struct config_generic* gconf = u_sess->guc_variables[i];
GucStack* stack = NULL;
/*
* Process and pop each stack entry within the nest level. To simplify
* fmgr_security_definer() and other places that use GUC_ACTION_SAVE,
* we allow failure exit from code that uses a local nest level to be
* recovered at the surrounding transaction or subtransaction abort;
* so there could be more than one stack entry to pop.
*/
while ((stack = gconf->stack) != NULL && stack->nest_level >= nestLevel) {
GucStack* prev = stack->prev;
bool restorePrior = false;
bool restoreMasked = false;
bool changed = false;
/*
* In this next bit, if we don't set either restorePrior or
* restoreMasked, we must "discard" any unwanted fields of the
* stack entries to avoid leaking memory. If we do set one of
* those flags, unused fields will be cleaned up after restoring.
*/
if (!isCommit) { /* if abort, always restore prior value */
restorePrior = true;
} else if (stack->state == GUC_SAVE) {
restorePrior = true;
} else if (stack->nest_level == 1) {
/* transaction commit */
if (stack->state == GUC_SET_LOCAL) {
restoreMasked = true;
} else if (stack->state == GUC_SET) {
/* we keep the current active value */
discard_stack_value(gconf, &stack->prior);
} else { /* must be GUC_LOCAL */
restorePrior = true;
}
} else if (prev == NULL || prev->nest_level < stack->nest_level - 1) {
/* decrement entry's level and do not pop it */
stack->nest_level--;
continue;
} else {
/*
* We have to merge this stack entry into prev. See README for
* discussion of this bit.
*/
switch (stack->state) {
case GUC_SAVE:
Assert(false); /* can't get here */
case GUC_SET:
/* next level always becomes SET */
discard_stack_value(gconf, &stack->prior);
if (prev->state == GUC_SET_LOCAL) {
discard_stack_value(gconf, &prev->masked);
}
prev->state = GUC_SET;
break;
case GUC_LOCAL:
if (prev->state == GUC_SET) {
/* LOCAL migrates down */
prev->masked_scontext = stack->scontext;
prev->masked = stack->prior;
prev->state = GUC_SET_LOCAL;
} else {
/* else just forget this stack level */
discard_stack_value(gconf, &stack->prior);
}
break;
case GUC_SET_LOCAL:
/* prior state at this level no longer wanted */
discard_stack_value(gconf, &stack->prior);
/* copy down the masked state */
prev->masked_scontext = stack->masked_scontext;
if (prev->state == GUC_SET_LOCAL) {
discard_stack_value(gconf, &prev->masked);
}
prev->masked = stack->masked;
prev->state = GUC_SET_LOCAL;
break;
default:
break;
}
}
changed = false;
if (restorePrior || restoreMasked) {
/* Perform appropriate restoration of the stacked value */
config_var_value newvalue;
GucSource newsource;
GucContext newscontext;
if (restoreMasked) {
newvalue = stack->masked;
newsource = PGC_S_SESSION;
newscontext = stack->masked_scontext;
} else {
newvalue = stack->prior;
newsource = stack->source;
newscontext = stack->scontext;
}
switch (gconf->vartype) {
case PGC_BOOL: {
struct config_bool* conf = (struct config_bool*)gconf;
bool newval = newvalue.val.boolval;
void* newextra = newvalue.extra;
if (*conf->variable != newval || conf->gen.extra != newextra) {
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
changed = true;
}
break;
}
case PGC_INT: {
struct config_int* conf = (struct config_int*)gconf;
int newval = newvalue.val.intval;
void* newextra = newvalue.extra;
if (*conf->variable != newval || conf->gen.extra != newextra) {
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
changed = true;
}
break;
}
case PGC_INT64: {
struct config_int64* conf = (struct config_int64*)gconf;
int64 newval = newvalue.val.int64val;
void* newextra = newvalue.extra;
if (*conf->variable != newval || conf->gen.extra != newextra) {
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
changed = true;
}
break;
}
case PGC_REAL: {
struct config_real* conf = (struct config_real*)gconf;
double newval = newvalue.val.realval;
void* newextra = newvalue.extra;
if (*conf->variable != newval || conf->gen.extra != newextra) {
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
changed = true;
}
break;
}
case PGC_STRING: {
struct config_string* conf = (struct config_string*)gconf;
char* newval = newvalue.val.stringval;
void* newextra = newvalue.extra;
if (*conf->variable != newval || conf->gen.extra != newextra) {
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
set_string_field(conf, conf->variable, newval);
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
changed = true;
}
/*
* Release stacked values if not used anymore. We
* could use discard_stack_value() here, but since
* we have type-specific code anyway, might as
* well inline it.
*/
set_string_field(conf, &stack->prior.val.stringval, NULL);
set_string_field(conf, &stack->masked.val.stringval, NULL);
break;
}
case PGC_ENUM: {
struct config_enum* conf = (struct config_enum*)gconf;
int newval = newvalue.val.enumval;
void* newextra = newvalue.extra;
if (*conf->variable != newval || conf->gen.extra != newextra) {
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
*conf->variable = newval;
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
changed = true;
}
break;
}
default:
break;
}
/*
* Release stacked extra values if not used anymore.
*/
set_extra_field(gconf, &(stack->prior.extra), NULL);
set_extra_field(gconf, &(stack->masked.extra), NULL);
/* And restore source information */
gconf->source = newsource;
gconf->scontext = newscontext;
}
/* Finish popping the state stack */
gconf->stack = prev;
pfree(stack);
/* Report new value if we changed it */
if (changed && (gconf->flags & GUC_REPORT)) {
report_guc_option(gconf);
}
} /* end of stack-popping loop */
if (stack != NULL) {
still_dirty = true;
}
}
/* If there are no remaining stack entries, we can reset guc_dirty */
u_sess->utils_cxt.guc_dirty = still_dirty;
/* Update nesting level */
u_sess->utils_cxt.GUCNestLevel = nestLevel - 1;
/*
* Send set command which is in transactionBlock to pool
*
* During inplace upgrade, we don't need to set agent and DNs'
* GUC at prepare or commit. These connections will always be closed.
*/
if (isCommit && nestLevel == 1 && !u_sess->attr.attr_common.IsInplaceUpgrade) {
int rs;
char* set_str = get_set_string();
if (set_str != NULL) {
rs = PoolManagerSetCommand(POOL_CMD_GLOBAL_SET, set_str);
if (rs < 0) {
ereport(ERROR,
(errcode(ERRCODE_CONNECTION_EXCEPTION),
errmsg("Communication failure, failed to send set commands to pool.")));
}
}
/* reset input_set_message when current transaction is in top level and isCommit is true. */
reset_set_message(isCommit);
}
SetThreadLocalGUC(u_sess);
}
/*
* Start up automatic reporting of changes to variables marked GUC_REPORT.
* This is executed at completion of backend startup.
*/
void BeginReportingGUCOptions(void)
{
int i;
/*
* Don't do anything unless talking to an interactive frontend of protocol
* 3.0 or later.
*/
if (t_thrd.postgres_cxt.whereToSendOutput != DestRemote || PG_PROTOCOL_MAJOR(FrontendProtocol) < 3) {
return;
}
u_sess->utils_cxt.reporting_enabled = true;
/* Transmit initial values of interesting variables */
for (i = 0; i < u_sess->num_guc_variables; i++) {
struct config_generic* conf = u_sess->guc_variables[i];
if (conf->flags & GUC_REPORT) {
report_guc_option(conf);
}
}
}
/*
* report_guc_option: if appropriate, transmit option value to frontend
*/
static void report_guc_option(struct config_generic* record)
{
if (u_sess->utils_cxt.reporting_enabled && (record->flags & GUC_REPORT)) {
char* val = _show_option(record, false);
StringInfoData msgbuf;
pq_beginmessage(&msgbuf, 'S');
pq_sendstring(&msgbuf, record->name);
pq_sendstring(&msgbuf, val);
pq_endmessage(&msgbuf);
pfree(val);
}
}
/*
* Try to parse value as an integer. The accepted formats are the
* usual decimal, octal, or hexadecimal formats, optionally followed by
* a unit name if "flags" indicates a unit is allowed.
*
* If the string parses okay, return true, else false.
* If okay and result is not NULL, return the value in *result.
* If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
* HINT message, or NULL if no hint provided.
*/
bool parse_int(const char* value, int* result, int flags, const char** hintmsg)
{
int64 val;
char* endptr = NULL;
/* To suppress compiler warnings, always set output params */
if (result != NULL) {
*result = 0;
}
if (hintmsg != NULL) {
*hintmsg = NULL;
}
/* We assume here that int64 is at least as wide as long */
errno = 0;
val = strtol(value, &endptr, 0);
if (endptr == value) {
return false; /* no HINT for integer syntax error */
}
if (errno == ERANGE || val != (int64)((int32)val)) {
if (hintmsg != NULL) {
*hintmsg = gettext_noop("Value exceeds integer range.");
}
return false;
}
/* allow whitespace between integer and unit */
while (isspace((unsigned char)*endptr)) {
endptr++;
}
/* Handle possible unit */
if (*endptr != '\0') {
/*
* Note: the multiple-switch coding technique here is a bit tedious,
* but seems necessary to avoid intermediate-value overflows.
*/
if (flags & GUC_UNIT_MEMORY) {
/* Set hint for use if no match or trailing garbage */
if (hintmsg != NULL) {
*hintmsg = gettext_noop("Valid units for this parameter are \"kB\", \"MB\", and \"GB\".");
}
#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
if (strncmp(endptr, "kB", 2) == 0) {
endptr += 2;
switch (flags & GUC_UNIT_MEMORY) {
case GUC_UNIT_BLOCKS:
val /= (BLCKSZ / 1024);
break;
case GUC_UNIT_XBLOCKS:
val /= (XLOG_BLCKSZ / 1024);
break;
default:
break;
}
} else if (strncmp(endptr, "MB", 2) == 0) {
endptr += 2;
switch (flags & GUC_UNIT_MEMORY) {
case GUC_UNIT_KB:
val *= KB_PER_MB;
break;
case GUC_UNIT_BLOCKS:
val *= KB_PER_MB / (BLCKSZ / 1024);
break;
case GUC_UNIT_XBLOCKS:
val *= KB_PER_MB / (XLOG_BLCKSZ / 1024);
break;
default:
break;
}
} else if (strncmp(endptr, "GB", 2) == 0) {
endptr += 2;
switch (flags & GUC_UNIT_MEMORY) {
case GUC_UNIT_KB:
val *= KB_PER_GB;
break;
case GUC_UNIT_BLOCKS:
val *= KB_PER_GB / (BLCKSZ / 1024);
break;
case GUC_UNIT_XBLOCKS:
val *= KB_PER_GB / (XLOG_BLCKSZ / 1024);
break;
default:
break;
}
}
} else if (flags & GUC_UNIT_TIME) {
/* Set hint for use if no match or trailing garbage */
if (hintmsg != NULL) {
*hintmsg = gettext_noop("Valid units for this parameter are \"ms\", \"s\", \"min\", \"h\", and \"d\".");
}
if (strncmp(endptr, "ms", 2) == 0) {
endptr += 2;
switch (flags & GUC_UNIT_TIME) {
case GUC_UNIT_S:
val /= MS_PER_S;
break;
case GUC_UNIT_MIN:
val /= MS_PER_MIN;
break;
case GUC_UNIT_HOUR:
val /= MS_PER_H;
break;
default:
break;
}
} else if (strncmp(endptr, "s", 1) == 0) {
endptr += 1;
switch (flags & GUC_UNIT_TIME) {
case GUC_UNIT_MS:
val *= MS_PER_S;
break;
case GUC_UNIT_MIN:
val /= S_PER_MIN;
break;
case GUC_UNIT_HOUR:
val /= S_PER_H;
break;
default:
break;
}
} else if (strncmp(endptr, "min", 3) == 0) {
endptr += 3;
switch (flags & GUC_UNIT_TIME) {
case GUC_UNIT_MS:
val *= MS_PER_MIN;
break;
case GUC_UNIT_S:
val *= S_PER_MIN;
break;
case GUC_UNIT_HOUR:
val /= MIN_PER_H;
break;
default:
break;
}
} else if (strncmp(endptr, "h", 1) == 0) {
endptr += 1;
switch (flags & GUC_UNIT_TIME) {
case GUC_UNIT_MS:
val *= MS_PER_H;
break;
case GUC_UNIT_S:
val *= S_PER_H;
break;
case GUC_UNIT_MIN:
val *= MIN_PER_H;
break;
default:
break;
}
} else if (strncmp(endptr, "d", 1) == 0) {
endptr += 1;
switch (flags & GUC_UNIT_TIME) {
case GUC_UNIT_MS:
val *= MS_PER_D;
break;
case GUC_UNIT_S:
val *= S_PER_D;
break;
case GUC_UNIT_MIN:
val *= MIN_PER_D;
break;
case GUC_UNIT_HOUR:
val *= H_PER_D;
default:
break;
}
}
}
/* allow whitespace after unit */
while (isspace((unsigned char)*endptr)) {
endptr++;
}
if (*endptr != '\0') {
return false; /* appropriate hint, if any, already set */
}
/* Check for overflow due to units conversion */
if (val != (int64)((int32)val)) {
if (hintmsg != NULL) {
*hintmsg = gettext_noop("Value exceeds integer range.");
}
return false;
}
}
if (result != NULL) {
*result = (int)val;
}
return true;
}
/*
* Try to parse value as an 64-bit integer. The accepted format is
* decimal number.
*
* If the string parses okay, return true, else false.
* If okay and result is not NULL, return the value in *result.
* If not okay and hintmsg is not NULL, *hintmsg is set to a suitable
* HINT message, or NULL if no hint provided.
*/
bool parse_int64(const char* value, int64* result, const char** hintmsg)
{
int64 val;
char* endptr = NULL;
/* To suppress compiler warnings, always set output params */
if (result != NULL) {
*result = 0;
}
if (hintmsg != NULL) {
*hintmsg = NULL;
}
/* We assume here that int64 is at least as wide as long */
errno = 0;
#ifdef _MSC_VER /* MSVC only */
val = _strtoi64(value, &endptr, 10);
#elif defined(HAVE_STRTOLL) && SIZEOF_LONG < 8
val = strtoll(value, &endptr, 10);
#else
val = strtol(value, &endptr, 10);
#endif
if (endptr == value) {
return false; /* no HINT for integer syntax error */
}
if (errno == ERANGE) {
if (hintmsg != NULL) {
*hintmsg = gettext_noop("Value exceeds 64-bit integer range.");
}
return false;
}
if (result != NULL) {
*result = val;
}
return true;
}
/*
* Try to parse value as a floating point number in the usual format.
* If the string parses okay, return true, else false.
* If okay and result is not NULL, return the value in *result.
*/
bool parse_real(const char* value, double* result)
{
double val;
char* endptr = NULL;
if (result != NULL) {
*result = 0; /* suppress compiler warning */
}
errno = 0;
val = strtod(value, &endptr);
if (endptr == value || errno == ERANGE) {
return false;
}
/* reject NaN (infinities will fail range checks later) */
if (isnan(val)) {
return false;
}
/* allow whitespace after number */
while (isspace((unsigned char)*endptr)) {
endptr++;
}
if (*endptr != '\0') {
return false;
}
if (result != NULL) {
*result = val;
}
return true;
}
/*
* @Description: Get guc string value according to val.
* @in record: Enum configure struct.
* @in val: Guc value.
* @return: Guc string values.
*/
static const char* config_enum_map_lookup_by_value(struct config_enum* record, int val)
{
StringInfoData buf;
initStringInfo(&buf);
bool is_first = true;
const struct config_enum_entry* entry = NULL;
for (entry = record->options; entry && entry->name; entry++) {
if (entry->val & val) {
if (is_first) {
appendStringInfo(&buf, "%s", entry->name);
is_first = false;
} else {
appendStringInfo(&buf, ", %s", entry->name);
}
}
}
if (buf.len == 0) {
appendStringInfoString(&buf, "none");
}
return buf.data;
}
/*
* Lookup the name for an enum option with the selected value.
* Should only ever be called with known-valid values, so throws
* an elog(ERROR) if the enum option is not found.
*
* The returned string is a pointer to static THR_LOCAL data and not
* allocated for modification.
*/
const char* config_enum_lookup_by_value(struct config_enum* record, int val)
{
if (pg_strncasecmp(record->gen.name, "rewrite_rule", sizeof("rewrite_rule")) == 0) {
return config_enum_map_lookup_by_value(record, val);
} else {
const struct config_enum_entry* entry = NULL;
for (entry = record->options; entry && entry->name; entry++) {
if (entry->val == val) {
return entry->name;
}
}
}
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("could not find enum option %d for %s", val, record->gen.name)));
return NULL; /* silence compiler */
}
/*
* @Description: Set bit map to guc.
* @in record: Enum config.
* @in newval: New values.
* @out retval: Guc param.
*/
static bool config_enum_map_lookup_by_name(struct config_enum* record, const char* newval, int* retval)
{
char* val = pstrdup(newval);
List* valList = NIL;
if (!SplitIdentifierString(val, ',', &valList)) {
pfree(val);
list_free(valList);
return false;
}
int set_value = 0;
const struct config_enum_entry* entry = NULL;
ListCell* lc = NULL;
foreach (lc, valList) {
char* valItem = (char*)lfirst(lc);
for (entry = record->options; entry && entry->name; entry++) {
if (pg_strcasecmp(valItem, entry->name) == 0) {
set_value |= entry->val;
break;
}
}
if (entry != NULL && entry->name == NULL) {
return false;
}
}
pfree(val);
list_free(valList);
*retval = set_value;
return true;
}
/*
* Lookup the value for an enum option with the selected name
* (case-insensitive).
* If the enum option is found, sets the retval value and returns
* true. If it's not found, return FALSE and retval is set to 0.
*/
bool config_enum_lookup_by_name(struct config_enum* record, const char* value, int* retval)
{
if (pg_strncasecmp(record->gen.name, "rewrite_rule", sizeof("rewrite_rule")) == 0) {
return config_enum_map_lookup_by_name(record, value, retval);
} else {
const struct config_enum_entry* entry = NULL;
for (entry = record->options; entry && entry->name; entry++) {
if (pg_strcasecmp(value, entry->name) == 0) {
*retval = entry->val;
return TRUE;
}
}
}
*retval = 0;
return FALSE;
}
/*
* Return a list of all available options for an enum, excluding
* hidden ones, separated by the given separator.
* If prefix is non-NULL, it is added before the first enum value.
* If suffix is non-NULL, it is added to the end of the string.
*/
static char* config_enum_get_options(
struct config_enum* record, const char* prefix, const char* suffix, const char* separator)
{
const struct config_enum_entry* entry = NULL;
StringInfoData retstr;
int seplen;
initStringInfo(&retstr);
appendStringInfoString(&retstr, prefix);
seplen = strlen(separator);
for (entry = record->options; entry && entry->name; entry++) {
if (!entry->hidden) {
appendStringInfoString(&retstr, entry->name);
appendBinaryStringInfo(&retstr, separator, seplen);
}
}
/*
* All the entries may have been hidden, leaving the string empty if no
* prefix was given. This indicates a broken GUC setup, since there is no
* use for an enum without any values, so we just check to make sure we
* don't write to invalid memory instead of actually trying to do
* something smart with it.
*/
if (retstr.len >= seplen) {
/* Replace final separator */
retstr.data[retstr.len - seplen] = '\0';
retstr.len -= seplen;
}
appendStringInfoString(&retstr, suffix);
return retstr.data;
}
void SetThreadLocalGUC(knl_session_context* session)
{
default_statistics_target = session->attr.attr_sql.default_statistics_target;
session_timezone = session->attr.attr_common.session_timezone;
log_timezone = session->attr.attr_common.log_timezone;
client_min_messages = session->attr.attr_common.client_min_messages;
log_min_messages = session->attr.attr_common.log_min_messages;
enable_alarm = g_instance.attr.attr_common.enable_alarm;
Alarm_component = g_instance.attr.attr_common.Alarm_component;
sctp_link_addr = g_instance.attr.attr_network.sctp_link_addr;
assert_enabled = session->attr.attr_common.assert_enabled;
AlarmReportInterval = session->attr.attr_common.AlarmReportInterval;
xmloption = session->attr.attr_common.xmloption;
comm_client_bind = session->attr.attr_network.comm_client_bind;
comm_ackchk_time = session->attr.attr_network.comm_ackchk_time;
}
/*
* Sets option `name' to given value.
*
* The value should be a string, which will be parsed and converted to
* the appropriate data type. The context and source parameters indicate
* in which context this function is being called, so that it can apply the
* access restrictions properly.
*
* If value is NULL, set the option to its default value (normally the
* reset_val, but if source == PGC_S_DEFAULT we instead use the boot_val).
*
* action indicates whether to set the value globally in the session, locally
* to the current top transaction, or just for the duration of a function call.
*
* If changeVal is false then don't really set the option but do all
* the checks to see if it would work.
*
* elevel should normally be passed as zero, allowing this function to make
* its standard choice of ereport level. However some callers need to be
* able to override that choice; they should pass the ereport level to use.
*
* Return value:
* +1: the value is valid and was successfully applied.
* 0: the name or value is invalid (but see below).
* -1: the value was not applied because of context, priority, or changeVal.
*
* If there is an error (non-existing option, invalid value) then an
* ereport(ERROR) is thrown *unless* this is called for a source for which
* we don't want an ERROR (currently, those are defaults, the config file,
* and per-database or per-user settings, as well as callers who specify
* a less-than-ERROR elevel). In those cases we write a suitable error
* message via ereport() and return 0.
*
* See also SetConfigOption for an external interface.
*/
int set_config_option(const char* name, const char* value, GucContext context, GucSource source, GucAction action,
bool changeVal, int elevel, bool isReload)
{
struct config_generic* record = NULL;
bool prohibitValueChange = false;
bool makeDefault = false;
#ifdef PGXC
/*
* Current GucContest value is needed to check if xc_maintenance_mode parameter
* is specified in valid contests. It is allowed only by SET command or
* libpq connect parameters so that setting this ON is just temporary.
*/
currentGucContext = context;
#endif
if (elevel == 0) {
if (source == PGC_S_DEFAULT || source == PGC_S_FILE) {
/*
* To avoid cluttering the log, only the postmaster bleats loudly
* about problems with the config file.
*/
elevel = IsUnderPostmaster ? DEBUG3 : LOG;
} else if (source == PGC_S_DATABASE || source == PGC_S_USER || source == PGC_S_DATABASE_USER) {
elevel = WARNING;
} else {
elevel = ERROR;
}
}
record = find_option(name, true, elevel);
if (record == NULL) {
ereport(
elevel, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized configuration parameter \"%s\"", name)));
return 0;
}
if (strcmp(name, "enable_cluster_resize") == 0) {
ereport(LOG, (errmsg("Set parameter \"%s\": \"%s\"", name, value)));
}
/*
* Check if the option can be set at this time. See guc.h for the precise
* rules.
*/
switch (record->context) {
case PGC_INTERNAL:
if (context != PGC_INTERNAL) {
/* Add for upgrade */
if (strncmp(name, "sql_compatibility", sizeof("sql_compatibility")) == 0) {
ereport(WARNING,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed. Compatibility can only be specified when "
"creating database",
name)));
return 1;
} else {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed", name)));
}
return 0;
}
break;
case PGC_POSTMASTER:
if (context == PGC_SIGHUP) {
/*
* We are re-reading a PGC_POSTMASTER variable from
* postgresql.conf. We can't change the setting, so we should
* give a warning if the DBA tries to change it. However,
* because of variant formats, canonicalization by check
* hooks, etc, we can't just compare the given string directly
* to what's stored. Set a flag to check below after we have
* the final storable value.
*/
prohibitValueChange = true;
} else if (context != PGC_POSTMASTER) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
break;
case PGC_SIGHUP:
if (context != PGC_SIGHUP && context != PGC_POSTMASTER) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed now", name)));
return 0;
}
/*
* Hmm, the idea of the SIGHUP context is "ought to be global, but
* can be changed after postmaster start". But there's nothing
* that prevents a crafty administrator from sending SIGHUP
* signals to individual backends only.
*/
break;
case PGC_BACKEND:
if (context == PGC_SIGHUP) {
/*
* If a PGC_BACKEND parameter is changed in the config file,
* we want to accept the new value in the postmaster (whence
* it will propagate to subsequently-started backends), but
* ignore it in existing backends. This is a tad klugy, but
* necessary because we don't re-read the config file during
* backend start.
*/
if (IsUnderPostmaster && !isReload) {
return -1;
}
} else if (context != PGC_POSTMASTER && context != PGC_BACKEND && source != PGC_S_CLIENT) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be set after connection start", name)));
return 0;
}
break;
case PGC_SUSET:
if (context == PGC_USERSET || context == PGC_BACKEND) {
ereport(elevel,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to set parameter \"%s\"", name)));
return 0;
}
break;
case PGC_USERSET:
/* always okay */
break;
default:
break;
}
/*
* Disallow changing GUC_NOT_WHILE_SEC_REST values if we are inside a
* security restriction context. We can reject this regardless of the GUC
* context or source, mainly because sources that it might be reasonable
* to override for won't be seen while inside a function.
*
* Note: variables marked GUC_NOT_WHILE_SEC_REST should usually be marked
* GUC_NO_RESET_ALL as well, because ResetAllOptions() doesn't check this.
* An exception might be made if the reset value is assumed to be "safe".
*
* Note: this flag is currently used for "session_authorization" and
* "role". We need to prohibit changing these inside a local userid
* context because when we exit it, GUC won't be notified, leaving things
* out of sync. (This could be fixed by forcing a new GUC nesting level,
* but that would change behavior in possibly-undesirable ways.) Also, we
* prohibit changing these in a security-restricted operation because
* otherwise RESET could be used to regain the session user's privileges.
*/
if (record->flags & GUC_NOT_WHILE_SEC_REST) {
if (InLocalUserIdChange()) {
/*
* Phrasing of this error message is historical, but it's the most
* common case.
*/
ereport(elevel,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("cannot set parameter \"%s\" within security-definer function", name)));
return 0;
}
if (InSecurityRestrictedOperation()) {
ereport(elevel,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("cannot set parameter \"%s\" within security-restricted operation", name)));
return 0;
}
}
/*
* Should we set reset/stacked values? (If so, the behavior is not
* transactional.) This is done either when we get a default value from
* the database's/user's/client's default settings or when we reset a
* value to its default.
*/
makeDefault = changeVal && (source <= PGC_S_OVERRIDE) && ((value != NULL) || source == PGC_S_DEFAULT);
/*
* Ignore attempted set if overridden by previously processed setting.
* However, if changeVal is false then plow ahead anyway since we are
* trying to find out if the value is potentially good, not actually use
* it. Also keep going if makeDefault is true, since we may want to set
* the reset/stacked values even if we can't set the variable itself.
*/
if (record->source > source) {
if (changeVal && !makeDefault) {
ereport(DEBUG3, (errmsg("\"%s\": setting ignored because previous source is higher priority", name)));
return -1;
}
changeVal = false;
}
/*
* Evaluate value and set variable.
*/
switch (record->vartype) {
case PGC_BOOL: {
struct config_bool* conf = (struct config_bool*)record;
bool newval = false;
void* newextra = NULL;
if (value != NULL) {
if (!parse_bool(value, &newval)) {
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("parameter \"%s\" requires a Boolean value", name)));
return 0;
}
if (!call_bool_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else if (source == PGC_S_DEFAULT) {
newval = conf->boot_val;
if (!call_bool_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else {
newval = conf->reset_val;
newextra = conf->reset_extra;
source = conf->gen.reset_source;
context = conf->gen.reset_scontext;
}
if (prohibitValueChange) {
if (*conf->variable != newval) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
return -1;
}
if (changeVal) {
/* Save old value to support transaction abort */
if (!makeDefault) {
push_old_value(&conf->gen, action);
}
if (conf->assign_hook) {
if (strcasecmp(record->name, "enable_save_datachanged_timestamp") == 0) {
bool set_op = false;
if (value != NULL && source == PGC_S_SESSION) {
set_op = true;
}
(*conf->assign_hook)(newval, &set_op);
} else {
(*conf->assign_hook)(newval, newextra);
}
}
if (!IsUnderPostmaster || conf->gen.context != PGC_POSTMASTER) {
*conf->variable = newval;
}
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
conf->gen.source = source;
conf->gen.scontext = context;
}
if (makeDefault) {
GucStack* stack = NULL;
if (conf->gen.reset_source <= source) {
conf->reset_val = newval;
set_extra_field(&conf->gen, &conf->reset_extra, newextra);
conf->gen.reset_source = source;
conf->gen.reset_scontext = context;
}
for (stack = conf->gen.stack; stack; stack = stack->prev) {
if (stack->source <= source) {
stack->prior.val.boolval = newval;
set_extra_field(&conf->gen, &stack->prior.extra, newextra);
stack->source = source;
stack->scontext = context;
}
}
}
/* Perhaps we didn't install newextra anywhere */
if (newextra && !extra_field_used(&conf->gen, newextra)) {
pfree(newextra);
}
break;
}
case PGC_INT: {
struct config_int* conf = (struct config_int*)record;
int newval;
void* newextra = NULL;
if (value != NULL) {
const char* hintmsg = NULL;
if (!parse_int(value, &newval, conf->gen.flags, &hintmsg)) {
ereport(elevel, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid value for parameter \"%s\": \"%s\"", name, value),
hintmsg ? errhint("%s", _(hintmsg)) : 0));
return 0;
}
if (newval < conf->min || newval > conf->max) {
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("%d is outside the valid range for parameter \"%s\" (%d .. %d)",
newval,
name,
conf->min,
conf->max)));
return 0;
}
if (!call_int_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else if (source == PGC_S_DEFAULT) {
newval = conf->boot_val;
if (!call_int_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else {
newval = conf->reset_val;
newextra = conf->reset_extra;
source = conf->gen.reset_source;
context = conf->gen.reset_scontext;
}
if (prohibitValueChange) {
if (*conf->variable != newval) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
return -1;
}
if (changeVal) {
/* Save old value to support transaction abort */
if (!makeDefault) {
push_old_value(&conf->gen, action);
}
u_sess->utils_cxt.guc_new_value = &newval;
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
if (!IsUnderPostmaster || conf->gen.context != PGC_POSTMASTER) {
*conf->variable = newval;
}
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
conf->gen.source = source;
conf->gen.scontext = context;
u_sess->utils_cxt.guc_new_value = NULL;
}
if (makeDefault) {
GucStack* stack = NULL;
if (conf->gen.reset_source <= source) {
conf->reset_val = newval;
set_extra_field(&conf->gen, &conf->reset_extra, newextra);
conf->gen.reset_source = source;
conf->gen.reset_scontext = context;
}
for (stack = conf->gen.stack; stack; stack = stack->prev) {
if (stack->source <= source) {
stack->prior.val.intval = newval;
set_extra_field(&conf->gen, &stack->prior.extra, newextra);
stack->source = source;
stack->scontext = context;
}
}
}
/* Perhaps we didn't install newextra anywhere */
if (newextra && !extra_field_used(&conf->gen, newextra)) {
pfree(newextra);
}
break;
}
case PGC_INT64: {
struct config_int64* conf = (struct config_int64*)record;
int64 newval;
void* newextra = NULL;
if (value != NULL) {
const char* hintmsg = NULL;
if (!parse_int64(value, &newval, &hintmsg)) {
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("parameter \"%s\" requires a numeric value", name)));
return 0;
}
if (newval < conf->min || newval > conf->max) {
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("%ld is outside the valid range for parameter \"%s\" (%ld .. %ld)",
newval,
name,
conf->min,
conf->max)));
return 0;
}
if (!call_int64_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else if (source == PGC_S_DEFAULT) {
newval = conf->boot_val;
if (!call_int64_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else {
newval = conf->reset_val;
newextra = conf->reset_extra;
source = conf->gen.reset_source;
context = conf->gen.reset_scontext;
}
if (prohibitValueChange) {
if (*conf->variable != newval) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
return -1;
}
if (changeVal) {
/* Save old value to support transaction abort */
if (!makeDefault) {
push_old_value(&conf->gen, action);
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
if (!IsUnderPostmaster || conf->gen.context != PGC_POSTMASTER) {
*conf->variable = newval;
}
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
conf->gen.source = source;
conf->gen.scontext = context;
}
if (makeDefault) {
GucStack* stack = NULL;
if (conf->gen.reset_source <= source) {
conf->reset_val = newval;
set_extra_field(&conf->gen, &conf->reset_extra, newextra);
conf->gen.reset_source = source;
conf->gen.reset_scontext = context;
}
for (stack = conf->gen.stack; stack; stack = stack->prev) {
if (stack->source <= source) {
stack->prior.val.intval = newval;
set_extra_field(&conf->gen, &stack->prior.extra, newextra);
stack->source = source;
stack->scontext = context;
}
}
}
/* Perhaps we didn't install newextra anywhere */
if (newextra && !extra_field_used(&conf->gen, newextra)) {
free(newextra);
newextra = NULL;
}
break;
}
case PGC_REAL: {
struct config_real* conf = (struct config_real*)record;
double newval;
void* newextra = NULL;
if (value != NULL) {
if (!parse_real(value, &newval)) {
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("parameter \"%s\" requires a numeric value", name)));
return 0;
}
if (newval < conf->min || newval > conf->max) {
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("%g is outside the valid range for parameter \"%s\" (%g .. %g)",
newval,
name,
conf->min,
conf->max)));
return 0;
}
if (!call_real_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else if (source == PGC_S_DEFAULT) {
newval = conf->boot_val;
if (!call_real_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else {
newval = conf->reset_val;
newextra = conf->reset_extra;
source = conf->gen.reset_source;
context = conf->gen.reset_scontext;
}
if (prohibitValueChange) {
if (*conf->variable != newval) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
return -1;
}
if (changeVal) {
/* Save old value to support transaction abort */
if (!makeDefault) {
push_old_value(&conf->gen, action);
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
if (!IsUnderPostmaster || conf->gen.context != PGC_POSTMASTER) {
*conf->variable = newval;
}
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
conf->gen.source = source;
conf->gen.scontext = context;
}
if (makeDefault) {
GucStack* stack = NULL;
if (conf->gen.reset_source <= source) {
conf->reset_val = newval;
set_extra_field(&conf->gen, &conf->reset_extra, newextra);
conf->gen.reset_source = source;
conf->gen.reset_scontext = context;
}
for (stack = conf->gen.stack; stack; stack = stack->prev) {
if (stack->source <= source) {
stack->prior.val.realval = newval;
set_extra_field(&conf->gen, &stack->prior.extra, newextra);
stack->source = source;
stack->scontext = context;
}
}
}
/* Perhaps we didn't install newextra anywhere */
if (newextra && !extra_field_used(&conf->gen, newextra)) {
pfree(newextra);
}
break;
}
case PGC_STRING: {
struct config_string* conf = (struct config_string*)record;
char* newval = NULL;
void* newextra = NULL;
if (u_sess->catalog_cxt.overrideStack &&
(strcasecmp(name, SEARCH_PATH_GUC_NAME) == 0 || strcasecmp(name, CURRENT_SCHEMA_GUC_NAME) == 0)) {
/*
* set search_path or current_schema inside stored procedure is invalid,
* return directly.
*/
OverrideStackEntry* entry = NULL;
entry = (OverrideStackEntry*)linitial(u_sess->catalog_cxt.overrideStack);
if (entry->inProcedure) {
return -1;
}
}
if (value != NULL) {
/*
* The value passed by the caller could be transient, so
* we always strdup it.
*/
newval = guc_strdup(elevel, value);
if (newval == NULL) {
return 0;
}
// when \parallel in gsql is on, we use "set search_path to pg_temp_XXX"
// to tell new started parallel postgres which temp namespace should use.
// but we should not clean the temp namespace when parallel postgres
// quiting, so a flag deleteTempOnQuiting is set to prevent clean
// temp namespace when postgres quiting.
if ((strcasecmp(name, "search_path") == 0 || strcasecmp(name, "current_schema") == 0) &&
isTempNamespaceName(value)) {
// If is not our own created temp namespace, we should not
// delete it when quitting, just leave it behand and it will
// be deleted by it's owner.
Oid nspid = get_namespace_oid(value, true);
if (OidIsValid(nspid)) {
if (!(OidIsValid(u_sess->catalog_cxt.myTempNamespace) &&
nspid == u_sess->catalog_cxt.myTempNamespace)) {
u_sess->catalog_cxt.deleteTempOnQuiting = false;
}
u_sess->catalog_cxt.myTempNamespace = nspid;
setTempToastNspName();
u_sess->catalog_cxt.baseSearchPathValid = false;
// @Temp Table. Coordinator should send the set temp schema command to each dn too.
// Add retry query error code ERRCODE_SET_QUERY for error "ERROR SET query".
if (IS_PGXC_COORDINATOR && PoolManagerSetCommand(POOL_CMD_TEMP, value) < 0) {
ereport(ERROR, (errcode(ERRCODE_SET_QUERY), errmsg("Postgres-XC: ERROR SET query")));
}
}
return 1;
}
/*
* The only built-in "parsing" check we have is to apply
* truncation if GUC_IS_NAME.
*/
if (conf->gen.flags & GUC_IS_NAME) {
truncate_identifier(newval, strlen(newval), true);
}
if (!call_string_check_hook(conf, &newval, &newextra, source, elevel)) {
pfree(newval);
return 0;
}
} else if (source == PGC_S_DEFAULT) {
/* non-NULL boot_val must always get strdup'd */
if (conf->boot_val != NULL) {
newval = guc_strdup(elevel, conf->boot_val);
if (newval == NULL) {
return 0;
}
} else {
newval = NULL;
}
if (!call_string_check_hook(conf, &newval, &newextra, source, elevel)) {
pfree(newval);
return 0;
}
} else {
/*
* strdup not needed, since reset_val is already under
* guc.c's control
*/
newval = conf->reset_val;
newextra = conf->reset_extra;
source = conf->gen.reset_source;
context = conf->gen.reset_scontext;
}
if (prohibitValueChange) {
/* newval shouldn't be NULL, so we're a bit sloppy here */
if (*conf->variable == NULL || newval == NULL || strcmp(*conf->variable, newval) != 0) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
return -1;
}
if (changeVal) {
/* Save old value to support transaction abort */
if (!makeDefault) {
push_old_value(&conf->gen, action);
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
if (!IsUnderPostmaster || conf->gen.context != PGC_POSTMASTER) {
set_string_field(conf, conf->variable, newval);
}
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
conf->gen.source = source;
conf->gen.scontext = context;
}
if (makeDefault) {
GucStack* stack = NULL;
if (conf->gen.reset_source <= source) {
set_string_field(conf, &conf->reset_val, newval);
set_extra_field(&conf->gen, &conf->reset_extra, newextra);
conf->gen.reset_source = source;
conf->gen.reset_scontext = context;
}
for (stack = conf->gen.stack; stack; stack = stack->prev) {
if (stack->source <= source) {
set_string_field(conf, &stack->prior.val.stringval, newval);
set_extra_field(&conf->gen, &stack->prior.extra, newextra);
stack->source = source;
stack->scontext = context;
}
}
}
/* Perhaps we didn't install newval anywhere */
if (newval && !string_field_used(conf, newval)) {
pfree(newval);
}
/* Perhaps we didn't install newextra anywhere */
if (newextra && !extra_field_used(&conf->gen, newextra)) {
pfree(newextra);
}
break;
}
case PGC_ENUM: {
struct config_enum* conf = (struct config_enum*)record;
int newval;
void* newextra = NULL;
if (value != NULL) {
if (!config_enum_lookup_by_name(conf, value, &newval)) {
char* hintmsg = NULL;
hintmsg = config_enum_get_options(conf, "Available values: ", ".", ", ");
ereport(elevel, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid value for parameter \"%s\": \"%s\"", name, value),
hintmsg ? errhint("%s", _(hintmsg)) : 0));
if (hintmsg != NULL) {
pfree(hintmsg);
}
return 0;
}
if (!call_enum_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else if (source == PGC_S_DEFAULT) {
newval = conf->boot_val;
if (!call_enum_check_hook(conf, &newval, &newextra, source, elevel)) {
return 0;
}
} else {
newval = conf->reset_val;
newextra = conf->reset_extra;
source = conf->gen.reset_source;
context = conf->gen.reset_scontext;
}
if (prohibitValueChange) {
if (*conf->variable != newval) {
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed without restarting the server", name)));
return 0;
}
return -1;
}
if (changeVal) {
/* Save old value to support transaction abort */
if (!makeDefault) {
push_old_value(&conf->gen, action);
}
if (conf->assign_hook) {
(*conf->assign_hook)(newval, newextra);
}
if (!IsUnderPostmaster || conf->gen.context != PGC_POSTMASTER) {
*conf->variable = newval;
}
set_extra_field(&conf->gen, &conf->gen.extra, newextra);
conf->gen.source = source;
conf->gen.scontext = context;
}
if (makeDefault) {
GucStack* stack = NULL;
if (conf->gen.reset_source <= source) {
conf->reset_val = newval;
set_extra_field(&conf->gen, &conf->reset_extra, newextra);
conf->gen.reset_source = source;
conf->gen.reset_scontext = context;
}
for (stack = conf->gen.stack; stack; stack = stack->prev) {
if (stack->source <= source) {
stack->prior.val.enumval = newval;
set_extra_field(&conf->gen, &stack->prior.extra, newextra);
stack->source = source;
stack->scontext = context;
}
}
}
/* Perhaps we didn't install newextra anywhere */
if (newextra && !extra_field_used(&conf->gen, newextra)) {
pfree(newextra);
}
break;
}
default:
break;
}
if (changeVal && (record->flags & GUC_REPORT)) {
report_guc_option(record);
}
SetThreadLocalGUC(u_sess);
return changeVal ? 1 : -1;
}
/*
* Set the fields for source file and line number the setting came from.
*/
static void set_config_sourcefile(const char* name, char* sourcefile, int sourceline)
{
struct config_generic* record = NULL;
int elevel;
/*
* To avoid cluttering the log, only the postmaster bleats loudly about
* problems with the config file.
*/
elevel = IsUnderPostmaster ? DEBUG3 : LOG;
record = find_option(name, true, elevel);
/* should not happen */
if (record == NULL) {
ereport(ERROR, (errcode(ERRCODE_INVALID_NAME), errmsg("unrecognized configuration parameter \"%s\"", name)));
}
sourcefile = guc_strdup(elevel, sourcefile);
if (record->sourcefile) {
pfree(record->sourcefile);
}
record->sourcefile = sourcefile;
record->sourceline = sourceline;
}
/*
* Set a config option to the given value.
*
* See also set_config_option; this is just the wrapper to be called from
* outside GUC. (This function should be used when possible, because its API
* is more stable than set_config_option's.)
*
* Note: there is no support here for setting source file/line, as it
* is currently not needed.
*/
void SetConfigOption(const char* name, const char* value, GucContext context, GucSource source)
{
(void)set_config_option(name, value, context, source, GUC_ACTION_SET, true, 0);
}
/*
* Fetch the current value of the option `name', as a string.
*
* If the option doesn't exist, return NULL if missing_ok is true (NOTE that
* this cannot be distinguished from a string variable with a NULL value!),
* otherwise throw an ereport and don't return.
*
* If restrict_superuser is true, we also enforce that only superusers can
* see GUC_SUPERUSER_ONLY variables. This should only be passed as true
* in user-driven calls.
*
* The string is *not* allocated for modification and is really only
* valid until the next call to configuration related functions.
*/
const char* GetConfigOption(const char* name, bool missing_ok, bool restrict_superuser)
{
struct config_generic* record = NULL;
char* buffer = t_thrd.buf_cxt.config_opt_buf;
int size = sizeof(t_thrd.buf_cxt.config_opt_buf);
int rc = 0;
record = find_option(name, false, ERROR);
if (record == NULL) {
if (missing_ok) {
return NULL;
}
ereport(
ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized configuration parameter \"%s\"", name)));
}
if (restrict_superuser && (record->flags & GUC_SUPERUSER_ONLY) && (GetUserId() != BOOTSTRAP_SUPERUSERID)) {
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be initial account to examine \"%s\"", name)));
}
switch (record->vartype) {
case PGC_BOOL:
return *((struct config_bool*)record)->variable ? "on" : "off";
case PGC_INT:
rc = snprintf_s(buffer, size, size - 1, "%d", *((struct config_int*)record)->variable);
securec_check_ss(rc, "\0", "\0");
return buffer;
case PGC_INT64:
rc = snprintf_s(buffer, size, size - 1, INT64_FORMAT, *((struct config_int64*)record)->variable);
securec_check_ss(rc, "\0", "\0");
return buffer;
case PGC_REAL:
rc = snprintf_s(buffer, size, size - 1, "%g", *((struct config_real*)record)->variable);
securec_check_ss(rc, "\0", "\0");
return buffer;
case PGC_STRING:
return *((struct config_string*)record)->variable;
case PGC_ENUM:
return config_enum_lookup_by_value((struct config_enum*)record, *((struct config_enum*)record)->variable);
default:
break;
}
return NULL;
}
/*
* Get the RESET value associated with the given option.
*
* Note: this is not re-entrant, due to use of static THR_LOCAL result buffer;
* not to mention that a string variable could have its reset_val changed.
* Beware of assuming the result value is good for very long.
*/
const char* GetConfigOptionResetString(const char* name)
{
struct config_generic* record = NULL;
char* buffer = t_thrd.buf_cxt.config_opt_reset_buf;
int size = sizeof(t_thrd.buf_cxt.config_opt_reset_buf);
int rc = 0;
record = find_option(name, false, ERROR);
if (record == NULL) {
ereport(
ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized configuration parameter \"%s\"", name)));
}
if ((record->flags & GUC_SUPERUSER_ONLY) && (GetUserId() != BOOTSTRAP_SUPERUSERID)) {
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be initial account to examine \"%s\"", name)));
}
switch (record->vartype) {
case PGC_BOOL:
return ((struct config_bool*)record)->reset_val ? "on" : "off";
case PGC_INT:
rc = snprintf_s(buffer, size, size - 1, "%d", ((struct config_int*)record)->reset_val);
securec_check_ss(rc, "\0", "\0");
return buffer;
case PGC_INT64:
rc = snprintf_s(buffer, size, size - 1, INT64_FORMAT, ((struct config_int64*)record)->reset_val);
securec_check_ss(rc, "\0", "\0");
return buffer;
case PGC_REAL:
rc = snprintf_s(buffer, size, size - 1, "%g", ((struct config_real*)record)->reset_val);
securec_check_ss(rc, "\0", "\0");
return buffer;
case PGC_STRING:
return ((struct config_string*)record)->reset_val;
case PGC_ENUM:
return config_enum_lookup_by_value((struct config_enum*)record, ((struct config_enum*)record)->reset_val);
}
return NULL;
}
/*
* flatten_set_variable_args
* Given a parsenode List as emitted by the grammar for SET,
* convert to the flat string representation used by GUC.
*
* We need to be told the name of the variable the args are for, because
* the flattening rules vary (ugh).
*
* The result is NULL if args is NIL (ie, SET ... TO DEFAULT), otherwise
* a palloc'd string.
*/
static char* flatten_set_variable_args(const char* name, List* args)
{
struct config_generic* record = NULL;
unsigned int flags;
StringInfoData buf;
ListCell* l = NULL;
/* Fast path if just DEFAULT */
if (args == NIL) {
return NULL;
}
/*
* Get flags for the variable; if it's not known, use default flags.
* (Caller might throw error later, but not our business to do so here.)
*/
record = find_option(name, false, WARNING);
if (record != NULL) {
flags = (unsigned int)record->flags;
} else {
flags = 0;
}
/* Complain if list input and non-list variable */
if ((flags & GUC_LIST_INPUT) == 0 && list_length(args) != 1) {
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("SET %s takes only one argument", name)));
}
initStringInfo(&buf);
/*
* Each list member may be a plain A_Const node, or an A_Const within a
* TypeCast; the latter case is supported only for ConstInterval arguments
* (for SET TIME ZONE).
*/
foreach (l, args) {
Node* arg = (Node*)lfirst(l);
char* val = NULL;
TypeName* typname = NULL;
A_Const* con = NULL;
if (l != list_head(args)) {
appendStringInfo(&buf, ", ");
}
if (IsA(arg, TypeCast)) {
TypeCast* tc = (TypeCast*)arg;
arg = tc->arg;
typname = tc->typname;
}
if (!IsA(arg, A_Const)) {
ereport(
ERROR, (errcode(ERRCODE_INVALID_OPERATION), errmsg("unrecognized node type: %d", (int)nodeTag(arg))));
}
con = (A_Const*)arg;
switch (nodeTag(&con->val)) {
case T_Integer:
appendStringInfo(&buf, "%ld", intVal(&con->val));
break;
case T_Float:
/* represented as a string, so just copy it */
appendStringInfoString(&buf, strVal(&con->val));
break;
case T_String:
case T_Null:
if (nodeTag(&con->val) == T_String) {
val = strVal(&con->val);
} else {
val = "";
}
if (typname != NULL) {
/*
* Must be a ConstInterval argument for TIME ZONE. Coerce
* to interval and back to normalize the value and account
* for any typmod.
*/
Oid typoid;
int32 typmod;
Datum interval;
char* intervalout = NULL;
typenameTypeIdAndMod(NULL, typname, &typoid, &typmod);
Assert(typoid == INTERVALOID);
interval = DirectFunctionCall3(
interval_in, CStringGetDatum(val), ObjectIdGetDatum(InvalidOid), Int32GetDatum(typmod));
intervalout = DatumGetCString(DirectFunctionCall1(interval_out, interval));
appendStringInfo(&buf, "INTERVAL '%s'", intervalout);
} else {
/*
* Plain string literal or identifier. For quote mode,
* quote it if it's not a vanilla identifier.
*/
if (flags & GUC_LIST_QUOTE) {
appendStringInfoString(&buf, quote_identifier(val));
} else {
appendStringInfoString(&buf, val);
}
}
break;
default:
ereport(ERROR,
(errcode(ERRCODE_INVALID_OPERATION),
errmsg("unrecognized node type: %d", (int)nodeTag(&con->val))));
break;
}
}
return buf.data;
}
/*
* SET command
*/
void ExecSetVariableStmt(VariableSetStmt* stmt)
{
GucAction action = stmt->is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET;
A_Const* arg = NULL;
char* role = NULL;
char* passwd = NULL;
ListCell* phead = NULL;
switch (stmt->kind) {
case VAR_SET_VALUE:
case VAR_SET_CURRENT:
(void)set_config_option(stmt->name,
ExtractSetVariableArgs(stmt),
(superuser() ? PGC_SUSET : PGC_USERSET),
PGC_S_SESSION,
action,
true,
0);
// switch the tablespace to the one with the same name as schema
// when we switch the current schema with search_path
if (!pg_strcasecmp(stmt->name, "search_path") || !pg_strcasecmp(stmt->name, "current_schema")) {
char* var = NULL;
char* spcname = NULL;
if (!pg_strcasecmp(stmt->name, "search_path")) {
var = "current_schema";
} else {
var = "search_path";
}
(void)set_config_option(var,
ExtractSetVariableArgs(stmt),
(superuser() ? PGC_SUSET : PGC_USERSET),
PGC_S_SESSION,
action,
true,
0);
/* must not be null */
if (!PointerIsValid(stmt->args)) {
break;
}
/* get parameter as string */
spcname = ExtractSetVariableArgs(stmt);
if (spcname != NULL) {
char* tempname = strstr(spcname, SCHEMA_TEMP_NAME);
char* catalogname = strstr(spcname, SCHEMA_CATALOG_NAME);
if ((tempname != NULL && tempname - spcname != 0) ||
(catalogname != NULL && catalogname - spcname != 0)) {
ereport(WARNING,
(errmsg("It is invalid to set pg_temp or pg_catalog behind other schemas in search path "
"explicitly. The priority order is pg_temp, pg_catalog and other schemas.")));
}
}
if (SUPPORT_BIND_TABLESPACE) {
/* must be one item */
if (stmt->args->length != 1) {
break;
}
/* get the tablespace id that has the same name as parameter */
if (OidIsValid(get_tablespace_oid(spcname, true))) {
(void)set_config_option("default_tablespace",
spcname,
(superuser() ? PGC_SUSET : PGC_USERSET),
PGC_S_SESSION,
action,
true,
0);
}
}
}
break;
case VAR_SET_MULTI:
/*
* Special-case SQL syntaxes. The TRANSACTION and SESSION
* CHARACTERISTICS cases effectively set more than one variable
* per statement. TRANSACTION SNAPSHOT only takes one argument,
* but we put it here anyway since it's a special case and not
* related to any GUC variable.
*/
if (strcmp(stmt->name, "TRANSACTION") == 0) {
ListCell* head = NULL;
foreach (head, stmt->args) {
DefElem* item = (DefElem*)lfirst(head);
if (strcmp(item->defname, "transaction_isolation") == 0) {
SetPGVariable("transaction_isolation", list_make1(item->arg), stmt->is_local);
} else if (strcmp(item->defname, "transaction_read_only") == 0) {
SetPGVariable("transaction_read_only", list_make1(item->arg), stmt->is_local);
} else if (strcmp(item->defname, "transaction_deferrable") == 0) {
SetPGVariable("transaction_deferrable", list_make1(item->arg), stmt->is_local);
} else {
ereport(ERROR,
(errcode(ERRCODE_INVALID_OPERATION),
errmsg("unexpected SET TRANSACTION element: %s", item->defname)));
}
}
} else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0) {
ListCell* head = NULL;
foreach (head, stmt->args) {
DefElem* item = (DefElem*)lfirst(head);
if (strcmp(item->defname, "transaction_isolation") == 0) {
SetPGVariable("default_transaction_isolation", list_make1(item->arg), stmt->is_local);
} else if (strcmp(item->defname, "transaction_read_only") == 0) {
SetPGVariable("default_transaction_read_only", list_make1(item->arg), stmt->is_local);
} else if (strcmp(item->defname, "transaction_deferrable") == 0) {
SetPGVariable("default_transaction_deferrable", list_make1(item->arg), stmt->is_local);
} else {
ereport(ERROR,
(errcode(ERRCODE_INVALID_OPERATION),
errmsg("unexpected SET SESSION element: %s", item->defname)));
}
}
} else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0) {
A_Const* con = (A_Const*)linitial(stmt->args);
if (stmt->is_local) {
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));
}
AssertEreport(IsA(con, A_Const), MOD_OPT, "");
Assert(nodeTag(&con->val) == T_String || (nodeTag(&con->val) == T_Null && strVal(&con->val) != NULL));
ImportSnapshot(strVal(&con->val));
} else {
ereport(ERROR,
(errcode(ERRCODE_INVALID_OPERATION), errmsg("unexpected SET MULTI element: %s", stmt->name)));
}
break;
case VAR_SET_ROLEPWD:
if ((stmt->name == NULL) ||
((strcmp(stmt->name, "role") != 0) && pg_strcasecmp(stmt->name, "session_authorization") != 0)) {
ereport(ERROR, (errcode(ERRCODE_INVALID_OPERATION), errmsg("unexpected SET name: %s", stmt->name)));
break;
}
/* OK, Get role and pwd from arguments */
role = NULL;
passwd = NULL;
phead = NULL;
phead = list_head(stmt->args);
if (phead != NULL) {
/* role */
arg = (A_Const*)linitial(stmt->args);
if (arg == NULL) {
ereport(ERROR, (errcode(ERRCODE_SYSTEM_ERROR), errmsg("role name in the set command is empty.")));
break;
}
/* check the existence of role and verify the password */
role = strVal(&arg->val);
if (lnext(phead)) {
arg = (A_Const*)lsecond(stmt->args);
if (arg != NULL) {
passwd = strVal(&arg->val);
}
}
if (pg_strcasecmp(stmt->name, "session_authorization") == 0) {
if (!verify_setrole_passwd(role, passwd, false)) {
str_reset(passwd);
ereport(ERROR,
(errcode(ERRCODE_SYSTEM_ERROR),
errmsg("verify set session_authorization and passwd failed.")));
break;
}
} else {
if (!verify_setrole_passwd(role, passwd, true)) {
str_reset(passwd);
ereport(ERROR, (errcode(ERRCODE_SYSTEM_ERROR), errmsg("verify set role and passwd failed.")));
break;
}
}
/* passwd is sensitive info, it should be cleaned when it's useless */
str_reset(passwd);
}
(void)set_config_option(
stmt->name, role, (superuser() ? PGC_SUSET : PGC_USERSET), PGC_S_SESSION, action, true, 0);
break;
case VAR_SET_DEFAULT:
case VAR_RESET:
(void)set_config_option(
stmt->name, NULL, (superuser() ? PGC_SUSET : PGC_USERSET), PGC_S_SESSION, action, true, 0);
if (!pg_strcasecmp(stmt->name, "search_path") || !pg_strcasecmp(stmt->name, "current_schema")) {
char* var = NULL;
if (!pg_strcasecmp(stmt->name, "search_path")) {
var = "current_schema";
} else {
var = "search_path";
}
(void)set_config_option(
var, NULL, (superuser() ? PGC_SUSET : PGC_USERSET), PGC_S_SESSION, action, true, 0);
}
break;
case VAR_RESET_ALL:
ResetAllOptions();
break;
default:
break;
}
}
/*
* Get the value to assign for a VariableSetStmt, or NULL if it's RESET.
* The result is palloc'd.
*
* This is exported for use by actions such as ALTER ROLE SET.
*/
char* ExtractSetVariableArgs(VariableSetStmt* stmt)
{
switch (stmt->kind) {
case VAR_SET_VALUE:
return flatten_set_variable_args(stmt->name, stmt->args);
case VAR_SET_CURRENT:
return GetConfigOptionByName(stmt->name, NULL);
default:
return NULL;
}
}
/*
* SetPGVariable - SET command exported as an easily-C-callable function.
*
* This provides access to SET TO value, as well as SET TO DEFAULT (expressed
* by passing args == NIL), but not SET FROM CURRENT functionality.
*/
void SetPGVariable(const char* name, List* args, bool is_local)
{
char* argstring = flatten_set_variable_args(name, args);
/* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
(void)set_config_option(name,
argstring,
(superuser() ? PGC_SUSET : PGC_USERSET),
PGC_S_SESSION,
is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
true,
0);
}
/*
* SET command wrapped as a SQL callable function.
*/
Datum set_config_by_name(PG_FUNCTION_ARGS)
{
char* name = NULL;
char* value = NULL;
char* new_value = NULL;
bool is_local = false;
if (PG_ARGISNULL(0)) {
ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("SET requires parameter name")));
}
/* Get the GUC variable name */
name = TextDatumGetCString(PG_GETARG_DATUM(0));
/* Get the desired value or set to NULL for a reset request */
if (PG_ARGISNULL(1)) {
value = NULL;
} else {
value = TextDatumGetCString(PG_GETARG_DATUM(1));
}
/*
* Get the desired state of is_local. Default to false if provided value
* is NULL
*/
if (PG_ARGISNULL(2)) {
is_local = false;
} else {
is_local = PG_GETARG_BOOL(2);
}
/* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
(void)set_config_option(name,
value,
(superuser() ? PGC_SUSET : PGC_USERSET),
PGC_S_SESSION,
is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
true,
0);
/* get the new current value */
new_value = GetConfigOptionByName(name, NULL);
#ifdef PGXC
/*
* Convert this to SET statement and pass it to pooler.
* If command is local and we are not in a transaction block do NOT
* send this query to backend nodes, it is just bypassed by the backend.
*/
if (IS_PGXC_COORDINATOR && !IsConnFromCoord() && (!is_local || IsTransactionBlock())) {
PoolCommandType poolcmdType = (is_local ? POOL_CMD_LOCAL_SET : POOL_CMD_GLOBAL_SET);
StringInfoData poolcmd;
initStringInfo(&poolcmd);
appendStringInfo(&poolcmd, "SET %s %s TO %s", (is_local ? "LOCAL" : ""), name, (value ? value : "DEFAULT"));
// Add retry query error code ERRCODE_SET_QUERY for error "ERROR SET query".
if (PoolManagerSetCommand(poolcmdType, poolcmd.data) < 0) {
ereport(ERROR, (errcode(ERRCODE_SET_QUERY), errmsg("Postgres-XC: ERROR SET query")));
}
}
#endif
/* Convert return string to text */
PG_RETURN_TEXT_P(cstring_to_text(new_value));
}
/*
* Common code for DefineCustomXXXVariable subroutines: allocate the
* new variable's config struct and fill in generic fields.
*/
static struct config_generic* init_custom_variable(const char* name, const char* short_desc, const char* long_desc,
GucContext context, int flags, enum config_type type, size_t sz)
{
struct config_generic* gen = NULL;
/*
* Only allow custom PGC_POSTMASTER variables to be created during shared
* library preload; any later than that, we can't ensure that the value
* doesn't change after startup. This is a fatal elog if it happens; just
* erroring out isn't safe because we don't know what the calling loadable
* module might already have hooked into.
*/
if (context == PGC_POSTMASTER && !u_sess->misc_cxt.process_shared_preload_libraries_in_progress) {
ereport(FATAL, (errmsg("cannot create PGC_POSTMASTER variables after startup")));
}
gen = (struct config_generic*)guc_malloc(ERROR, sz);
errno_t rc = memset_s(gen, sz, 0, sz);
securec_check(rc, "\0", "\0");
gen->name = guc_strdup(ERROR, name);
gen->context = context;
gen->group = CUSTOM_OPTIONS;
gen->short_desc = short_desc;
gen->long_desc = long_desc;
gen->flags = flags;
gen->vartype = type;
return gen;
}
/*
* Common code for DefineCustomXXXVariable subroutines: insert the new
* variable into the GUC variable array, replacing any placeholder.
*/
static void define_custom_variable(struct config_generic* variable)
{
const char* name = variable->name;
const char** name_addr = &name;
struct config_string* holder = NULL;
struct config_generic** res;
/*
* See if there's a placeholder by the same name.
*/
res = (struct config_generic**)bsearch((void*)&name_addr,
(void*)u_sess->guc_variables,
u_sess->num_guc_variables,
sizeof(struct config_generic*),
guc_var_compare);
if (res == NULL) {
/*
* No placeholder to replace, so we can just add it ... but first,
* make sure it's initialized to its default value.
*/
initialize_one_guc_option(variable);
add_guc_variable(variable, ERROR);
return;
}
/*
* This better be a placeholder
*/
if (((unsigned int)(*res)->flags & GUC_CUSTOM_PLACEHOLDER) == 0) {
ereport(ERROR, (errcode(ERRCODE_SYSTEM_ERROR), errmsg("attempt to redefine parameter \"%s\"", name)));
}
Assert((*res)->vartype == PGC_STRING);
holder = (struct config_string*)(*res);
/*
* First, set the variable to its default value. We must do this even
* though we intend to immediately apply a new value, since it's possible
* that the new value is invalid.
*/
initialize_one_guc_option(variable);
/*
* Replace the placeholder. We aren't changing the name, so no re-sorting
* is necessary
*/
*res = variable;
/*
* Assign the string value(s) stored in the placeholder to the real
* variable. Essentially, we need to duplicate all the active and stacked
* values, but with appropriate validation and datatype adjustment.
*
* If an assignment fails, we report a WARNING and keep going. We don't
* want to throw ERROR for bad values, because it'd bollix the add-on
* module that's presumably halfway through getting loaded. In such cases
* the default or previous state will become active instead.
*/
/* First, apply the reset value if any */
if (holder->reset_val) {
(void)set_config_option(name,
holder->reset_val,
holder->gen.reset_scontext,
holder->gen.reset_source,
GUC_ACTION_SET,
true,
WARNING);
}
/* That should not have resulted in stacking anything */
AssertEreport(variable->stack == NULL, MOD_OPT, "");
/* Now, apply current and stacked values, in the order they were stacked */
reapply_stacked_values(
variable, holder, holder->gen.stack, *(holder->variable), holder->gen.scontext, holder->gen.source);
/* Also copy over any saved source-location information */
if (holder->gen.sourcefile) {
set_config_sourcefile(name, holder->gen.sourcefile, holder->gen.sourceline);
}
/*
* Free up as much as we conveniently can of the placeholder structure.
* (This neglects any stack items, so it's possible for some memory to be
* leaked. Since this can only happen once per session per variable, it
* doesn't seem worth spending much code on.)
*/
set_string_field(holder, holder->variable, NULL);
set_string_field(holder, &holder->reset_val, NULL);
pfree(holder);
}
/*
* Recursive subroutine for define_custom_variable: reapply non-reset values
*
* We recurse so that the values are applied in the same order as originally.
* At each recursion level, apply the upper-level value (passed in) in the
* fashion implied by the stack entry.
*/
static void reapply_stacked_values(struct config_generic* variable, struct config_string* holder, GucStack* stack,
const char* curvalue, GucContext curscontext, GucSource cursource)
{
const char* name = variable->name;
GucStack* oldvarstack = variable->stack;
if (stack != NULL) {
/* First, recurse, so that stack items are processed bottom to top */
reapply_stacked_values(
variable, holder, stack->prev, stack->prior.val.stringval, stack->scontext, stack->source);
/* See how to apply the passed-in value */
switch (stack->state) {
case GUC_SAVE:
(void)set_config_option(name, curvalue, curscontext, cursource, GUC_ACTION_SAVE, true, WARNING);
break;
case GUC_SET:
(void)set_config_option(name, curvalue, curscontext, cursource, GUC_ACTION_SET, true, WARNING);
break;
case GUC_LOCAL:
(void)set_config_option(name, curvalue, curscontext, cursource, GUC_ACTION_LOCAL, true, WARNING);
break;
case GUC_SET_LOCAL:
/* first, apply the masked value as SET */
(void)set_config_option(name,
stack->masked.val.stringval,
stack->masked_scontext,
PGC_S_SESSION,
GUC_ACTION_SET,
true,
WARNING);
/* then apply the current value as LOCAL */
(void)set_config_option(name, curvalue, curscontext, cursource, GUC_ACTION_LOCAL, true, WARNING);
break;
default:
break;
}
/* If we successfully made a stack entry, adjust its nest level */
if (variable->stack && variable->stack != oldvarstack) {
variable->stack->nest_level = stack->nest_level;
}
} else {
/*
* We are at the end of the stack. If the active/previous value is
* different from the reset value, it must represent a previously
* committed session value. Apply it, and then drop the stack entry
* that set_config_option will have created under the impression that
* this is to be just a transactional assignment. (We leak the stack
* entry.)
*/
if (curvalue != holder->reset_val || curscontext != holder->gen.reset_scontext ||
cursource != holder->gen.reset_source) {
(void)set_config_option(name, curvalue, curscontext, cursource, GUC_ACTION_SET, true, WARNING);
variable->stack = NULL;
}
}
}
void DefineCustomBoolVariable(const char* name, const char* short_desc, const char* long_desc, bool* valueAddr,
bool bootValue, GucContext context, int flags, GucBoolCheckHook check_hook, GucBoolAssignHook assign_hook,
GucShowHook show_hook)
{
struct config_bool* var = NULL;
var = (struct config_bool*)init_custom_variable(
name, short_desc, long_desc, context, flags, PGC_BOOL, sizeof(struct config_bool));
var->variable = valueAddr;
var->boot_val = bootValue;
var->reset_val = bootValue;
var->check_hook = check_hook;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
}
void DefineCustomIntVariable(const char* name, const char* short_desc, const char* long_desc, int* valueAddr,
int bootValue, int minValue, int maxValue, GucContext context, int flags, GucIntCheckHook check_hook,
GucIntAssignHook assign_hook, GucShowHook show_hook)
{
struct config_int* var = NULL;
var = (struct config_int*)init_custom_variable(
name, short_desc, long_desc, context, flags, PGC_INT, sizeof(struct config_int));
var->variable = valueAddr;
var->boot_val = bootValue;
var->reset_val = bootValue;
var->min = minValue;
var->max = maxValue;
var->check_hook = check_hook;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
}
void DefineCustomInt64Variable(const char* name, const char* short_desc, const char* long_desc, int64* valueAddr,
int64 bootValue, int64 minValue, int64 maxValue, GucContext context, int flags, GucInt64CheckHook check_hook,
GucInt64AssignHook assign_hook, GucShowHook show_hook)
{
struct config_int64* var = NULL;
var = (struct config_int64*)init_custom_variable(
name, short_desc, long_desc, context, flags, PGC_INT64, sizeof(struct config_int64));
var->variable = valueAddr;
var->boot_val = bootValue;
var->reset_val = bootValue;
var->min = minValue;
var->max = maxValue;
var->check_hook = check_hook;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
}
void DefineCustomRealVariable(const char* name, const char* short_desc, const char* long_desc, double* valueAddr,
double bootValue, double minValue, double maxValue, GucContext context, int flags, GucRealCheckHook check_hook,
GucRealAssignHook assign_hook, GucShowHook show_hook)
{
struct config_real* var = NULL;
var = (struct config_real*)init_custom_variable(
name, short_desc, long_desc, context, flags, PGC_REAL, sizeof(struct config_real));
var->variable = valueAddr;
var->boot_val = bootValue;
var->reset_val = bootValue;
var->min = minValue;
var->max = maxValue;
var->check_hook = check_hook;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
}
void DefineCustomStringVariable(const char* name, const char* short_desc, const char* long_desc, char** valueAddr,
const char* bootValue, GucContext context, int flags, GucStringCheckHook check_hook,
GucStringAssignHook assign_hook, GucShowHook show_hook)
{
struct config_string* var = NULL;
var = (struct config_string*)init_custom_variable(
name, short_desc, long_desc, context, flags, PGC_STRING, sizeof(struct config_string));
var->variable = valueAddr;
var->boot_val = bootValue;
var->check_hook = check_hook;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
}
void DefineCustomEnumVariable(const char* name, const char* short_desc, const char* long_desc, int* valueAddr,
int bootValue, const struct config_enum_entry* options, GucContext context, int flags, GucEnumCheckHook check_hook,
GucEnumAssignHook assign_hook, GucShowHook show_hook)
{
struct config_enum* var = NULL;
var = (struct config_enum*)init_custom_variable(
name, short_desc, long_desc, context, flags, PGC_ENUM, sizeof(struct config_enum));
var->variable = valueAddr;
var->boot_val = bootValue;
var->reset_val = bootValue;
var->options = options;
var->check_hook = check_hook;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
}
void EmitWarningsOnPlaceholders(const char* className)
{
int classLen = strlen(className);
int i;
for (i = 0; i < u_sess->num_guc_variables; i++) {
struct config_generic* var = u_sess->guc_variables[i];
if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 && strncmp(className, var->name, classLen) == 0 &&
var->name[classLen] == GUC_QUALIFIER_SEPARATOR) {
ereport(WARNING,
(errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized configuration parameter \"%s\"", var->name)));
}
}
}
/*
* SHOW command
*/
void GetPGVariable(const char* name, DestReceiver* dest)
{
if (guc_name_compare(name, "all") == 0) {
show_all_guc_config(dest);
} else {
show_guc_config_option(name, dest);
}
}
TupleDesc GetPGVariableResultDesc(const char* name)
{
TupleDesc tupdesc;
if (guc_name_compare(name, "all") == 0) {
/* need a tuple descriptor representing three TEXT columns */
tupdesc = CreateTemplateTupleDesc(3, false);
TupleDescInitEntry(tupdesc, (AttrNumber)1, "name", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)2, "setting", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)3, "description", TEXTOID, -1, 0);
} else {
const char* varname = NULL;
/* Get the canonical spelling of name */
(void)GetConfigOptionByName(name, &varname);
/* need a tuple descriptor representing a single TEXT column */
tupdesc = CreateTemplateTupleDesc(1, false);
TupleDescInitEntry(tupdesc, (AttrNumber)1, varname, TEXTOID, -1, 0);
}
return tupdesc;
}
/*
* SHOW command
*/
static void show_guc_config_option(const char* name, DestReceiver* dest)
{
TupOutputState* tstate = NULL;
TupleDesc tupdesc;
const char* varname = NULL;
char* value = NULL;
/* Get the value and canonical spelling of name */
value = GetConfigOptionByName(name, &varname);
/* need a tuple descriptor representing a single TEXT column */
tupdesc = CreateTemplateTupleDesc(1, false);
TupleDescInitEntry(tupdesc, (AttrNumber)1, varname, TEXTOID, -1, 0);
/* prepare for projection of tuples */
tstate = begin_tup_output_tupdesc(dest, tupdesc);
/* Send it */
do_text_output_oneline(tstate, value);
end_tup_output(tstate);
}
/*
* SHOW ALL command
*/
static void show_all_guc_config(DestReceiver* dest)
{
bool am_superuser = (GetUserId() == BOOTSTRAP_SUPERUSERID);
int i;
TupOutputState* tstate = NULL;
TupleDesc tupdesc;
Datum values[3];
bool isnull[3] = {false, false, false};
/* need a tuple descriptor representing three TEXT columns */
tupdesc = CreateTemplateTupleDesc(3, false);
TupleDescInitEntry(tupdesc, (AttrNumber)1, "name", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)2, "setting", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)3, "description", TEXTOID, -1, 0);
/* prepare for projection of tuples */
tstate = begin_tup_output_tupdesc(dest, tupdesc);
for (i = 0; i < u_sess->num_guc_variables; i++) {
struct config_generic* conf = u_sess->guc_variables[i];
char* setting = NULL;
if ((conf->flags & GUC_NO_SHOW_ALL) || ((conf->flags & GUC_SUPERUSER_ONLY) && !am_superuser)) {
continue;
}
/* assign to the values array */
values[0] = PointerGetDatum(cstring_to_text(conf->name));
setting = _show_option(conf, true);
if (setting != NULL) {
values[1] = PointerGetDatum(cstring_to_text(setting));
isnull[1] = false;
} else {
values[1] = PointerGetDatum(NULL);
isnull[1] = true;
}
values[2] = PointerGetDatum(cstring_to_text(conf->short_desc));
/* send it to dest */
do_tup_output(tstate, values, 3, isnull, 3);
/* clean up */
pfree(DatumGetPointer(values[0]));
if (setting != NULL) {
pfree(setting);
pfree(DatumGetPointer(values[1]));
}
pfree(DatumGetPointer(values[2]));
}
end_tup_output(tstate);
}
/*
* Return GUC variable value by name; optionally return canonical
* form of name. Return value is palloc'd.
*/
char* GetConfigOptionByName(const char* name, const char** varname)
{
struct config_generic* record = NULL;
record = find_option(name, false, ERROR);
if (record == NULL) {
ereport(
ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized configuration parameter \"%s\"", name)));
}
if ((record->flags & GUC_SUPERUSER_ONLY) && (GetUserId() != BOOTSTRAP_SUPERUSERID)) {
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be initial account to examine \"%s\"", name)));
}
if (varname != NULL) {
*varname = record->name;
}
return _show_option(record, true);
}
/*
* Return GUC variable value by variable number; optionally return canonical
* form of name. Return value is palloc'd.
*/
void GetConfigOptionByNum(int varnum, const char** values, bool* noshow)
{
char buffer[256];
struct config_generic* conf = NULL;
int rc = 0;
/* check requested variable number valid */
Assert((varnum >= 0) && (varnum < u_sess->num_guc_variables));
conf = u_sess->guc_variables[varnum];
if (noshow != NULL) {
if ((conf->flags & GUC_NO_SHOW_ALL) ||
((conf->flags & GUC_SUPERUSER_ONLY) && (GetUserId() != BOOTSTRAP_SUPERUSERID))) {
*noshow = true;
} else {
*noshow = false;
}
}
/* first get the generic attributes */
/* name */
values[0] = conf->name;
/* setting : use _show_option in order to avoid duplicating the logic */
values[1] = _show_option(conf, false);
/* unit */
if (conf->vartype == PGC_INT) {
char buf[8];
switch (conf->flags & (GUC_UNIT_MEMORY | GUC_UNIT_TIME)) {
case GUC_UNIT_KB:
values[2] = "kB";
break;
case GUC_UNIT_BLOCKS:
rc = snprintf_s(buf, sizeof(buf), sizeof(buf) - 1, "%dkB", BLCKSZ / 1024);
securec_check_ss(rc, "\0", "\0");
values[2] = pstrdup(buf);
break;
case GUC_UNIT_XBLOCKS:
rc = snprintf_s(buf, sizeof(buf), sizeof(buf) - 1, "%dkB", XLOG_BLCKSZ / 1024);
securec_check_ss(rc, "\0", "\0");
values[2] = pstrdup(buf);
break;
case GUC_UNIT_MS:
values[2] = "ms";
break;
case GUC_UNIT_S:
values[2] = "s";
break;
case GUC_UNIT_MIN:
values[2] = "min";
break;
case GUC_UNIT_HOUR:
values[2] = "hour";
break;
default:
values[2] = "";
break;
}
} else {
values[2] = NULL;
}
/* group */
values[3] = config_group_names[conf->group];
/* short_desc */
values[4] = conf->short_desc;
/* extra_desc */
values[5] = conf->long_desc;
/* context */
values[6] = GucContext_Names[conf->context];
/* vartype */
values[7] = config_type_names[conf->vartype];
/* source */
values[8] = GucSource_Names[conf->source];
/* now get the type specifc attributes */
switch (conf->vartype) {
case PGC_BOOL: {
struct config_bool* lconf = (struct config_bool*)conf;
/* min_val */
values[9] = NULL;
/* max_val */
values[10] = NULL;
/* enumvals */
values[11] = NULL;
/* boot_val */
values[12] = pstrdup(lconf->boot_val ? "on" : "off");
/* reset_val */
values[13] = pstrdup(lconf->reset_val ? "on" : "off");
} break;
case PGC_INT: {
struct config_int* lconf = (struct config_int*)conf;
/* min_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%d", lconf->min);
securec_check_ss(rc, "\0", "\0");
values[9] = pstrdup(buffer);
/* max_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%d", lconf->max);
securec_check_ss(rc, "\0", "\0");
values[10] = pstrdup(buffer);
/* enumvals */
values[11] = NULL;
/* boot_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%d", lconf->boot_val);
securec_check_ss(rc, "\0", "\0");
values[12] = pstrdup(buffer);
/* reset_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%d", lconf->reset_val);
securec_check_ss(rc, "\0", "\0");
values[13] = pstrdup(buffer);
} break;
case PGC_INT64: {
struct config_int64* lconf = (struct config_int64*)conf;
/* min_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, INT64_FORMAT, lconf->min);
securec_check_ss(rc, "\0", "\0");
values[9] = pstrdup(buffer);
/* max_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, INT64_FORMAT, lconf->max);
securec_check_ss(rc, "\0", "\0");
values[10] = pstrdup(buffer);
/* enumvals */
values[11] = NULL;
/* boot_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, INT64_FORMAT, lconf->boot_val);
securec_check_ss(rc, "\0", "\0");
values[12] = pstrdup(buffer);
/* reset_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, INT64_FORMAT, lconf->reset_val);
securec_check_ss(rc, "\0", "\0");
values[13] = pstrdup(buffer);
} break;
case PGC_REAL: {
struct config_real* lconf = (struct config_real*)conf;
/* min_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%g", lconf->min);
securec_check_ss(rc, "\0", "\0");
values[9] = pstrdup(buffer);
/* max_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%g", lconf->max);
securec_check_ss(rc, "\0", "\0");
values[10] = pstrdup(buffer);
/* enumvals */
values[11] = NULL;
/* boot_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%g", lconf->boot_val);
securec_check_ss(rc, "\0", "\0");
values[12] = pstrdup(buffer);
/* reset_val */
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%g", lconf->reset_val);
securec_check_ss(rc, "\0", "\0");
values[13] = pstrdup(buffer);
} break;
case PGC_STRING: {
struct config_string* lconf = (struct config_string*)conf;
/* min_val */
values[9] = NULL;
/* max_val */
values[10] = NULL;
/* enumvals */
values[11] = NULL;
/* boot_val */
if (lconf->boot_val == NULL) {
values[12] = NULL;
} else {
values[12] = pstrdup(lconf->boot_val);
}
/* reset_val */
if (lconf->reset_val == NULL) {
values[13] = NULL;
} else {
values[13] = pstrdup(lconf->reset_val);
}
} break;
case PGC_ENUM: {
struct config_enum* lconf = (struct config_enum*)conf;
/* min_val */
values[9] = NULL;
/* max_val */
values[10] = NULL;
/* enumvals */
/*
* NOTE! enumvals with double quotes in them are not
* supported!
*/
values[11] = config_enum_get_options((struct config_enum*)conf, "{\"", "\"}", "\",\"");
/* boot_val */
values[12] = pstrdup(config_enum_lookup_by_value(lconf, lconf->boot_val));
/* reset_val */
values[13] = pstrdup(config_enum_lookup_by_value(lconf, lconf->reset_val));
} break;
default: { /* should never get here, but in case we do, set 'em to NULL */
/* min_val */
values[9] = NULL;
/* max_val */
values[10] = NULL;
/* enumvals */
values[11] = NULL;
/* boot_val */
values[12] = NULL;
/* reset_val */
values[13] = NULL;
} break;
}
/*
* If the setting came from a config file, set the source location. For
* security reasons, we don't show source file/line number for
* non-superusers.
*/
if (conf->source == PGC_S_FILE && superuser()) {
values[14] = conf->sourcefile;
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%d", conf->sourceline);
securec_check_ss(rc, "\0", "\0");
values[15] = pstrdup(buffer);
} else {
values[14] = NULL;
values[15] = NULL;
}
}
/*
* Return the total number of GUC variables
*/
int GetNumConfigOptions(void)
{
return u_sess->num_guc_variables;
}
/*
* show_config_by_name - equiv to SHOW X command but implemented as
* a function.
*/
Datum show_config_by_name(PG_FUNCTION_ARGS)
{
char* varname = NULL;
char* varval = NULL;
/* Get the GUC variable name */
varname = TextDatumGetCString(PG_GETARG_DATUM(0));
/* Get the value */
varval = GetConfigOptionByName(varname, NULL);
/* Convert to text */
PG_RETURN_TEXT_P(cstring_to_text(varval));
}
/*
* show_all_settings - equiv to SHOW ALL command but implemented as
* a Table Function.
*/
#define NUM_PG_SETTINGS_ATTS 16
Datum show_all_settings(PG_FUNCTION_ARGS)
{
FuncCallContext* funcctx = NULL;
TupleDesc tupdesc;
int call_cntr;
int max_calls;
AttInMetadata* attinmeta = NULL;
MemoryContext oldcontext;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL()) {
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/*
* switch to memory context appropriate for multiple function calls
*/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/*
* need a tuple descriptor representing NUM_PG_SETTINGS_ATTS columns
* of the appropriate types
*/
tupdesc = CreateTemplateTupleDesc(NUM_PG_SETTINGS_ATTS, false);
TupleDescInitEntry(tupdesc, (AttrNumber)1, "name", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)2, "setting", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)3, "unit", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)4, "category", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)5, "short_desc", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)6, "extra_desc", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)7, "context", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)8, "vartype", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)9, "source", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)10, "min_val", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)11, "max_val", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)12, "enumvals", TEXTARRAYOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)13, "boot_val", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)14, "reset_val", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)15, "sourcefile", TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber)16, "sourceline", INT4OID, -1, 0);
/*
* Generate attribute metadata needed later to produce tuples from raw
* C strings
*/
attinmeta = TupleDescGetAttInMetadata(tupdesc);
funcctx->attinmeta = attinmeta;
/* total number of tuples to be returned */
funcctx->max_calls = GetNumConfigOptions();
MemoryContextSwitchTo(oldcontext);
}
/* stuff done on every call of the function */
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
attinmeta = funcctx->attinmeta;
if (call_cntr < max_calls) { /* do when there is more left to send */
char* values[NUM_PG_SETTINGS_ATTS];
bool noshow = false;
HeapTuple tuple;
Datum result;
/*
* Get the next visible GUC variable name and value
*/
do {
GetConfigOptionByNum(call_cntr, (const char**)values, &noshow);
if (noshow) {
/* bump the counter and get the next config setting */
call_cntr = ++funcctx->call_cntr;
/* make sure we haven't gone too far now */
if (call_cntr >= max_calls) {
SRF_RETURN_DONE(funcctx);
}
}
} while (noshow);
/* build a tuple */
tuple = BuildTupleFromCStrings(attinmeta, values);
/* make the tuple into a datum */
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
} else {
/* do when there is no more left */
SRF_RETURN_DONE(funcctx);
}
}
static char* _show_option(struct config_generic* record, bool use_units)
{
char buffer[256];
const char* val = NULL;
int rc = 0;
switch (record->vartype) {
case PGC_BOOL: {
struct config_bool* conf = (struct config_bool*)record;
if (conf->show_hook) {
val = (*conf->show_hook)();
} else {
val = *conf->variable ? "on" : "off";
}
} break;
case PGC_INT: {
struct config_int* conf = (struct config_int*)record;
if (conf->show_hook) {
val = (*conf->show_hook)();
} else {
/*
* Use int64 arithmetic to avoid overflows in units
* conversion.
*/
int64 result = *conf->variable;
const char* unit = NULL;
if (use_units && result > 0 && (record->flags & GUC_UNIT_MEMORY)) {
switch (record->flags & GUC_UNIT_MEMORY) {
case GUC_UNIT_BLOCKS:
result *= BLCKSZ / 1024;
break;
case GUC_UNIT_XBLOCKS:
result *= XLOG_BLCKSZ / 1024;
break;
default:
break;
}
if (result % KB_PER_GB == 0) {
result /= KB_PER_GB;
unit = "GB";
} else if (result % KB_PER_MB == 0) {
result /= KB_PER_MB;
unit = "MB";
} else {
unit = "kB";
}
} else if (use_units && result > 0 && (record->flags & GUC_UNIT_TIME)) {
switch (record->flags & GUC_UNIT_TIME) {
case GUC_UNIT_S:
result *= MS_PER_S;
break;
case GUC_UNIT_MIN:
result *= MS_PER_MIN;
break;
case GUC_UNIT_HOUR:
result *= MS_PER_H;
break;
default:
break;
}
if (result % MS_PER_D == 0) {
result /= MS_PER_D;
unit = "d";
} else if (result % MS_PER_H == 0) {
result /= MS_PER_H;
unit = "h";
} else if (result % MS_PER_MIN == 0) {
result /= MS_PER_MIN;
unit = "min";
} else if (result % MS_PER_S == 0) {
result /= MS_PER_S;
unit = "s";
} else {
unit = "ms";
}
} else {
unit = "";
}
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, INT64_FORMAT "%s", result, unit);
securec_check_ss(rc, "\0", "\0");
val = buffer;
}
} break;
case PGC_INT64: {
struct config_int64* conf = (struct config_int64*)record;
if (conf->show_hook) {
val = (*conf->show_hook)();
} else {
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, INT64_FORMAT, *conf->variable);
securec_check_ss(rc, "\0", "\0");
val = buffer;
}
} break;
case PGC_REAL: {
struct config_real* conf = (struct config_real*)record;
if (conf->show_hook) {
val = (*conf->show_hook)();
} else {
rc = snprintf_s(buffer, sizeof(buffer), sizeof(buffer) - 1, "%g", *conf->variable);
securec_check_ss(rc, "\0", "\0");
val = buffer;
}
} break;
case PGC_STRING: {
struct config_string* conf = (struct config_string*)record;
if (conf->show_hook) {
val = (*conf->show_hook)();
} else if (*conf->variable && **conf->variable) {
val = *conf->variable;
} else {
val = "";
}
} break;
case PGC_ENUM: {
struct config_enum* conf = (struct config_enum*)record;
if (conf->show_hook) {
val = (*conf->show_hook)();
} else {
val = config_enum_lookup_by_value(conf, *conf->variable);
}
} break;
default:
/* just to keep compiler quiet */
val = "???";
break;
}
return pstrdup(val);
}
#ifdef EXEC_BACKEND
inline static void write_fp(FILE* fp, config_generic* gconf, int elevel)
{
if (fwrite(&gconf->sourceline, 1, sizeof(gconf->sourceline), fp) != sizeof(gconf->sourceline)) {
ereport(elevel, (errcode(ERRCODE_FILE_WRITE_FAILED),
errmsg("write nondefault variables's sourceline failed")));
}
if (fwrite(&gconf->source, 1, sizeof(gconf->source), fp) != sizeof(gconf->source)) {
ereport(elevel, (errcode(ERRCODE_FILE_WRITE_FAILED),
errmsg("write nondefault variables's source failed")));
}
if (fwrite(&gconf->scontext, 1, sizeof(gconf->scontext), fp) != sizeof(gconf->scontext)) {
ereport(elevel, (errcode(ERRCODE_FILE_WRITE_FAILED),
errmsg("write nondefault variables's scontext failed")));
}
}
/*
* These routines dump out all non-default GUC options into a binary
* file that is read by all exec'ed backends. The format is:
*
* variable name, string, null terminated
* variable value, string, null terminated
* variable sourcefile, string, null terminated (empty if none)
* variable sourceline, integer
* variable source, integer
* variable scontext, integer
*/
static void write_one_nondefault_variable(FILE* fp, struct config_generic* gconf, int elevel)
{
if (gconf->source == PGC_S_DEFAULT) {
return;
}
fprintf(fp, "%s", gconf->name);
fputc(0, fp);
switch (gconf->vartype) {
case PGC_BOOL: {
struct config_bool* conf = (struct config_bool*)gconf;
if (*conf->variable) {
fprintf(fp, "true");
} else {
fprintf(fp, "false");
}
} break;
case PGC_INT: {
struct config_int* conf = (struct config_int*)gconf;
fprintf(fp, "%d", *conf->variable);
} break;
case PGC_INT64: {
struct config_int64* conf = (struct config_int64*)gconf;
fprintf(fp, INT64_FORMAT, *conf->variable);
} break;
case PGC_REAL: {
struct config_real* conf = (struct config_real*)gconf;
fprintf(fp, "%.17g", *conf->variable);
} break;
case PGC_STRING: {
struct config_string* conf = (struct config_string*)gconf;
fprintf(fp, "%s", *conf->variable);
} break;
case PGC_ENUM: {
struct config_enum* conf = (struct config_enum*)gconf;
fprintf(fp, "%s", config_enum_lookup_by_value(conf, *conf->variable));
} break;
default:
break;
}
fputc(0, fp);
if (gconf->sourcefile) {
fprintf(fp, "%s", gconf->sourcefile);
}
fputc(0, fp);
write_fp(fp, gconf, elevel);
}
void write_nondefault_variables(GucContext context)
{
int elevel;
FILE* fp = NULL;
int i;
AssertEreport(context == PGC_POSTMASTER || context == PGC_SIGHUP, MOD_OPT, "");
elevel = (context == PGC_SIGHUP) ? LOG : ERROR;
/*
* Open file
*/
fp = AllocateFile(CONFIG_EXEC_PARAMS_NEW, "w");
if (fp == NULL) {
ereport(
elevel, (errcode_for_file_access(), errmsg("could not write to file \"%s\": %m", CONFIG_EXEC_PARAMS_NEW)));
return;
}
for (i = 0; i < u_sess->num_guc_variables; i++) {
write_one_nondefault_variable(fp, u_sess->guc_variables[i], elevel);
}
/*
* make sure the content has been flush to disk.
* we need not check if fp == NULL, it has been check before.
*/
fflush(fp);
if (FreeFile(fp)) {
ereport(
elevel, (errcode_for_file_access(), errmsg("could not write to file \"%s\": %m", CONFIG_EXEC_PARAMS_NEW)));
return;
}
/*
* Put new file in place. This could delay on Win32, but we don't hold
* any exclusive locks.
*/
rename(CONFIG_EXEC_PARAMS_NEW, CONFIG_EXEC_PARAMS);
}
/*
* Read string, including null byte from file
*
* Return NULL on EOF and nothing read
*/
static char* read_string_with_null(FILE* fp)
{
int i = 0;
int ch = 0;
int maxlen = 256;
char* str = NULL;
do {
if ((ch = fgetc(fp)) == EOF) {
if (i == 0) {
return NULL;
} else {
ereport(FATAL, (errmsg("invalid format of exec config params file")));
}
}
if (i == 0) {
str = (char*)guc_malloc(FATAL, maxlen);
} else if (i == maxlen) {
str = (char*)guc_realloc(FATAL, str, maxlen *= 2);
}
str[i++] = ch;
} while (ch != 0);
return str;
}
/*
* This routine loads a previous postmaster dump of its non-default
* settings.
*/
void read_nondefault_variables(void)
{
FILE* fp = NULL;
char *varname = NULL;
char *varvalue = NULL;
char *varsourcefile = NULL;
int varsourceline;
GucSource varsource;
GucContext varscontext;
int retry_times = 0;
do {
/*
* Open file
*/
fp = AllocateFile(CONFIG_EXEC_PARAMS, "r");
if (fp == NULL) {
retry_times++;
}
} while (fp == NULL && retry_times <= 1000);
if (fp == NULL) {
ereport(FATAL, (errcode_for_file_access(), errmsg("could not read from file \"%s\": %m", CONFIG_EXEC_PARAMS)));
return;
}
for (;;) {
struct config_generic* record = NULL;
if ((varname = read_string_with_null(fp)) == NULL) {
break;
}
if ((record = find_option(varname, true, FATAL)) == NULL) {
ereport(FATAL, (errmsg("failed to locate variable \"%s\" in exec config params file", varname)));
}
if ((varvalue = read_string_with_null(fp)) == NULL) {
ereport(FATAL, (errmsg("invalid format of exec config params file")));
}
if ((varsourcefile = read_string_with_null(fp)) == NULL) {
ereport(FATAL, (errmsg("invalid format of exec config params file")));
}
if (fread(&varsourceline, 1, sizeof(varsourceline), fp) != sizeof(varsourceline)) {
ereport(FATAL, (errmsg("invalid format of exec config params file")));
}
if (fread(&varsource, 1, sizeof(varsource), fp) != sizeof(varsource)) {
ereport(FATAL, (errmsg("invalid format of exec config params file")));
}
if (fread(&varscontext, 1, sizeof(varscontext), fp) != sizeof(varscontext)) {
ereport(FATAL, (errmsg("invalid format of exec config params file")));
}
(void)set_config_option(varname, varvalue, varscontext, varsource, GUC_ACTION_SET, true, 0, true);
if (varsourcefile[0]) {
set_config_sourcefile(varname, varsourcefile, varsourceline);
}
pfree(varname);
pfree(varvalue);
pfree(varsourcefile);
}
(void)FreeFile(fp);
// shared_buffers is 32MB for dummyStandby
//
if (dummyStandbyMode) {
g_instance.attr.attr_storage.NBuffers = (int)(32 * 1024 * 1024 / BLCKSZ);
}
}
#endif /* EXEC_BACKEND */
/*
* A little "long argument" simulation, although not quite GNU
* compliant. Takes a string of the form "some-option=some value" and
* returns name = "some_option" and value = "some value" in malloc'ed
* storage. Note that '-' is converted to '_' in the option name. If
* there is no '=' in the input string then value will be NULL.
*/
void ParseLongOption(const char* string, char** name, char** value)
{
size_t equal_pos;
char* cp = NULL;
AssertArg(string);
AssertArg(name);
AssertArg(value);
equal_pos = strcspn(string, "=");
if (string[equal_pos] == '=') {
*name = (char*)guc_malloc(FATAL, equal_pos + 1);
strlcpy(*name, string, equal_pos + 1);
*value = guc_strdup(FATAL, &string[equal_pos + 1]);
} else {
/* no equal sign in string */
*name = guc_strdup(FATAL, string);
*value = NULL;
}
for (cp = *name; *cp; cp++) {
if (*cp == '-') {
*cp = '_';
}
}
}
/*
* Handle options fetched from pg_db_role_setting.setconfig,
* pg_proc.proconfig, etc. Caller must specify proper context/source/action.
*
* The array parameter must be an array of TEXT (it must not be NULL).
*/
void ProcessGUCArray(ArrayType* array, GucContext context, GucSource source, GucAction action)
{
int i;
Assert(array != NULL);
Assert(ARR_ELEMTYPE(array) == TEXTOID);
Assert(ARR_NDIM(array) == 1);
Assert(ARR_LBOUND(array)[0] == 1);
for (i = 1; i <= ARR_DIMS(array)[0]; i++) {
Datum d;
bool isnull = false;
char* s = NULL;
char* name = NULL;
char* value = NULL;
d = array_ref(array,
1,
&i,
-1 /* varlenarray */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */,
&isnull);
if (isnull != false) {
continue;
}
s = TextDatumGetCString(d);
ParseLongOption(s, &name, &value);
if (value == NULL) {
ereport(
WARNING, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("could not parse setting for parameter \"%s\"", name)));
pfree(name);
continue;
}
(void)set_config_option(name, value, context, source, action, true, 0);
pfree(name);
if (value != NULL) {
selfpfree(value);
}
pfree(s);
}
}
/*
* Add an entry to an option array. The array parameter may be NULL
* to indicate the current table entry is NULL.
*/
ArrayType* GUCArrayAdd(ArrayType* array, const char* name, const char* value)
{
struct config_generic* record = NULL;
Datum datum;
char* newval = NULL;
ArrayType* a = NULL;
AssertEreport(name, MOD_OPT, "");
AssertEreport(value, MOD_OPT, "");
/* test if the option is valid and we're allowed to set it */
(void)validate_option_array_item(name, value, false);
/* normalize name (converts obsolete GUC names to modern spellings) */
record = find_option(name, false, WARNING);
if (record != NULL) {
name = record->name;
}
/* build new item for array */
newval = (char*)palloc(strlen(name) + 1 + strlen(value) + 1);
int rcs = snprintf_s(
newval, strlen(name) + 1 + strlen(value) + 1, strlen(name) + 1 + strlen(value), "%s=%s", name, value);
securec_check_ss(rcs, "\0", "\0");
datum = CStringGetTextDatum(newval);
if (array != NULL) {
int index;
bool isnull = false;
int i;
Assert(ARR_ELEMTYPE(array) == TEXTOID);
Assert(ARR_NDIM(array) == 1);
Assert(ARR_LBOUND(array)[0] == 1);
index = ARR_DIMS(array)[0] + 1; /* add after end */
for (i = 1; i <= ARR_DIMS(array)[0]; i++) {
Datum d;
char* current = NULL;
d = array_ref(array,
1,
&i,
-1 /* varlenarray */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */,
&isnull);
if (isnull) {
continue;
}
current = TextDatumGetCString(d);
/* check for match up through and including '=' */
if (strncmp(current, newval, strlen(name) + 1) == 0) {
index = i;
break;
}
}
a = array_set(array,
1,
&index,
datum,
false,
-1 /* varlena array */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */);
} else {
a = construct_array(&datum, 1, TEXTOID, -1, false, 'i');
}
return a;
}
/*
* Delete an entry from an option array. The array parameter may be NULL
* to indicate the current table entry is NULL. Also, if the return value
* is NULL then a null should be stored.
*/
ArrayType* GUCArrayDelete(ArrayType* array, const char* name)
{
struct config_generic* record = NULL;
ArrayType* newarray = NULL;
int i;
int index;
AssertEreport(name, MOD_OPT, "");
/* test if the option is valid and we're allowed to set it */
(void)validate_option_array_item(name, NULL, false);
/* normalize name (converts obsolete GUC names to modern spellings) */
record = find_option(name, false, WARNING);
if (record != NULL) {
name = record->name;
}
/* if array is currently null, then surely nothing to delete */
if (array == NULL) {
return NULL;
}
newarray = NULL;
index = 1;
for (i = 1; i <= ARR_DIMS(array)[0]; i++) {
Datum d;
char* val = NULL;
bool isnull = false;
d = array_ref(array,
1,
&i,
-1 /* varlenarray */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */,
&isnull);
if (isnull) {
continue;
}
val = TextDatumGetCString(d);
/* ignore entry if it's what we want to delete */
if (strncmp(val, name, strlen(name)) == 0 && val[strlen(name)] == '=') {
continue;
}
/* else add it to the output array */
if (newarray != NULL) {
newarray = array_set(newarray,
1,
&index,
d,
false,
-1 /* varlenarray */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */);
} else {
newarray = construct_array(&d, 1, TEXTOID, -1, false, 'i');
}
index++;
}
return newarray;
}
/*
* Given a GUC array, delete all settings from it that our permission
* level allows: if superuser, delete them all; if regular user, only
* those that are PGC_USERSET
*/
ArrayType* GUCArrayReset(ArrayType* array)
{
ArrayType* newarray = NULL;
int i;
int index;
/* if array is currently null, nothing to do */
if (array == NULL) {
return NULL;
}
/* if we're superuser, we can delete everything, so just do it */
if (superuser()) {
return NULL;
}
for (i = 1, index = 1; i <= ARR_DIMS(array)[0]; i++) {
Datum d;
char* val = NULL;
char* eqsgn = NULL;
bool isnull = false;
d = array_ref(array,
1,
&i,
-1 /* varlenarray */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */,
&isnull);
if (isnull) {
continue;
}
val = TextDatumGetCString(d);
eqsgn = strchr(val, '=');
if (eqsgn != NULL) {
*eqsgn = '\0';
}
/* skip if we have permission to delete it */
if (validate_option_array_item(val, NULL, true)) {
continue;
}
/* else add it to the output array */
if (newarray != NULL) {
newarray = array_set(newarray,
1,
&index,
d,
false,
-1 /* varlenarray */,
-1 /* TEXT's typlen */,
false /* TEXT's typbyval */,
'i' /* TEXT's typalign */);
} else {
newarray = construct_array(&d, 1, TEXTOID, -1, false, 'i');
}
index++;
pfree(val);
}
return newarray;
}
/*
* Validate a proposed option setting for GUCArrayAdd/Delete/Reset.
*
* name is the option name. value is the proposed value for the Add case,
* or NULL for the Delete/Reset cases. If skip_if_no_permissions is true, it's
* not an error to have no permissions to set the option.
*
* Returns TRUE if OK, FALSE if skip_if_no_permissions is true and user does not
* have permission to change this option (all other error cases result in an
* error being thrown).
*/
static bool validate_option_array_item(const char* name, const char* value, bool skip_if_no_permissions)
{
struct config_generic* gconf = NULL;
/*
* There are three cases to consider:
*
* name is a known GUC variable. Check the value normally, check
* permissions normally (ie, allow if variable is USERSET, or if it's
* SUSET and user is superuser).
*
* name is not known, but exists or can be created as a placeholder (i.e.,
* it has a prefixed name). We allow this case if you're a superuser,
* otherwise not. Superusers are assumed to know what they're doing. We
* can't allow it for other users, because when the placeholder is
* resolved it might turn out to be a SUSET variable;
* define_custom_variable assumes we checked that.
*
* name is not known and can't be created as a placeholder. Throw error,
* unless skip_if_no_permissions is true, in which case return FALSE.
*/
gconf = find_option(name, true, WARNING);
if (gconf == NULL) {
/* not known, failed to make a placeholder */
if (skip_if_no_permissions) {
return false;
}
ereport(
ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("unrecognized configuration parameter \"%s\"", name)));
}
if (gconf->flags & GUC_CUSTOM_PLACEHOLDER) {
/*
* We cannot do any meaningful check on the value, so only permissions
* are useful to check.
*/
if (superuser()){
return true;
}
if (skip_if_no_permissions) {
return false;
}
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied to set parameter \"%s\"", name)));
}
/* manual permissions check so we can avoid an error being thrown */
if (gconf->context == PGC_USERSET) {
/* ok */
;
} else if (gconf->context == PGC_SUSET && superuser()) {
/* ok */
;
} else if (skip_if_no_permissions) {
return false;
}
/* if a permissions error should be thrown, let set_config_option do it */
/* test for permissions and valid option value */
(void)set_config_option(name, value, superuser() ? PGC_SUSET : PGC_USERSET, PGC_S_TEST, GUC_ACTION_SET, false, 0);
return true;
}
/*
* Called by check_hooks that want to override the normal
* ERRCODE_INVALID_PARAMETER_VALUE SQLSTATE for check hook failures.
*
* Note that GUC_check_errmsg() etc are just macros that result in a direct
* assignment to the associated variables. That is ugly, but forced by the
* limitations of C's macro mechanisms.
*/
void GUC_check_errcode(int sqlerrcode)
{
u_sess->utils_cxt.GUC_check_errcode_value = sqlerrcode;
}
/*
* Convenience functions to manage calling a variable's check_hook.
* These mostly take care of the protocol for letting check hooks supply
* portions of the error report on failure.
*/
static bool call_bool_check_hook(struct config_bool* conf, bool* newval, void** extra, GucSource source, int elevel)
{
/* Quick success if no hook */
if (!conf->check_hook) {
return true;
}
/* Reset variables that might be set by hook */
u_sess->utils_cxt.GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
u_sess->utils_cxt.GUC_check_errmsg_string = NULL;
u_sess->utils_cxt.GUC_check_errdetail_string = NULL;
u_sess->utils_cxt.GUC_check_errhint_string = NULL;
if (!(*conf->check_hook)(newval, extra, source)) {
ereport(elevel,
(errcode(u_sess->utils_cxt.GUC_check_errcode_value),
errmodule(MOD_GUC),
u_sess->utils_cxt.GUC_check_errmsg_string
? errmsg_internal("%s", u_sess->utils_cxt.GUC_check_errmsg_string)
: errmsg("invalid value for parameter \"%s\": %d", conf->gen.name, (int)*newval),
u_sess->utils_cxt.GUC_check_errdetail_string
? errdetail_internal("%s", u_sess->utils_cxt.GUC_check_errdetail_string)
: 0,
u_sess->utils_cxt.GUC_check_errhint_string
? errhint("%s", u_sess->utils_cxt.GUC_check_errhint_string)
: 0));
/* Flush any strings created in ErrorContext */
FlushErrorState();
return false;
}
return true;
}
static bool call_int_check_hook(struct config_int* conf, int* newval, void** extra, GucSource source, int elevel)
{
/* Quick success if no hook */
if (!conf->check_hook) {
return true;
}
/* Reset variables that might be set by hook */
u_sess->utils_cxt.GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
u_sess->utils_cxt.GUC_check_errmsg_string = NULL;
u_sess->utils_cxt.GUC_check_errdetail_string = NULL;
u_sess->utils_cxt.GUC_check_errhint_string = NULL;
if (!(*conf->check_hook)(newval, extra, source)) {
ereport(elevel,
(errcode(u_sess->utils_cxt.GUC_check_errcode_value),
errmodule(MOD_GUC),
u_sess->utils_cxt.GUC_check_errmsg_string
? errmsg_internal("%s", u_sess->utils_cxt.GUC_check_errmsg_string)
: errmsg("invalid value for parameter \"%s\": %d", conf->gen.name, *newval),
u_sess->utils_cxt.GUC_check_errdetail_string
? errdetail_internal("%s", u_sess->utils_cxt.GUC_check_errdetail_string)
: 0,
u_sess->utils_cxt.GUC_check_errhint_string
? errhint("%s", u_sess->utils_cxt.GUC_check_errhint_string)
: 0));
/* Flush any strings created in ErrorContext */
FlushErrorState();
return false;
}
return true;
}
static bool call_int64_check_hook(struct config_int64* conf, int64* newval, void** extra, GucSource source, int elevel)
{
/* Quick success if no hook */
if (!conf->check_hook) {
return true;
}
/* Reset variables that might be set by hook */
u_sess->utils_cxt.GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
u_sess->utils_cxt.GUC_check_errmsg_string = NULL;
u_sess->utils_cxt.GUC_check_errdetail_string = NULL;
u_sess->utils_cxt.GUC_check_errhint_string = NULL;
if (!(*conf->check_hook)(newval, extra, source)) {
ereport(elevel,
(errcode(u_sess->utils_cxt.GUC_check_errcode_value),
u_sess->utils_cxt.GUC_check_errmsg_string
? errmsg_internal("%s", u_sess->utils_cxt.GUC_check_errmsg_string)
: errmsg("invalid value for parameter \"%s\": " INT64_FORMAT, conf->gen.name, *newval),
u_sess->utils_cxt.GUC_check_errdetail_string
? errdetail_internal("%s", u_sess->utils_cxt.GUC_check_errdetail_string)
: 0,
u_sess->utils_cxt.GUC_check_errhint_string
? errhint("%s", u_sess->utils_cxt.GUC_check_errhint_string)
: 0));
/* Flush any strings created in ErrorContext */
FlushErrorState();
return false;
}
return true;
}
static bool call_real_check_hook(struct config_real* conf, double* newval, void** extra, GucSource source, int elevel)
{
/* Quick success if no hook */
if (!conf->check_hook) {
return true;
}
/* Reset variables that might be set by hook */
u_sess->utils_cxt.GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
u_sess->utils_cxt.GUC_check_errmsg_string = NULL;
u_sess->utils_cxt.GUC_check_errdetail_string = NULL;
u_sess->utils_cxt.GUC_check_errhint_string = NULL;
if (!(*conf->check_hook)(newval, extra, source)) {
ereport(elevel,
(errcode(u_sess->utils_cxt.GUC_check_errcode_value),
errmodule(MOD_GUC),
u_sess->utils_cxt.GUC_check_errmsg_string
? errmsg_internal("%s", u_sess->utils_cxt.GUC_check_errmsg_string)
: errmsg("invalid value for parameter \"%s\": %g", conf->gen.name, *newval),
u_sess->utils_cxt.GUC_check_errdetail_string
? errdetail_internal("%s", u_sess->utils_cxt.GUC_check_errdetail_string)
: 0,
u_sess->utils_cxt.GUC_check_errhint_string
? errhint("%s", u_sess->utils_cxt.GUC_check_errhint_string)
: 0));
/* Flush any strings created in ErrorContext */
FlushErrorState();
return false;
}
return true;
}
static bool call_string_check_hook(
struct config_string* conf, char** newval, void** extra, GucSource source, int elevel)
{
/* Quick success if no hook */
if (!conf->check_hook) {
return true;
}
/* Reset variables that might be set by hook */
u_sess->utils_cxt.GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
u_sess->utils_cxt.GUC_check_errmsg_string = NULL;
u_sess->utils_cxt.GUC_check_errdetail_string = NULL;
u_sess->utils_cxt.GUC_check_errhint_string = NULL;
if (!(*conf->check_hook)(newval, extra, source)) {
ereport(elevel,
(errcode(u_sess->utils_cxt.GUC_check_errcode_value),
errmodule(MOD_GUC),
u_sess->utils_cxt.GUC_check_errmsg_string
? errmsg_internal("%s", u_sess->utils_cxt.GUC_check_errmsg_string)
: errmsg("invalid value for parameter \"%s\": \"%s\"", conf->gen.name, *newval ? *newval : ""),
u_sess->utils_cxt.GUC_check_errdetail_string
? errdetail_internal("%s", u_sess->utils_cxt.GUC_check_errdetail_string)
: 0,
u_sess->utils_cxt.GUC_check_errhint_string
? errhint("%s", u_sess->utils_cxt.GUC_check_errhint_string)
: 0));
/* Flush any strings created in ErrorContext */
FlushErrorState();
return false;
}
return true;
}
static bool call_enum_check_hook(struct config_enum* conf, int* newval, void** extra, GucSource source, int elevel)
{
/* Quick success if no hook */
if (!conf->check_hook) {
return true;
}
/* Reset variables that might be set by hook */
u_sess->utils_cxt.GUC_check_errcode_value = ERRCODE_INVALID_PARAMETER_VALUE;
u_sess->utils_cxt.GUC_check_errmsg_string = NULL;
u_sess->utils_cxt.GUC_check_errdetail_string = NULL;
u_sess->utils_cxt.GUC_check_errhint_string = NULL;
if (!(*conf->check_hook)(newval, extra, source)) {
ereport(elevel,
(errcode(u_sess->utils_cxt.GUC_check_errcode_value),
errmodule(MOD_GUC),
u_sess->utils_cxt.GUC_check_errmsg_string
? errmsg_internal("%s", u_sess->utils_cxt.GUC_check_errmsg_string)
: errmsg("invalid value for parameter \"%s\": \"%s\"",
conf->gen.name,
config_enum_lookup_by_value(conf, *newval)),
u_sess->utils_cxt.GUC_check_errdetail_string
? errdetail_internal("%s", u_sess->utils_cxt.GUC_check_errdetail_string)
: 0,
u_sess->utils_cxt.GUC_check_errhint_string
? errhint("%s", u_sess->utils_cxt.GUC_check_errhint_string)
: 0));
/* Flush any strings created in ErrorContext */
FlushErrorState();
return false;
}
return true;
}
/*
* Brief: Check the value of statistics memory can not bigger than 50 percent of max process memory
* Description:
* Notes:
*/
static bool check_statistics_memory_limit(int* newval, void** extra, GucSource source)
{
if (*newval * 2 > g_instance.attr.attr_memory.max_process_memory) {
GUC_check_errdetail("\"session_statistics_memory\" cannot be greater 50 percent \"max_process_memory\". "
"max_process_memory is %dkB",
g_instance.attr.attr_memory.max_process_memory);
ereport(WARNING,
(errmsg("\"session_history_memory\" cannot be greater 50 percent \"max_process_memory\". "
"max_process_memory is %dkB",
g_instance.attr.attr_memory.max_process_memory)));
return false;
}
return true;
}
/*
* Brief: Check the value of history memory can not bigger than 50 percent of max process memory
* Description:
* Notes:
*/
static bool check_history_memory_limit(int* newval, void** extra, GucSource source)
{
if (*newval * 2 > g_instance.attr.attr_memory.max_process_memory) {
ereport(WARNING,
(errmsg("\"session_history_memory\" cannot be greater 50 percent \"max_process_memory\". "
"max_process_memory is %dkB",
g_instance.attr.attr_memory.max_process_memory)));
GUC_check_errdetail("\"session_history_memory\" cannot be greater 50 percent \"max_process_memory\". "
"max_process_memory is %dkB",
g_instance.attr.attr_memory.max_process_memory);
return false;
}
return true;
}
/*
* Brief: assignthe value of statistics memory to g_statManager.max_collectinfo_num
* Description:
* Notes:
*/
static void assign_statistics_memory(int newval, void* extra)
{
if (currentGucContext == PGC_SIGHUP) {
u_sess->attr.attr_resource.session_statistics_memory = newval;
if (IS_PGXC_COORDINATOR) {
g_instance.wlm_cxt->stat_manager.max_collectinfo_num = newval * 1024 / sizeof(WLMDNodeInfo);
}
if (IS_PGXC_DATANODE) {
g_instance.wlm_cxt->stat_manager.max_collectinfo_num = newval * 1024 / sizeof(WLMDNRealTimeInfoDetail);
}
g_instance.wlm_cxt->stat_manager.max_iostatinfo_num = newval * 1024 / sizeof(WLMDNodeInfo);
}
}
/*
* Brief: assignthe value of history memory to g_statManager.max_detail_num
* Description:
* Notes:
*/
static void assign_history_memory(int newval, void* extra)
{
if (currentGucContext == PGC_SIGHUP) {
u_sess->attr.attr_resource.session_history_memory = newval;
g_instance.wlm_cxt->stat_manager.max_detail_num = newval * 1024 / sizeof(WLMStmtDetail);
}
}
/*
* check_hook, assign_hook and show_hook subroutines
*/
static bool check_log_destination(char** newval, void** extra, GucSource source)
{
char* rawstring = NULL;
List* elemlist = NIL;
ListCell* l = NULL;
unsigned int newlogdest = 0;
unsigned int* myextra = NULL;
/* Need a modifiable copy of string */
rawstring = pstrdup(*newval);
/* Parse string into list of identifiers */
if (!SplitIdentifierString(rawstring, ',', &elemlist)) {
/* syntax error in list */
GUC_check_errdetail("List syntax is invalid.");
pfree(rawstring);
list_free(elemlist);
return false;
}
foreach (l, elemlist) {
char* tok = (char*)lfirst(l);
if (pg_strcasecmp(tok, "stderr") == 0) {
newlogdest |= LOG_DESTINATION_STDERR;
} else if (pg_strcasecmp(tok, "csvlog") == 0) {
newlogdest |= LOG_DESTINATION_CSVLOG;
}
#ifdef HAVE_SYSLOG
else if (pg_strcasecmp(tok, "syslog") == 0) {
newlogdest |= LOG_DESTINATION_SYSLOG;
}
#endif
#ifdef WIN32
else if (pg_strcasecmp(tok, "eventlog") == 0) {
newlogdest |= LOG_DESTINATION_EVENTLOG;
}
#endif
else {
GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
pfree(rawstring);
list_free(elemlist);
return false;
}
}
pfree(rawstring);
list_free(elemlist);
myextra = (unsigned int*)guc_malloc(ERROR, sizeof(unsigned int));
*myextra = newlogdest;
*extra = (void*)myextra;
return true;
}
static void assign_log_destination(const char* newval, void* extra)
{
t_thrd.log_cxt.Log_destination = *((int*)extra);
}
static void assign_syslog_facility(int newval, void* extra)
{
#ifdef HAVE_SYSLOG
set_syslog_parameters(
u_sess->attr.attr_common.syslog_ident_str ? u_sess->attr.attr_common.syslog_ident_str : "postgres", newval);
#endif
/* Without syslog support, just ignore it */
}
static void assign_syslog_ident(const char* newval, void* extra)
{
#ifdef HAVE_SYSLOG
set_syslog_parameters(newval, u_sess->attr.attr_common.syslog_facility);
#endif
/* Without syslog support, it will always be set to "none", so ignore */
}
static void assign_session_replication_role(int newval, void* extra)
{
/*
* Must flush the plan cache when changing replication role; but don't
* flush unnecessarily.
*/
if (u_sess->attr.attr_common.SessionReplicationRole != newval) {
ResetPlanCache();
}
}
static bool check_client_min_messages(int* newval, void** extra, GucSource source)
{
/*
* We disallow setting client_min_messages above ERROR, because not
* sending an ErrorResponse message for an error breaks the FE/BE
* protocol. However, for backwards compatibility, we still accept FATAL
* or PANIC as input values, and then adjust here.
*/
if (*newval > ERROR) {
*newval = ERROR;
}
return true;
}
static bool check_temp_buffers(int* newval, void** extra, GucSource source)
{
/*
* Once local buffers have been initialized, it's too late to change this.
*/
if (u_sess->storage_cxt.NLocBuffer && u_sess->storage_cxt.NLocBuffer != *newval) {
GUC_check_errdetail(
"\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
return false;
}
return true;
}
static bool check_fencedUDFMemoryLimit(int* newval, void** extra, GucSource source)
{
if (*newval > g_instance.attr.attr_sql.UDFWorkerMemHardLimit) {
GUC_check_errdetail("\"FencedUDFMemoryLimit\" cannot be greater than \"UDFWorkerMemHardLimit\".");
return false;
}
return true;
}
static bool check_udf_memory_limit(int* newval, void** extra, GucSource source)
{
if (*newval > g_instance.attr.attr_memory.max_process_memory) {
GUC_check_errdetail(
"\"udf_memory_limit\" cannot be greater than \"max_process_memory\". max_process_memory is %dkB",
g_instance.attr.attr_memory.max_process_memory);
return false;
}
return true;
}
static bool check_phony_autocommit(bool* newval, void** extra, GucSource source)
{
if (!*newval) {
GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
GUC_check_errmsg("SET AUTOCOMMIT TO OFF is no longer supported");
return false;
}
return true;
}
static bool check_debug_assertions(bool* newval, void** extra, GucSource source)
{
#ifndef USE_ASSERT_CHECKING
if (*newval) {
GUC_check_errmsg("assertion checking is not supported by this build");
return false;
}
#endif
return true;
}
#ifdef USE_BONJOUR
static bool check_bonjour(bool* newval, void** extra, GucSource source)
{
// if not supported bonjour, must report error
if (*newval) {
GUC_check_errmsg("Bonjour is not supported by this build");
return false;
}
return true;
}
#endif
static bool check_ssl(bool* newval, void** extra, GucSource source)
{
#ifndef USE_SSL
if (*newval) {
GUC_check_errmsg("SSL is not supported by this build");
return false;
}
#endif
return true;
}
static bool check_stage_log_stats(bool* newval, void** extra, GucSource source)
{
if (*newval && u_sess->attr.attr_common.log_statement_stats) {
GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
return false;
}
return true;
}
static bool check_log_stats(bool* newval, void** extra, GucSource source)
{
if (*newval && (u_sess->attr.attr_common.log_parser_stats || u_sess->attr.attr_common.log_planner_stats ||
u_sess->attr.attr_common.log_executor_stats)) {
GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
"\"log_parser_stats\", \"log_planner_stats\", "
"or \"log_executor_stats\" is true.");
return false;
}
return true;
}
#ifdef PGXC
/*
* Only a warning is printed to log.
* Returning false will cause FATAL error and it will not be good.
*/
static bool check_pgxc_maintenance_mode(bool* newval, void** extra, GucSource source)
{
switch (source) {
case PGC_S_DYNAMIC_DEFAULT:
case PGC_S_ENV_VAR:
case PGC_S_ARGV:
GUC_check_errmsg("pgxc_maintenance_mode is not allowed here.");
return false;
case PGC_S_FILE:
ereport(WARNING,
(errmsg("pgxc_maintenance_mode is not allowed in postgresql.conf. Set to default (false).")));
*newval = false;
return true;
case PGC_S_DATABASE:
case PGC_S_USER:
case PGC_S_DATABASE_USER:
case PGC_S_INTERACTIVE:
case PGC_S_TEST:
ereport(WARNING, (errmsg("pgxc_maintenance_mode is not allowed here. Set to default (false).")));
*newval = false;
return true;
case PGC_S_DEFAULT:
case PGC_S_CLIENT:
case PGC_S_SESSION:
return true;
default:
GUC_check_errmsg("Unknown source");
return false;
}
}
#ifdef ENABLE_MULTIPLE_NODES
static bool check_enable_gtm_free(bool* newval, void** extra, GucSource source)
{ /* Always gtm free for any version when it is single database */
if (IS_SINGLE_NODE) {
*newval = true;
} else {
/* check our gaussdb version num */
if (is_feature_disabled(GTM_FREE)) {
*newval = false;
}
}
return true;
}
#endif
static bool check_enable_data_replicate(bool* newval, void** extra, GucSource source)
{
/* Always disable data replication in multi standbys mode */
if (IS_DN_MULTI_STANDYS_MODE()) {
*newval = false;
}
return true;
}
/*
* Check if the kernel version greater than suse sp2 (3.0.13)
* Only a warning is printed to log.
* Returning false will cause FATAL error and it will not be good.
*/
static bool check_sctp_support(bool* newval, void** extra, GucSource source)
{
if (*newval == false) {
GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
GUC_check_errmsg("SET COMM_TCP_MODE TO OFF is no longer supported");
*newval = true;
}
return true;
}
#endif
#ifdef ENABLE_MULTIPLE_NODES
static bool check_cn_dn_logic_support(bool* newval, void** extra, GucSource source)
{
if (*newval == true) {
GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
GUC_check_errmsg("SET COMM_CN_DN_LOGIC_CONN TO ON is no longer supported");
*newval = false;
}
return true;
}
#endif
static bool check_canonical_path(char** newval, void** extra, GucSource source)
{
/*
* Since canonicalize_path never enlarges the string, we can just modify
* newval in-place. But watch out for NULL, which is the default value
* for external_pid_file.
*/
if (*newval) {
canonicalize_path(*newval);
}
return true;
}
static bool check_perf_filename(char** newval)
{
char* tmp_string = NULL;
tmp_string = pstrdup(*newval);
bool result = false;
int len = strlen(tmp_string);
if (len > 4 && strcmp(tmp_string + len - 4, ".csv") == 0) {
result = true;
} else {
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("explain_dna_file should be .csv file.")));
}
u_sess->attr.attr_sql.guc_explain_perf_mode = EXPLAIN_RUN;
pfree(tmp_string);
return result;
}
static bool check_perf_log(char** newval, void** extra, GucSource source)
{
bool result = false;
if (*newval == NULL) {
return true;
}
if (is_absolute_path(*newval) == false) {
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("explain_dna_file should be absolute path + .csv file.")));
}
result = check_canonical_path(newval, extra, source);
if (result) {
return check_perf_filename(newval);
} else {
return false;
}
}
static bool check_timezone_abbreviations(char** newval, void** extra, GucSource source)
{
/*
* The boot_val given above for timezone_abbreviations is NULL. When we
* see this we just do nothing. If this value isn't overridden from the
* config file then pg_timezone_abbrev_initialize() will eventually
* replace it with "Default". This hack has two purposes: to avoid
* wasting cycles loading values that might soon be overridden from the
* config file, and to avoid trying to read the timezone abbrev files
* during InitializeGUCOptions(). The latter doesn't work in an
* EXEC_BACKEND subprocess because my_exec_path hasn't been set yet and so
* we can't locate PGSHAREDIR.
*/
if (*newval == NULL) {
Assert(source == PGC_S_DEFAULT);
return true;
}
/* OK, load the file and produce a malloc'd TimeZoneAbbrevTable */
*extra = load_tzoffsets(*newval);
/* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
if (!*extra) {
return false;
}
return true;
}
static void assign_comm_debug_mode(bool newval, void* extra)
{
gs_set_debug_mode(newval);
return;
}
static void assign_comm_stat_mode(bool newval, void* extra)
{
gs_set_stat_mode(newval);
return;
}
static void assign_comm_timer_mode(bool newval, void* extra)
{
gs_set_timer_mode(newval);
return;
}
static void assign_comm_no_delay(bool newval, void* extra)
{
gs_set_no_delay(newval);
return;
}
#ifdef LIBCOMM_SPEED_TEST_ENABLE
static void assign_comm_test_thread_num(int newval, void* extra)
{
gs_set_test_thread_num(newval);
return;
}
static void assign_comm_test_msg_len(int newval, void* extra)
{
gs_set_test_msg_len(newval);
return;
}
static void assign_comm_test_send_sleep(int newval, void* extra)
{
gs_set_test_send_sleep(newval);
return;
}
static void assign_comm_test_send_once(int newval, void* extra)
{
gs_set_test_send_once(newval);
return;
}
static void assign_comm_test_recv_sleep(int newval, void* extra)
{
gs_set_test_recv_sleep(newval);
return;
}
static void assign_comm_test_recv_once(int newval, void* extra)
{
gs_set_test_recv_once(newval);
return;
}
#endif
#ifdef ENABLE_MULTIPLE_NODES
static void comm_change_datanode(int newval, void* extra)
{
// newval is the number of DN.
// MaxCoords is CN=16.
gs_change_capacity(newval + g_instance.attr.attr_network.MaxCoords);
return;
}
static void comm_change_coordnode(int newval, void* extra)
{
// newval is the number of DN.
// MaxCoords is CN=16.
gs_change_capacity(newval + u_sess->attr.attr_network.comm_max_datanode);
return;
}
static bool check_max_datanode(int* newval, void** extra, GucSource source)
{
if (*newval + g_instance.attr.attr_network.MaxCoords > MAX_CN_DN_NODE_NUM) {
ereport(LOG,
(errmsg("PGXC can't support comm_max_datanode more than %d.",
MAX_CN_DN_NODE_NUM - g_instance.attr.attr_network.MaxCoords)));
return false;
}
return true;
}
static bool check_max_coordnode(int* newval, void** extra, GucSource source)
{
if (*newval + u_sess->attr.attr_network.comm_max_datanode > MAX_CN_DN_NODE_NUM) {
ereport(LOG,
(errmsg("PGXC can't support max_coordinators more than %d.",
MAX_CN_DN_NODE_NUM - u_sess->attr.attr_network.comm_max_datanode)));
return false;
}
return true;
}
static const char* show_max_datanode(void)
{
char nbuf[16];
int rcs = snprintf_s(
nbuf, sizeof(nbuf), sizeof(nbuf) - 1, "%d", gs_get_cur_node() - g_instance.attr.attr_network.MaxCoords);
securec_check_ss(rcs, "\0", "\0");
return pstrdup(nbuf);
}
static const char* show_max_coordnode(void)
{
char nbuf[16];
int rcs = snprintf_s(nbuf, sizeof(nbuf), sizeof(nbuf) - 1, "%d", g_instance.attr.attr_network.MaxCoords);
securec_check_ss(rcs, "\0", "\0");
return pstrdup(nbuf);
}
#endif
#ifdef LIBCOMM_FAULT_INJECTION_ENABLE
static void assign_comm_fault_injection(int newval, void* extra)
{
gs_set_fault_injection(newval);
return;
}
#endif
static void assign_comm_ackchk_time(int newval, void* extra)
{
gs_set_ackchk_time(newval);
}
#ifdef ENABLE_MULTIPLE_NODES
void assign_enable_cgroup_switch(bool newval, void* extra)
{
if (currentGucContext == PGC_SUSET || currentGucContext == PGC_USERSET) {
u_sess->wlm_cxt->cgroup_state = CG_USERSET;
u_sess->attr.attr_resource.enable_cgroup_switch = newval;
}
}
#endif
static const char* show_enable_memory_limit(void)
{
char* buf = t_thrd.buf_cxt.show_enable_memory_limit_buf;
int size = sizeof(t_thrd.buf_cxt.show_enable_memory_limit_buf);
int rcs;
if (t_thrd.utils_cxt.gs_mp_inited) {
rcs = snprintf_s(buf, size, size - 1, "%s", "on");
securec_check_ss(rcs, "\0", "\0");
} else {
rcs = snprintf_s(buf, size, size - 1, "%s", "off");
securec_check_ss(rcs, "\0", "\0");
}
return buf;
}
#ifdef ENABLE_MULTIPLE_NODES
static const char* show_enable_dynamic_workload(void)
{
char* buf = t_thrd.buf_cxt.show_enable_dynamic_workload_buf;
int size = sizeof(t_thrd.buf_cxt.show_enable_dynamic_workload_buf);
if (g_instance.wlm_cxt->dynamic_workload_inited != false) {
int rcs = snprintf_s(buf, size, size - 1, "%s", "on");
securec_check_ss(rcs, "\0", "\0");
} else {
int rcs = snprintf_s(buf, size, size - 1, "%s", "off");
securec_check_ss(rcs, "\0", "\0");
}
return buf;
}
#endif
static bool check_use_workload_manager(bool* newval, void** extra, GucSource source)
{
/* disable WLM during inplace upgrade */
if (u_sess->attr.attr_common.upgrade_mode == 1) {
*newval = false;
}
return true;
}
static void assign_use_workload_manager(const bool newval, void* extra)
{
if (t_thrd.proc_cxt.MyProcPid != PostmasterPid) {
return;
}
g_instance.wlm_cxt->gscgroup_init_done =
newval && u_sess->attr.attr_resource.enable_control_group && g_instance.wlm_cxt->gscgroup_config_parsed;
}
static void assign_timezone_abbreviations(const char* newval, void* extra)
{
/* Do nothing for the boot_val default of NULL */
if (extra == NULL) {
return;
}
InstallTimeZoneAbbrevs((TimeZoneAbbrevTable*)extra);
}
/*
* pg_timezone_abbrev_initialize --- set default value if not done already
*
* This is called after initial loading of postgresql.conf. If no
* timezone_abbreviations setting was found therein, select default.
* If a non-default value is already installed, nothing will happen.
*
* This can also be called from ProcessConfigFile to establish the default
* value after a postgresql.conf entry for it is removed.
*/
static void pg_timezone_abbrev_initialize(void)
{
SetConfigOption("timezone_abbreviations", "Default", PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT);
}
static const char* show_archive_command(void)
{
if (XLogArchivingActive()) {
return u_sess->attr.attr_storage.XLogArchiveCommand;
} else {
return "(disabled)";
}
}
static bool check_maxconnections(int* newval, void** extra, GucSource source)
{
#ifdef PGXC
if (IS_PGXC_COORDINATOR && *newval > MAX_BACKENDS) {
ereport(LOG, (errmsg("PGXC can't support max_connections more than %d.", MAX_BACKENDS)));
return false;
}
#endif
if (*newval + g_instance.attr.attr_storage.autovacuum_max_workers + g_instance.attr.attr_sql.job_queue_processes +
AUXILIARY_BACKENDS + AV_LAUNCHER_PROCS + g_instance.attr.attr_network.maxInnerToolConnections >
MAX_BACKENDS) {
return false;
}
return true;
}
static bool CheckMaxInnerToolConnections(int* newval, void** extra, GucSource source)
{
if (*newval + g_instance.attr.attr_storage.autovacuum_max_workers + g_instance.attr.attr_sql.job_queue_processes +
g_instance.attr.attr_network.MaxConnections + AUXILIARY_BACKENDS + AV_LAUNCHER_PROCS > MAX_BACKENDS) {
return false;
}
return true;
}
static bool check_autovacuum_max_workers(int* newval, void** extra, GucSource source)
{
if (g_instance.attr.attr_network.MaxConnections + *newval + g_instance.attr.attr_sql.job_queue_processes +
AUXILIARY_BACKENDS + AV_LAUNCHER_PROCS + g_instance.attr.attr_network.maxInnerToolConnections >
MAX_BACKENDS) {
return false;
}
return true;
}
/*
* Description: Check wheth out of max backends after max job worker threads.
*
* Parameters:
* @in newval: the param of job_queue_processes.
* Returns: bool
*/
static bool check_job_max_workers(int* newval, void** extra, GucSource source)
{
if (g_instance.attr.attr_network.MaxConnections + g_instance.attr.attr_storage.autovacuum_max_workers + *newval +
AUXILIARY_BACKENDS + AV_LAUNCHER_PROCS + g_instance.attr.attr_network.maxInnerToolConnections >
MAX_BACKENDS) {
return false;
}
return true;
}
static bool check_effective_io_concurrency(int* newval, void** extra, GucSource source)
{
#ifdef USE_PREFETCH
double new_prefetch_pages = 0.0;
int i;
/* ----------
* The user-visible GUC parameter is the number of drives (spindles),
* which we need to translate to a number-of-pages-to-prefetch target.
* The target value is stashed in *extra and then assigned to the actual
* variable by assign_effective_io_concurrency.
*
* The expected number of prefetch pages needed to keep N drives busy is:
*
* drives | I/O requests
* -------+----------------
* 1 | 1
* 2 | 2/1 + 2/2 = 3
* 3 | 3/1 + 3/2 + 3/3 = 5 1/2
* 4 | 4/1 + 4/2 + 4/3 + 4/4 = 8 1/3
* n | n * H(n)
*
* This is called the "coupon collector problem" and H(n) is called the
* harmonic series. This could be approximated by n * ln(n), but for
* reasonable numbers of drives we might as well just compute the series.
*
* Alternatively we could set the target to the number of pages necessary
* so that the expected number of active spindles is some arbitrary
* percentage of the total. This sounds the same but is actually slightly
* different. The result ends up being ln(1-P)/ln((n-1)/n) where P is
* that desired fraction.
*
* Experimental results show that both of these formulas aren't aggressive
* enough, but we don't really have any better proposals.
*
* Note that if *newval = 0 (disabled), we must set target = 0.
* ----------
*/
for (i = 1; i <= *newval; i++) {
new_prefetch_pages += (double)*newval / (double)i;
}
/* This range check shouldn't fail, but let's be paranoid */
if (new_prefetch_pages >= 0.0 && new_prefetch_pages < (double)INT_MAX) {
int* myextra = (int*)guc_malloc(ERROR, sizeof(int));
*myextra = (int)rint(new_prefetch_pages);
*extra = (void*)myextra;
return true;
} else {
return false;
}
#else
return true;
#endif /* USE_PREFETCH */
}
static void assign_effective_io_concurrency(int newval, void* extra)
{
#ifdef USE_PREFETCH
u_sess->storage_cxt.target_prefetch_pages = *((int*)extra);
#endif /* USE_PREFETCH */
}
/*
* @Description: parse the input of u_sess->opt_cxt.query_dop to get the u_sess->opt_cxt.parallel_debug_mode
*
* @param[IN] newval: new value
* @param[IN] extra: N/A
* @param[IN] source: N/A
* @return: true if value is valid
*/
#ifdef ENABLE_MULTIPLE_NODES
static bool parse_query_dop(int* newval, void** extra, GucSource source)
{
int dop_mark = *newval;
#if defined(USE_ASSERT_CHECKING) || defined(FASTCHECK)
if ((dop_mark > 2001) && (dop_mark <= (2000 + MAX_QUERY_DOP))) {
/*
* This mode is for llt, we reduce the parallel threshold to parallelize
* as much plan as possible, and do not print parallel plan so there
* will not be any fail in fastcheck.
*/
u_sess->opt_cxt.smp_thread_cost = 0;
u_sess->opt_cxt.parallel_debug_mode = LLT_MODE;
u_sess->opt_cxt.max_query_dop = -1; /* turn off dynamic smp */
} else if ((dop_mark > 1001) && (dop_mark <= (1000 + MAX_QUERY_DOP))) {
/*
* This mode is for function test, we reduce the parallel threshold
* to parallelize as much plan as possible, and print parallel plan
* so we can analyze the parallel plan.
*/
u_sess->opt_cxt.smp_thread_cost = 0;
u_sess->opt_cxt.parallel_debug_mode = DEBUG_MODE;
u_sess->opt_cxt.max_query_dop = -1; /* turn off dynamic smp */
} else if ((dop_mark > 0) && (dop_mark <= MAX_QUERY_DOP)) {
/*
* This mode is for performance test and release, we enhance the threshold
* to reject low cost parallel groups, so that the performance will not
* desend because of SMP.
*/
u_sess->opt_cxt.smp_thread_cost = DEFAULT_SMP_THREAD_COST;
u_sess->opt_cxt.parallel_debug_mode = DEFAULT_MODE;
u_sess->opt_cxt.max_query_dop = -1; /* turn off dynamic smp */
} else if (dop_mark >= MIN_QUERY_DOP && dop_mark <= 0) {
u_sess->opt_cxt.max_query_dop = abs(dop_mark);
/* turn on debug mode when dynsmp */
u_sess->opt_cxt.smp_thread_cost = 0;
u_sess->opt_cxt.parallel_debug_mode = DEBUG_MODE;
} else {
/* should not reach here */
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("Current degree of parallelism can only be set within [-64,64]")));
}
#else
if (dop_mark >= MIN_QUERY_DOP && dop_mark <= MAX_QUERY_DOP) {
/*
* This mode is for performance test and release, we enhance the threshold
* to reject low cost parallel groups, so that the performance will not
* desend because of SMP.
*/
u_sess->opt_cxt.smp_thread_cost = DEFAULT_SMP_THREAD_COST;
u_sess->opt_cxt.parallel_debug_mode = DEFAULT_MODE;
} else {
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("Current degree of parallelism can only be set within [-64,64]")));
}
#endif
return true;
}
/*
* @Description: assign new value to query_dop.
*
* @param[IN] newval: new value
* @param[IN] extra: N/A
* @return: void
*/
static void AssignQueryDop(int newval, void* extra)
{
if (newval > 0) {
u_sess->opt_cxt.query_dop = newval % 1000;
u_sess->opt_cxt.query_dop_store = u_sess->opt_cxt.query_dop;
u_sess->opt_cxt.max_query_dop = -1; /* turn off dynamic smp */
} else if (newval <= 0) {
if (newval == -1) {
/* -1 means not parallel */
u_sess->opt_cxt.query_dop = 1;
u_sess->opt_cxt.query_dop_store = 1;
} else {
/*
* only set query_dop here to indicate we have
* dop turned on. but later we generate optimal dop
*/
u_sess->opt_cxt.query_dop = 2;
u_sess->opt_cxt.query_dop_store = 2;
}
u_sess->opt_cxt.max_query_dop = abs(newval);
}
}
#endif
static void assign_pgstat_temp_directory(const char* newval, void* extra)
{
/* check_canonical_path already canonicalized newval for us */
char* tname = NULL;
char* fname = NULL;
tname = (char*)guc_malloc(ERROR, strlen(newval) + 12); /* /pgstat.tmp */
int rcs = snprintf_s(tname, strlen(newval) + 12, strlen(newval) + 11, "%s/pgstat.tmp", newval);
securec_check_ss(rcs, "\0", "\0");
fname = (char*)guc_malloc(ERROR, strlen(newval) + 13); /* /pgstat.stat */
rcs = snprintf_s(fname, strlen(newval) + 13, strlen(newval) + 12, "%s/pgstat.stat", newval);
securec_check_ss(rcs, "\0", "\0");
if (u_sess->stat_cxt.pgstat_stat_tmpname) {
pfree(u_sess->stat_cxt.pgstat_stat_tmpname);
}
u_sess->stat_cxt.pgstat_stat_tmpname = tname;
if (u_sess->stat_cxt.pgstat_stat_filename) {
pfree(u_sess->stat_cxt.pgstat_stat_filename);
}
u_sess->stat_cxt.pgstat_stat_filename = fname;
}
static bool check_application_name(char** newval, void** extra, GucSource source)
{
/* Only allow clean ASCII chars in the application name */
char* p = NULL;
for (p = *newval; *p; p++) {
if (*p < 32 || *p > 126) {
*p = '?';
}
}
return true;
}
static void assign_application_name(const char* newval, void* extra)
{
/* Update the pg_stat_activity view */
pgstat_report_appname(newval);
}
static void assign_connection_info(const char* newval, void* extra)
{
/* Update the pg_stat_activity view */
pgstat_report_conninfo(newval);
}
static bool check_cgroup_name(char** newval, void** extra, GucSource source)
{
/* Only allow clean ASCII chars in the control group name */
char* p = NULL;
for (p = *newval; *p; p++) {
if (*p < 32 || *p > 126) {
*p = '?';
}
}
p = *newval;
if (StringIsValid(p) && IS_PGXC_COORDINATOR && t_thrd.shemem_ptr_cxt.MyBEEntry &&
(currentGucContext == PGC_SUSET || currentGucContext == PGC_USERSET)) {
if (g_instance.wlm_cxt->gscgroup_init_done == 0) {
ereport(ERROR,
(errcode(ERRCODE_SYSTEM_ERROR),
errmsg("Failed to initialize Cgroup. "
"Please check if workload manager is enabled "
"and Cgroups have been created!")));
}
if (!OidIsValid(t_thrd.shemem_ptr_cxt.MyBEEntry->st_userid)) {
return true;
}
WLMNodeGroupInfo* ng = WLMGetNodeGroupByUserId(t_thrd.shemem_ptr_cxt.MyBEEntry->st_userid);
if (NULL == ng) {
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("Failed to get logic cluster information by user(oid %d).",
t_thrd.shemem_ptr_cxt.MyBEEntry->st_userid)));
}
if (-1 == gscgroup_check_group_name(ng, p)) {
return false;
}
}
return true;
}
static void assign_cgroup_name(const char* newval, void* extra)
{
/* set "control_group" global variable */
if (IS_PGXC_COORDINATOR && t_thrd.shemem_ptr_cxt.MyBEEntry && newval && *newval) {
if (g_instance.wlm_cxt->gscgroup_init_done == 0) {
return;
}
if (!OidIsValid(t_thrd.shemem_ptr_cxt.MyBEEntry->st_userid)) {
return;
}
if (currentGucContext == PGC_SUSET || currentGucContext == PGC_USERSET) {
WLMNodeGroupInfo* ng = WLMGetNodeGroupByUserId(t_thrd.shemem_ptr_cxt.MyBEEntry->st_userid);
if (NULL == ng) {
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("Failed to get logic cluster information by user(oid %d).",
t_thrd.shemem_ptr_cxt.MyBEEntry->st_userid)));
}
gscgroup_update_hashtbl(ng, u_sess->wlm_cxt->group_keyname);
WLMSetControlGroup(u_sess->wlm_cxt->group_keyname);
}
}
}
static const char* show_cgroup_name(void)
{
return u_sess->wlm_cxt->control_group;
}
static bool check_query_band_name(char** newval, void** extra, GucSource source)
{
/* Only allow clean ASCII chars in the application name */
char* p = NULL;
for (p = *newval; *p; p++) {
if (*p < 32 || *p > 126) {
*p = '?';
}
}
return true;
}
/* function: check_session_respool
* description: check GUC session_respool is invalid or not
* arguments:
* newval: the input string for checking
* extra: the extra information
* source: the GUC Source information
* return value: ture or false
*/
static bool check_session_respool(char** newval, void** extra, GucSource source)
{
/* Only allow clean ASCII chars in the session_respool name */
char* p = NULL;
for (p = *newval; *p; p++) {
if (*p < 32 || *p > 126) {
*p = '?';
}
}
p = *newval;
if (StringIsValid(p) && t_thrd.shemem_ptr_cxt.MyBEEntry &&
(currentGucContext == PGC_SUSET || currentGucContext == PGC_USERSET)) {
WLMCheckSessionRespool(p);
}
return true;
}
/* function: assign_session_respool
* description: to parse the GUC value and assign to the global variable
* arguments: standard GUC arguments
*/
static void assign_session_respool(const char* newval, void* extra)
{
/* set "control_group" global variable */
if (newval && *newval && t_thrd.shemem_ptr_cxt.MyBEEntry &&
(currentGucContext == PGC_SUSET || currentGucContext == PGC_USERSET)) {
WLMSetSessionRespool(newval);
} else {
WLMSetSessionRespool(INVALID_POOL_NAME);
}
}
/* function: show_session_respool
* description: to show session_respool
* arguments:
*/
static const char* show_session_respool(void)
{
return u_sess->wlm_cxt->session_respool;
}
/* function: check_memory_detail_tracking
* description: to verify if the input value is correct.
* arguments:
* newval: the input string for checking
* extra: the extra information
* source: the GUC Source information
* return value: ture of false
*
* Notes: this GUC is only used on DEBUG version;
* the format should be input as "seqnum:plannodeid".
*
*/
static bool check_memory_detail_tracking(char** newval, void** extra, GucSource source)
{
#ifdef MEMORY_CONTEXT_CHECKING
/* Only allow clean ASCII chars in the string of operator memory log */
char *p, *q;
for (p = *newval; *p; p++) {
if (*p < 32 || *p > 126) {
*p = '?';
}
}
p = *newval;
if (p && *p != '\0' && ((q = strchr(p, ':')) == NULL || isdigit(*(q + 1)) == 0)) {
return false;
}
return true;
#else
#ifndef FASTCHECK
char* p = *newval;
if (p && *p != '\0') {
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("unsupported to set memory_detail_tracking value under release version.")));
}
#endif
return true;
#endif
}
/* function: check_u_sess->attr.attr_memory.memory_detail_tracking
* description: to parse the GUC value and assign to the global variable
* arguments: standard GUC arguments
*/
static void assign_memory_detail_tracking(const char* newval, void* extra)
{
#ifdef MEMORY_CONTEXT_CHECKING
MemoryTrackingParseGUC(newval);
#endif
}
/* function: show_memory_detail_tracking
* description: to show the information
* arguments: standard GUC arguments
*/
static const char* show_memory_detail_tracking(void)
{
char* buf = t_thrd.buf_cxt.show_memory_detail_tracking_buf;
#ifdef MEMORY_CONTEXT_CHECKING
int size = sizeof(t_thrd.buf_cxt.show_memory_detail_tracking_buf);
errno_t rc = snprintf_s(buf,
size,
size - 1,
"Memory Context Sequent Count: %d, Plan Nodeid: %d",
t_thrd.utils_cxt.memory_track_sequent_count,
t_thrd.utils_cxt.memory_track_plan_nodeid);
securec_check_ss(rc, "\0", "\0");
#endif
return buf;
}
#ifdef ENABLE_MULTIPLE_NODES
/* function: assign_active_statements
* description: assign active statements
* arguments: standard GUC arguments
*/
static void assign_active_statements(int newval, void* extra)
{
if (currentGucContext == PGC_SIGHUP) {
if (g_instance.wlm_cxt->dynamic_workload_inited) {
dywlm_update_max_statements(newval);
} else {
WLMSetMaxStatements(newval);
}
}
}
/* function: assign_memory_quota
* description: assign dynamic memory quota
* arguments: standard GUC arguments
*/
static void assign_memory_quota(int newval, void* extra)
{
if (currentGucContext == PGC_SIGHUP && AmPostmasterProcess() && g_instance.wlm_cxt->dynamic_workload_inited) {
u_sess->attr.attr_resource.dynamic_memory_quota = newval;
ServerDynamicManager* srvmgr = &g_instance.wlm_cxt->MyDefaultNodeGroup.srvmgr;
int old_freesize_limit = srvmgr->freesize_limit;
gs_lock_test_and_set(&srvmgr->freesize_limit,
srvmgr->totalsize * u_sess->attr.attr_resource.dynamic_memory_quota / FULL_PERCENT);
gs_compare_and_swap_32(&srvmgr->freesize, old_freesize_limit, srvmgr->freesize_limit);
}
}
#endif
/* function: assign_collect_timer
* description: assign collect timer
* arguments: standard GUC arguments
*/
static void assign_collect_timer(int newval, void* extra)
{
#define WLM_COLLECT_INVALID_TIME 5
#define WLM_COLLECT_MIN_TIME 30
if (newval < WLM_COLLECT_INVALID_TIME && u_sess->utils_cxt.guc_new_value) {
*u_sess->utils_cxt.guc_new_value = WLM_COLLECT_MIN_TIME;
}
}
static bool check_statement_mem(int* newval, void** extra, GucSource source)
{
if ((*newval < 0) || (*newval > 0 && *newval < SIMPLE_THRESHOLD)) {
if (source != PGC_S_FILE) {
ereport(WARNING,
(errmsg(
"query mem can not be set lower than %dMB, so the guc variable is not avaiable.", MEM_THRESHOLD)));
}
*newval = 0;
}
return true;
}
static bool check_statement_max_mem(int* newval, void** extra, GucSource source)
{
if ((*newval < 0) || (*newval > 0 && *newval < SIMPLE_THRESHOLD)) {
if (source != PGC_S_FILE) {
ereport(WARNING,
(errmsg("query max mem can not be set lower than %dMB, so the guc variable is not avaiable.",
MEM_THRESHOLD)));
}
*newval = 0;
}
return true;
}
static const char* show_unix_socket_permissions(void)
{
char* buf = t_thrd.buf_cxt.show_unix_socket_permissions_buf;
int size = sizeof(t_thrd.buf_cxt.show_unix_socket_permissions_buf);
int rcs = snprintf_s(buf, size, size - 1, "%04o", g_instance.attr.attr_network.Unix_socket_permissions);
securec_check_ss(rcs, "\0", "\0");
return buf;
}
static const char* show_log_file_mode(void)
{
char* buf = t_thrd.buf_cxt.show_log_file_mode_buf;
int size = sizeof(t_thrd.buf_cxt.show_log_file_mode_buf);
int rcs = snprintf_s(buf, size, size - 1, "%04o", u_sess->attr.attr_common.Log_file_mode);
securec_check_ss(rcs, "\0", "\0");
return buf;
}
/*
* Brief: Check the value of int-type parameter for security
* Description:
* Notes:
*/
static bool check_int_parameter(int* newval, void** extra, GucSource source)
{
if (*newval >= 0) {
return true;
} else {
return false;
}
}
/*
* Brief: Check the value of double-type parameter for security
* Description:
* Notes:
*/
static bool check_double_parameter(double* newval, void** extra, GucSource source)
{
if (*newval >= 0) {
return true;
} else {
return false;
}
}
/*
* Brief: Verify the SET Role and Passwd
* Description: Both SET ROLE and SET ROLE PASSWORD are handled here
* Notes:
*/
static bool verify_setrole_passwd(const char* rolename, char* passwd, bool IsSetRole)
{
TupleDesc pg_authid_dsc;
HeapTuple tuple;
Datum authid_passwd_datum;
bool authid_passwd_is_null = false;
Relation pg_authid_rel;
char* role_passwd = NULL;
bool is_pwd_equal = true;
char encrypted_md5_password[MD5_PASSWD_LEN + 1] = {0};
char encrypted_sha256_password[SHA256_LENGTH + ENCRYPTED_STRING_LENGTH + 1] = {0};
char encrypted_combined_password[MD5_PASSWD_LEN + SHA256_PASSWD_LEN + 1] = {0};
char salt[SALT_LENGTH * 2 + 1] = {0};
TimestampTz last_try_loginT_time;
Datum vbegin_datum;
Datum vuntil_datum;
TimestampTz vbegin = 0;
TimestampTz vuntil = 0;
bool vbegin_null = true;
bool vuntil_null = true;
Oid roleid;
int iteration_count = 0;
errno_t ss_rc = 0;
USER_STATUS rolestatus = UNLOCK_STATUS;
if (passwd == NULL) {
if (IsSetRole) {
ereport(ERROR, (errcode(ERRCODE_INVALID_NAME), errmsg("Invalid username/password,set role denied.")));
} else {
ereport(ERROR,
(errcode(ERRCODE_INVALID_NAME),
errmsg("Invalid username/password,set session_authorization denied.")));
}
}
/* AccessShareLock is enough for SELECT */
pg_authid_rel = heap_open(AuthIdRelationId, AccessShareLock);
pg_authid_dsc = RelationGetDescr(pg_authid_rel);
tuple = SearchSysCache1(AUTHNAME, PointerGetDatum(rolename));
if (!HeapTupleIsValid(tuple)) {
str_reset(passwd);
if (IsSetRole) {
ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("Invalid username/password,set role denied.")));
} else {
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("Invalid username/password,set session_authorization denied.")));
}
}
/* get the role password */
authid_passwd_datum = heap_getattr(tuple, Anum_pg_authid_rolpassword, pg_authid_dsc, &authid_passwd_is_null);
/*
* In default, the role password could not be NULL, except we failed to
* get the attribute.
*/
if (authid_passwd_is_null == false && (void*)authid_passwd_datum != NULL) {
role_passwd = TextDatumGetCString(authid_passwd_datum);
} else {
return false;
}
/* whether the passwd equal to the role_passwd */
if (!isPWDENCRYPTED(passwd)) {
if (isMD5(role_passwd)) {
if (!pg_md5_encrypt(passwd, rolename, strlen(rolename), encrypted_md5_password)) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("md5-password encryption failed")));
return false;
}
if (strncmp(role_passwd, encrypted_md5_password, MD5_PASSWD_LEN + 1) != 0) {
is_pwd_equal = false;
}
} else if (isSHA256(role_passwd)) {
ss_rc = strncpy_s(salt, sizeof(salt), &role_passwd[SHA256_LENGTH], sizeof(salt) - 1);
securec_check(ss_rc, "", "");
salt[sizeof(salt) - 1] = '\0';
iteration_count = decode_iteration(&role_passwd[SHA256_PASSWD_LEN]);
if (!pg_sha256_encrypt(passwd, salt, strlen(salt), encrypted_sha256_password, NULL, iteration_count)) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("sha256-password encryption failed")));
}
if (strncmp(role_passwd, encrypted_sha256_password, ENCRYPTED_STRING_LENGTH + 1) != 0) {
is_pwd_equal = false;
}
} else if (isCOMBINED(role_passwd)) {
errno_t rc = EOK;
rc = strncpy_s(salt, sizeof(salt), &role_passwd[SHA256_LENGTH], sizeof(salt) - 1);
securec_check(rc, "\0", "\0");
salt[sizeof(salt) - 1] = '\0';
iteration_count = decode_iteration(&role_passwd[SHA256_PASSWD_LEN + MD5_PASSWD_LEN]);
if (!pg_sha256_encrypt(passwd, salt, strlen(salt), encrypted_sha256_password, NULL, iteration_count)) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("first stage encryption password failed")));
}
if (!pg_md5_encrypt(passwd, rolename, strlen(rolename), encrypted_md5_password)) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("second stage encryption password failed")));
}
rc = snprintf_s(encrypted_combined_password,
MD5_PASSWD_LEN + SHA256_PASSWD_LEN + 1,
MD5_PASSWD_LEN + SHA256_PASSWD_LEN,
"%s%s",
encrypted_sha256_password,
encrypted_md5_password);
securec_check_ss(rc, "\0", "\0");
if (strncmp(role_passwd, encrypted_sha256_password, ENCRYPTED_STRING_LENGTH + 1) != 0) {
is_pwd_equal = false;
}
} else {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("Invalid password stored")));
}
} else {
if (strcmp(passwd, role_passwd) != 0) {
is_pwd_equal = false;
} else {
ereport(NOTICE,
(errcode(ERRCODE_INVALID_PASSWORD), errmsg("Using encrypted password directly is not recommended.")));
}
}
last_try_loginT_time = GetCurrentTimestamp();
if (!TimestampDifferenceExceeds(u_sess->utils_cxt.lastFailedLoginTime, last_try_loginT_time, MS_PER_S * 1)) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR,
(errcode(ERRCODE_INVALID_OPERATION),
errmsg("you are not allowed to do that operation immediately, please try again later")));
}
/* Currently inner set statement from pooler don't check pwd. */
if (is_pwd_equal == false && !IsConnFromCoord()) {
u_sess->utils_cxt.lastFailedLoginTime = GetCurrentTimestamp();
str_reset(passwd);
str_reset(role_passwd);
if (IsSetRole) {
ereport(ERROR, (errcode(ERRCODE_INVALID_NAME), errmsg("Invalid username/password,set role denied.")));
} else {
ereport(ERROR,
(errcode(ERRCODE_INVALID_NAME), errmsg("Invalid username/password,set session_authorization denied.")));
}
}
/* get the roleid for check lock/unlock. */
roleid = GetRoleOid(rolename);
/* Check whether the role have been locked. */
if (t_thrd.postmaster_cxt.HaShmData->current_mode == STANDBY_MODE) {
rolestatus = GetAccountLockedStatusFromHashTable(roleid);
} else {
rolestatus = GetAccountLockedStatus(roleid);
}
if (rolestatus != UNLOCK_STATUS) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR, (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION), errmsg("The account has been locked.")));
}
/* whether within the validiity of period */
vbegin_datum = heap_getattr(tuple, Anum_pg_authid_rolvalidbegin, pg_authid_dsc, &vbegin_null);
if (!vbegin_null) {
vbegin = DatumGetTimestampTz(vbegin_datum);
}
vuntil_datum = heap_getattr(tuple, Anum_pg_authid_rolvaliduntil, pg_authid_dsc, &vuntil_null);
if (!vuntil_null) {
vuntil = DatumGetTimestampTz(vuntil_datum);
}
if ((!vbegin_null && vbegin > last_try_loginT_time) || (!vuntil_null && vuntil < last_try_loginT_time)) {
str_reset(passwd);
str_reset(role_passwd);
ereport(ERROR,
(errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
errmsg("The account is not within the period of validity.")));
}
ReleaseSysCache(tuple);
heap_close(pg_authid_rel, NoLock);
str_reset(passwd);
str_reset(role_passwd);
return true;
}
/*
* @@GaussDB@@
* Brief: Check one channel of the replconninfo.
* Description: If the format of the channel is right return true, else return false.
* Notes:
*/
static bool check_repl_channel(const char* channel_info)
{
char* iter = NULL;
char* repl_str = NULL;
if (channel_info == NULL) {
return false;
} else {
repl_str = pstrdup(channel_info);
if (repl_str == NULL) {
return false;
} else {
iter = strstr(repl_str, "localhost");
if (iter == NULL) {
pfree(repl_str);
return false;
}
iter += strlen("localhost");
while (*iter == ' ' || *iter == '=') {
iter++;
}
if ((!isdigit(*iter) && *iter != ':' && !isalpha(*iter)) ||
(0 == strncmp(iter, "localport", strlen("localport")))) {
pfree(repl_str);
return false;
}
iter = strstr(repl_str, "localport");
if (iter == NULL) {
pfree(repl_str);
return false;
}
iter += strlen("localport");
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (!isdigit(*iter)) {
pfree(repl_str);
return false;
}
iter = strstr(repl_str, "remotehost");
if (iter == NULL) {
pfree(repl_str);
return false;
}
iter += strlen("remotehost");
while (*iter == ' ' || *iter == '=') {
iter++;
}
if ((!isdigit(*iter) && *iter != ':' && !isalpha(*iter)) ||
(0 == strncmp(iter, "remoteport", strlen("remoteport")))) {
pfree(repl_str);
return false;
}
iter = strstr(repl_str, "remoteport");
if (iter == NULL) {
pfree(repl_str);
return false;
}
iter += strlen("remoteport");
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (!isdigit(*iter)) {
pfree(repl_str);
return false;
}
}
}
pfree(repl_str);
return true;
}
/*
* @@GaussDB@@
* Brief: Get the number of right-format-channel in a replconninfo.
* Description: Check each channel of a replconninfo, and return the number of the right-format ones.
* Notes:
*/
static int get_length_and_check_repl_conn(const char* conn_info_list)
{
int repl_len = 0;
char* repl_str = NULL;
char* token = NULL;
char* tmp_token = NULL;
if (conn_info_list == NULL) {
return repl_len;
} else {
repl_str = pstrdup(conn_info_list);
if (repl_str == NULL) {
ereport(LOG, (errmsg("conn_info_list is null")));
return repl_len;
}
token = strtok_r(repl_str, ",", &tmp_token);
while (token != NULL) {
if (check_repl_channel(token)) {
repl_len++;
}
token = strtok_r(NULL, ",", &tmp_token);
}
}
pfree(repl_str);
return repl_len;
}
/*
* @@GaussDB@@
* Brief: Parse one replconninfo, and get the connect info of each channel.
* Description: Parse one replconninfo, get the connect info of each channel.
* Then fill the ReplConnInfo array, and return it.
* Notes:
*/
static ReplConnInfo* parse_repl_conn_info(const char* conn_info_list, int* info_length)
{
ReplConnInfo* repl = NULL;
int repl_length = 0;
char* iter = NULL;
char* next = NULL;
char* repl_str = NULL;
char* token = NULL;
char* tmp_token = NULL;
char* ptr = NULL;
int parsed = 0;
int iplen = 0;
int portlen = strlen("localport");
int rportlen = strlen("remoteport");
int localservice_len = strlen("localservice");
int remoteservice_len = strlen("remoteservice");
int local_heartbeat_len = strlen("localheartbeatport");
int remote_heartbeat_len = strlen("remoteheartbeatport");
errno_t errorno = EOK;
if (info_length != NULL) {
*info_length = 0;
}
if (conn_info_list == NULL || info_length == NULL) {
ereport(LOG, (errmsg("parameter error in parse_repl_conn_info()")));
return NULL;
} else {
repl_str = pstrdup(conn_info_list);
if (repl_str == NULL) {
return NULL;
}
ptr = repl_str;
while (*ptr != '\0') {
if (*ptr != ' ') {
break;
}
ptr++;
}
if (*ptr == '\0') {
pfree(repl_str);
return NULL;
}
repl_length = get_length_and_check_repl_conn(repl_str);
if (repl_length == 0) {
pfree(repl_str);
return NULL;
}
repl = (ReplConnInfo*)MemoryContextAlloc(t_thrd.top_mem_cxt, sizeof(ReplConnInfo) * repl_length);
if (repl == NULL) {
pfree(repl_str);
return NULL;
}
errorno = memset_s(repl, sizeof(ReplConnInfo) * repl_length, 0, sizeof(ReplConnInfo) * repl_length);
securec_check(errorno, "\0", "\0");
token = strtok_r(repl_str, ",", &tmp_token);
while (token != NULL) {
/* localhost */
iter = strstr(token, "localhost");
if (iter == NULL) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
iter += strlen("localhost");
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (!isdigit(*iter) && *iter != ':' && !isalpha(*iter)) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
next = iter;
iplen = 0;
while (*next != ' ' && 0 != strncmp(next, "localport", portlen)) {
iplen++;
next++;
}
errorno = strncpy_s(repl[parsed].localhost, IP_LEN - 1, iter, iplen);
securec_check(errorno, "\0", "\0");
repl[parsed].localhost[iplen] = '\0';
/* localport */
iter = strstr(token, "localport");
if (iter == NULL) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
iter += portlen;
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (!isdigit(*iter)) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
repl[parsed].localport = atoi(iter);
/* localservice */
iter = strstr(token, "localservice");
if (iter != NULL) {
iter += localservice_len;
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (isdigit(*iter)) {
repl[parsed].localservice = atoi(iter);
}
}
/* localheartbeatport */
iter = strstr(token, "localheartbeatport");
if (iter != NULL) {
iter += local_heartbeat_len;
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (isdigit(*iter)) {
repl[parsed].localheartbeatport = atoi(iter);
}
}
/* remotehost */
iter = strstr(token, "remotehost");
if (iter == NULL) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
iter += strlen("remotehost");
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (!isdigit(*iter) && *iter != ':' && !isalpha(*iter)) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
next = iter;
iplen = 0;
while (*next != ' ' && 0 != strncmp(next, "remoteport", rportlen)) {
iplen++;
next++;
}
iplen = iplen >= IP_LEN ? IP_LEN - 1 : iplen;
errorno = strncpy_s(repl[parsed].remotehost, IP_LEN, iter, iplen);
securec_check(errorno, "\0", "\0");
repl[parsed].remotehost[iplen] = '\0';
/* remoteport */
iter = strstr(token, "remoteport");
if (iter == NULL) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
iter += rportlen;
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (!isdigit(*iter)) {
token = strtok_r(NULL, ",", &tmp_token);
continue;
}
repl[parsed].remoteport = atoi(iter);
/* remoteservice */
iter = strstr(token, "remoteservice");
if (iter != NULL) {
iter += remoteservice_len;
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (isdigit(*iter)) {
repl[parsed].remoteservice = atoi(iter);
}
}
/* remote heartbeat port */
iter = strstr(token, "remoteheartbeatport");
if (iter != NULL) {
iter += remote_heartbeat_len;
while (*iter == ' ' || *iter == '=') {
iter++;
}
if (isdigit(*iter)) {
repl[parsed].remoteheartbeatport = atoi(iter);
}
}
token = strtok_r(NULL, ",", &tmp_token);
parsed++;
}
}
pfree(repl_str);
*info_length = repl_length;
return repl;
}
#ifdef ENABLE_MULTIPLE_NODES
static GTM_HOST_IP* parse_gtm_host_conn_info(const char* conn_info_list, int* info_length)
{
char* repl_str = NULL;
char* token = NULL;
char* tmp_token = NULL;
uint32 len = 0;
uint32 tmp = 0;
GTM_HOST_IP* host_ip = NULL;
int rc;
if (conn_info_list == NULL) {
return NULL;
}
uint32 infolen = strlen(conn_info_list);
repl_str = pstrdup(conn_info_list);
if (repl_str == NULL) {
return NULL;
}
token = strtok_r(repl_str, ",", &tmp_token);
while (token != NULL) {
len++;
token = strtok_r(NULL, ",", &tmp_token);
}
pfree(repl_str);
if (len > 0) {
host_ip = (GTM_HOST_IP*)MemoryContextAllocZero(u_sess->top_mem_cxt, sizeof(GTM_HOST_IP) * len);
} else {
host_ip = (GTM_HOST_IP*)MemoryContextAllocZero(u_sess->top_mem_cxt, sizeof(GTM_HOST_IP));
}
if (host_ip == NULL) {
return NULL;
}
repl_str = (char*)MemoryContextAllocZero(u_sess->top_mem_cxt, infolen + 1);
if (repl_str == NULL) {
pfree(host_ip);
return NULL;
}
for (len = 0, tmp = 0; len < infolen; len++) {
if (conn_info_list[len] != ' ') {
repl_str[tmp++] = conn_info_list[len];
}
}
repl_str[tmp] = '\0';
len = 0;
token = strtok_r(repl_str, ",", &tmp_token);
while (token != NULL) {
rc = strncpy_s(host_ip[len].acHostIP, sizeof(host_ip[len].acHostIP), token, sizeof(host_ip[len].acHostIP) - 1);
securec_check(rc, "\0", "\0");
host_ip[len].acHostIP[127] = '\0';
len++;
token = strtok_r(NULL, ",", &tmp_token);
}
*info_length = len;
pfree(repl_str);
return host_ip;
}
static bool check_gtmhostconninfo(char** newval, void** extra, GucSource source)
{
char *str = NULL;
char *tmp = NULL;
bool ret = true;
if (newval == NULL) {
return false;
}
str = pstrdup(*newval);
if (str == NULL) {
return false;
}
tmp = str;
while (*tmp != '\0') {
if (isalpha(*tmp) || isdigit(*tmp) || *tmp == ' ' || *tmp == ',' || *tmp == '.' || *tmp == '*') {
tmp++;
continue;
}
ret = false;
break;
}
pfree(str);
return ret;
}
static void assign_gtmhostconninfo0(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[0] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[0]);
}
static void assign_gtmhostconninfo1(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[1] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[1]);
}
static void assign_gtmhostconninfo2(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[2] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[2]);
}
static void assign_gtmhostconninfo3(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[3] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[3]);
}
static void assign_gtmhostconninfo4(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[4] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[4]);
}
static void assign_gtmhostconninfo5(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[5] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[5]);
}
static void assign_gtmhostconninfo6(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[6] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[6]);
}
static void assign_gtmhostconninfo7(const char* newval, void* extra)
{
u_sess->attr.attr_common.GtmHostArray[7] =
parse_gtm_host_conn_info(newval, &u_sess->attr.attr_common.GtmHostIPNumArray[7]);
}
/*
* @Description: assign gtm response wait timeout.
* @int newval: guc input value about response wait timeout.
* @in extra: void pointer to extra variable.
*/
static void assign_gtm_rw_timeout(int newval, void* extra)
{
SetGTMrwTimeout(newval);
}
#endif
static bool check_replication_type(int* newval, void** extra, GucSource source)
{
if (*newval == RT_WITH_MULTI_STNADBY) {
if (!IsInitdb && (is_feature_disabled(DOUBLE_LIVE_DISASTER_RECOVERY_IN_THE_SAME_CITY) ||
is_feature_disabled(DISASTER_RECOVERY_IN_TWO_PLACES_AND_THREE_CENTRES) ||
is_feature_disabled(HA_SINGLE_PRIMARY_MULTI_STANDBY))) {
ereport(FATAL,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("replication_type is not allowed set 1 "
"in Current Version. Set to default (0).")));
}
}
return true;
}
/*
* @@GaussDB@@
* Brief: Check all the channel of one replconninfo.
* Description: Check each channel of one replconninfo. If one channel'format is not right, then return false.
* Notes:
*/
static bool check_replconninfo(char** newval, void** extra, GucSource source)
{
char* repl_str = NULL;
char* token = NULL;
char* tmp_token = NULL;
char* ptr = NULL;
if (newval == NULL) {
return false;
} else {
repl_str = pstrdup(*newval);
if (repl_str == NULL) {
return false;
}
ptr = repl_str;
while (*ptr != '\0') {
if (*ptr != ' ') {
break;
}
ptr++;
}
if (*ptr == '\0') {
pfree(repl_str);
return true;
}
token = strtok_r(repl_str, ",", &tmp_token);
while (token != NULL) {
if (!check_repl_channel(token)) {
pfree(repl_str);
return false;
}
token = strtok_r(NULL, ",", &tmp_token);
}
}
pfree(repl_str);
return true;
}
/*
* @@GaussDB@@
* Brief: Parse replconninfo1.
* Description:
* Notes:
*/
static void assign_replconninfo1(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[1] != NULL) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[1]);
}
/*
* We may need to move ReplConnArray to session level.
* At present, ReplConnArray is only used by PM, so it is safe.
*/
t_thrd.postmaster_cxt.ReplConnArray[1] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[1] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[1], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[1] = true;
}
}
/*
* @@GaussDB@@
* Brief: Parse replconninfo2.
* Description:
* Notes:
*/
static void assign_replconninfo2(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[2] != NULL) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[2]);
}
t_thrd.postmaster_cxt.ReplConnArray[2] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[2] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[2], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[2] = true;
}
}
static void assign_replconninfo3(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[3]) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[3]);
}
t_thrd.postmaster_cxt.ReplConnArray[3] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[3] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[3], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[3] = true;
}
}
static void assign_replconninfo4(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[4]) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[4]);
}
t_thrd.postmaster_cxt.ReplConnArray[4] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[4] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[4], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[4] = true;
}
}
#ifdef ENABLE_MULTIPLE_NODES
static void assign_replconninfo5(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[5]) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[5]);
}
t_thrd.postmaster_cxt.ReplConnArray[5] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[5] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[5], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[5] = true;
}
}
static void assign_replconninfo6(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[6]) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[6]);
}
t_thrd.postmaster_cxt.ReplConnArray[6] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[6] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[6], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[6] = true;
}
}
static void assign_replconninfo7(const char* newval, void* extra)
{
int repl_length = 0;
if (t_thrd.postmaster_cxt.ReplConnArray[7]) {
pfree(t_thrd.postmaster_cxt.ReplConnArray[7]);
}
t_thrd.postmaster_cxt.ReplConnArray[7] = parse_repl_conn_info(newval, &repl_length);
if (u_sess->attr.attr_storage.ReplConnInfoArr[7] != NULL && newval != NULL &&
strcmp(u_sess->attr.attr_storage.ReplConnInfoArr[7], newval) != 0) {
t_thrd.postmaster_cxt.ReplConnChanged[7] = true;
}
}
#endif
/*
* @@GaussDB@@
* Brief: Check inlist2join info.
* Description: If inlist2join'format is not right, then return false.
* Notes:
*/
static bool check_inlist2joininfo(char** newval, void** extra, GucSource source)
{
if (newval == NULL) {
return false;
}
if (strcmp((const char*)*newval, (const char*)"disable") == 0 ||
strcmp((const char*)*newval, (const char*)"cost_base") == 0 ||
strcmp((const char*)*newval, (const char*)"rule_base") == 0) {
return true;
} else if (atoi((const char*)*newval) <= 0) {
GUC_check_errdetail(
"Available values: disable, cost_base, rule_base, or any positive integer as a inlist2join threshold");
return false;
} else {
return true;
}
}
/*
* @@GaussDB@@
* Brief:
* Description: parse inlist2join info.
* Notes:
*/
static void assign_inlist2joininfo(const char* newval, void* extra)
{
int threshold = 0;
if (strcmp((const char*)newval, (const char*)"disable") == 0) {
u_sess->opt_cxt.qrw_inlist2join_optmode = QRW_INLIST2JOIN_DISABLE;
} else if (strcmp((const char*)newval, (const char*)"cost_base") == 0) {
u_sess->opt_cxt.qrw_inlist2join_optmode = QRW_INLIST2JOIN_CBO;
} else if (strcmp((const char*)newval, (const char*)"rule_base") == 0) {
u_sess->opt_cxt.qrw_inlist2join_optmode = QRW_INLIST2JOIN_FORCE;
} else {
threshold = atoi((const char*)newval);
if (threshold > 0) {
u_sess->opt_cxt.qrw_inlist2join_optmode = threshold;
}
}
}
/*
* @@GaussDB@@
* Brief: void * pg_malloc(size_t size)
* Description: malloc a space of size
* Notes:
*/
void* pg_malloc(size_t size)
{
void* result = NULL;
/* Avoid unportable behavior of malloc(0) */
if (size == 0) {
write_stderr(_("walreceiver malloc 0\n"));
gs_thread_exit(1);
}
#ifdef FRONTEND
result = malloc(size);
#else
result = MemoryContextAlloc(u_sess->top_mem_cxt, size);
#endif
if (result == NULL) {
write_stderr(_("walreceiver out of memory\n"));
gs_thread_exit(1);
}
return result;
}
/*
* @@GaussDB@@
* Brief: char *xstrdup(const char *s)
* Description: copy string
* Notes:
*/
char* xstrdup(const char* s)
{
char* result = NULL;
#ifndef EXEC_BACKEND
result = strdup(s);
#else
result = MemoryContextStrdup(u_sess->top_mem_cxt, s);
#endif
if (result == NULL) {
write_stderr(_("walreceiver out of memory\n"));
gs_thread_exit(1);
}
return result;
}
void release_opt_lines(char** opt_lines)
{
char** opt_line = NULL;
if (opt_lines == NULL) {
return;
}
for (opt_line = opt_lines; *opt_line != NULL; opt_line++) {
selfpfree(*opt_line);
*opt_line = NULL;
}
selfpfree(opt_lines);
opt_lines = NULL;
return;
}
char** alloc_opt_lines(int opt_lines_num)
{
char** opt_lines = NULL;
int i = 0;
opt_lines = ((char**)pg_malloc(opt_lines_num * sizeof(char*)));
for (i = 0; i < opt_lines_num; i++) {
opt_lines[i] = NULL;
}
return opt_lines;
}
/*
* @@GaussDB@@
* Brief: static char ** read_guc_file(const char* path)
* Description: get the lines from a text file - return NULL if file can't be opened
* Notes:
*/
char** read_guc_file(const char* path)
{
FILE* infile = NULL;
int maxlength = 1;
int linelen = 0;
int nlines = 0;
char** result;
char* buffer = NULL;
int c;
const int limit_of_length = 100000; // limit of maxlength and nlines
if ((infile = fopen(path, "r+")) == NULL) {
(void)fprintf(stderr, _("could not open file for reading: %s\n"), gs_strerror(errno));
return NULL;
}
while ((c = fgetc(infile)) != EOF) { /* pass over the file twice - the first time to size the result */
linelen++;
if (c == '\n') {
nlines++;
if (linelen > maxlength) {
maxlength = linelen;
}
linelen = 0;
}
}
/* handle last line without a terminating newline (yuck) */
if (linelen) {
nlines++;
}
if (linelen > maxlength) {
maxlength = linelen;
}
if (maxlength <= 1) {
fclose(infile);
infile = NULL;
return NULL;
}
if (maxlength > limit_of_length || nlines > limit_of_length) {
fclose(infile);
infile = NULL;
ereport(ERROR, (errcode(ERRCODE_CONFIG_FILE_ERROR), errmsg("Length of file or line is too long.")));
}
/* set up the result and the line buffer */
result = (char**)pg_malloc((nlines + 1) * sizeof(char*));
buffer = (char*)pg_malloc(maxlength + 1);
/* now reprocess the file and store the lines */
rewind(infile);
nlines = 0;
while (fgets(buffer, maxlength + 1, infile) != NULL) {
result[nlines++] = xstrdup(buffer);
}
(void)fclose(infile);
pfree(buffer);
result[nlines] = NULL;
return result;
}
/*
* @@GaussDB@@
* Brief: write_guc_file
* Description: write the config file
* Notes:
*/
ErrCode write_guc_file(const char* path, char** lines)
{
FILE* out_file = NULL;
char** line = NULL;
ErrCode retcode = CODE_OK;
if ((out_file = fopen(path, "w")) == NULL) {
(void)fprintf(stderr, _("walreceiver could not open file \"%s\" for writing: %s\n"), path, gs_strerror(errno));
return CODE_OPEN_CONFFILE_FAILED;
}
for (line = lines; *line != NULL; line++) {
if (fputs(*line, out_file) < 0) {
retcode = CODE_WRITE_CONFFILE_ERROR;
break;
}
pfree(*line);
*line = NULL;
}
if (retcode == CODE_OK) {
if (fflush(out_file)) {
(void)fprintf(stderr, _("walreceiver flush file \"%s\" failed: %s\n"), path, gs_strerror(errno));
retcode = CODE_WRITE_CONFFILE_ERROR;
}
}
if (fclose(out_file)) {
(void)fprintf(stderr, _("walreceiver could not write file \"%s\": %s\n"), path, gs_strerror(errno));
retcode = CODE_CLOSE_CONFFILE_FAILED;
}
out_file = NULL;
return retcode;
}
/*
* @@GaussDB@@
* Brief: copy_guc_lines
* Description: copy and store the specified lines
* Notes:
*/
ErrCode copy_guc_lines(char** copy_to_line, char** optlines, const char** opt_name)
{
int optvalue_off = 0;
int optvalue_len = 0;
int opt_name_index = 0;
int i = 0;
int opt_name_len = 0;
int opt_num = 0;
if (optlines != NULL) {
for (i = 0; i < RESERVE_SIZE; i++) {
opt_name_index = find_guc_option(optlines, opt_name[i], NULL, NULL, &optvalue_off, &optvalue_len);
if (INVALID_LINES_IDX != opt_name_index) {
errno_t errorno = EOK;
opt_name_len = strlen(optlines[opt_name_index]) + 1;
if (opt_name_len > MAX_PARAM_LEN) {
ereport(LOG, (errmsg("guc '%s' is out of 1024", optlines[opt_name_index])));
return CODE_INTERNAL_ERROR;
}
copy_to_line[i] = (char*)pg_malloc(opt_name_len);
errorno = memset_s(copy_to_line[i], opt_name_len, 0, opt_name_len);
securec_check(errorno, "\0", "\0");
errorno = strncpy_s(copy_to_line[i], opt_name_len, optlines[opt_name_index], opt_name_len - 1);
securec_check(errorno, "\0", "\0");
opt_num++;
}
}
if (opt_num <= 0) {
ereport(LOG, (errmsg("the config file has no reserved parameters.")));
return CODE_INTERNAL_ERROR;
}
} else {
ereport(LOG, (errmsg("the config file is null")));
return CODE_INTERNAL_ERROR;
}
return CODE_OK;
}
/*
* @@GaussDB@@
* Brief: static void modify_config_file
* Description: get the lines from a text file - return NULL if file can't be opened
* Notes:
*/
void modify_guc_lines(char** optlines, const char** opt_name, char** copy_from_line)
{
int opt_name_index = 0;
int optvalue_off = 0;
int optvalue_len = 0;
int i = 0;
int newsize = 0;
int real_newsize = 0;
if (optlines == NULL) {
ereport(LOG, (errmsg("configuration file has not data")));
} else {
for (i = 0; i < RESERVE_SIZE; i++) {
opt_name_index = find_guc_option(optlines, opt_name[i], NULL, NULL, &optvalue_off, &optvalue_len);
if (opt_name_index != INVALID_LINES_IDX && copy_from_line[i] != NULL) {
pfree(optlines[opt_name_index]);
newsize = strlen(copy_from_line[i]) + 1;
real_newsize = Min(newsize, MAX_PARAM_LEN);
optlines[opt_name_index] = (char*)pg_malloc(real_newsize);
errno_t rc = strncpy_s(optlines[opt_name_index], real_newsize, copy_from_line[i], real_newsize - 1);
securec_check(rc, "\0", "\0");
if (newsize > MAX_PARAM_LEN) {
ereport(WARNING, (errmsg("guc '%s' is out of 1024", optlines[opt_name_index])));
}
}
}
}
}
/*
* @@GaussDB@@
* Brief: find_guc_option
* Description: find the line info of the specified parameter in file
* Notes:
*/
int find_guc_option(
char** optlines, const char* opt_name, int* name_offset, int* name_len, int* value_offset, int* value_len)
{
bool isMatched = false;
int i = 0;
if (optlines == NULL || opt_name == NULL) {
return INVALID_LINES_IDX;
}
size_t paramlen = (size_t)strnlen(opt_name, MAX_PARAM_LEN);
if (name_len != NULL) {
*name_len = (int)paramlen;
}
/* The first loop is to deal with the lines not commented by '#' */
for (i = 0; optlines[i] != NULL; i++) {
if (!is_opt_line_commented(optlines[i])) {
isMatched = is_match_option_name(optlines[i], opt_name, paramlen, name_offset, value_len, value_offset);
if (isMatched) {
return i;
}
}
}
/* The second loop is to deal with the lines commented by '#' */
for (i = 0; optlines[i] != NULL; i++) {
if (is_opt_line_commented(optlines[i])) {
isMatched = is_match_option_name(optlines[i], opt_name, paramlen, name_offset, value_len, value_offset);
if (isMatched) {
return i;
}
}
}
return INVALID_LINES_IDX;
}
/*
* @@GaussDB@@
* Brief: genarate_temp_file
* Description: put the received data into temp file
* Notes:
*/
ErrCode generate_temp_file(char* buf, char* temppath, size_t size)
{
FILE* fp = NULL;
if ((fp = fopen(temppath, "w")) == NULL) {
ereport(LOG, (errmsg("could not open file \"%s\": %m", temppath)));
return CODE_OPEN_CONFFILE_FAILED;
}
if (fwrite((void*)buf, 1, size, fp) != size) {
ereport(LOG, (errmsg("could not write file \"%s\": %m", temppath)));
fclose(fp);
return CODE_WRITE_CONFFILE_ERROR;
}
if (fclose(fp)) {
ereport(LOG, (errmsg("could not close config file \"%s\": %m", temppath)));
return CODE_CLOSE_CONFFILE_FAILED;
}
return CODE_OK;
}
/*
* @@GaussDB@@
* Brief: copy_asyn_lines
* Description: copy and store the asynchronous lines
* Notes:
*/
ErrCode copy_asyn_lines(char* path, char** copy_to_line, const char** opt_name)
{
char** opt_lines = NULL;
ErrCode retcode = CODE_OK;
opt_lines = read_guc_file(path);
if (opt_lines == NULL) {
ereport(LOG, (errmsg("the config file has no data,please check it.")));
retcode = CODE_INTERNAL_ERROR;
} else {
retcode = copy_guc_lines(copy_to_line, opt_lines, opt_name);
if (retcode != CODE_OK) {
ereport(LOG, (errmsg("copy_guc_lines failed,code error:%d", retcode)));
}
release_opt_lines(opt_lines);
opt_lines = NULL;
}
return retcode;
}
/*
* @@GaussDB@@
* Brief: copy_asyn_lines
* Description: update the specified lines of the file
* Notes:
*/
ErrCode update_temp_file(char* tempfilepath, char** copy_to_line, const char** opt_name)
{
char** opt_lines = NULL;
ErrCode ret;
opt_lines = read_guc_file(tempfilepath);
if (opt_lines == NULL) {
ereport(LOG, (errmsg("the config file has no data,please check it.")));
return CODE_INTERNAL_ERROR;
}
modify_guc_lines(opt_lines, opt_name, copy_to_line);
ret = write_guc_file(tempfilepath, opt_lines);
release_opt_lines(opt_lines);
opt_lines = NULL;
if (ret == CODE_OK) {
ereport(LOG, (errmsg("the config file %s updates success.", tempfilepath)));
}
return ret;
}
/*
* @@GaussDB@@
* Brief: get the file lock
* Description:
* Notes:
*/
ErrCode get_file_lock(const char* path, ConfFileLock* filelock)
{
FILE* fp = NULL;
struct stat statbuf;
char content[PG_LOCKFILE_SIZE] = {0};
if (lstat(path, &statbuf) != 0) {
fp = fopen(path, PG_BINARY_W);
if (fp == NULL) {
ereport(LOG, (errmsg("Can't open lock file for write\"%s\",errormsg: %s", path, gs_strerror(errno))));
return CODE_OPEN_CONFFILE_FAILED;
} else {
if (fwrite(content, PG_LOCKFILE_SIZE, 1, fp) != 1) {
fclose(fp);
ereport(LOG, (errmsg("Can't write lock file \"%s\",errormsg: %s", path, gs_strerror(errno))));
return CODE_WRITE_CONFFILE_ERROR;
}
fclose(fp);
}
}
if ((fp = fopen(path, PG_BINARY_RW)) == NULL) {
ereport(LOG, (errmsg("could not open file or directory \"%s\",errormsg: %s", path, gs_strerror(errno))));
return CODE_OPEN_CONFFILE_FAILED;
}
if (flock(fileno(fp), LOCK_EX | LOCK_NB, 0, START_LOCATION, statbuf.st_size) == -1) {
ereport(LOG, (errmsg("could not lock file or directory \"%s\",errormsg: %s", path, gs_strerror(errno))));
fclose(fp);
return CODE_LOCK_CONFFILE_FAILED;
}
filelock->fp = fp;
filelock->size = statbuf.st_size;
return CODE_OK;
}
/*
* @@GaussDB@@
* Brief: release the file lock
* Description:
* Notes:
*/
void release_file_lock(ConfFileLock* filelock)
{
int ret;
ret = flock(fileno(filelock->fp), LOCK_UN, 0, START_LOCATION, filelock->size);
if (ret != 0) {
ereport(WARNING, (errmsg("unlock file failed")));
}
fclose(filelock->fp);
filelock->fp = NULL;
filelock->size = 0;
}
/* append set string to input_set_message */
void append_set_message(const char* str)
{
MemoryContext oldcontext = MemoryContextSwitchTo(u_sess->top_mem_cxt);
if ((*u_sess->utils_cxt.input_set_message).maxlen == 0) {
initStringInfo(&(*u_sess->utils_cxt.input_set_message));
}
appendStringInfoString(&(*u_sess->utils_cxt.input_set_message), str);
appendStringInfoString(&(*u_sess->utils_cxt.input_set_message), ";");
MemoryContextSwitchTo(oldcontext);
}
/*
* @Description: make set message with hash table
* @IN void
* @Return: void
* @See also:
*/
void make_set_message(void)
{
if (u_sess->utils_cxt.set_params_htab == NULL) {
return;
}
MemoryContext oldcontext = MemoryContextSwitchTo(u_sess->top_mem_cxt);
/*
* If input_set_message exists, we will destroy it.
* The reason for this is that the original string
* contains the parameters that need to be reset. In
* this case, we need to rebuild the message string
* based on the hash table
*/
if ((*u_sess->utils_cxt.input_set_message).maxlen == 0) {
initStringInfo(&(*u_sess->utils_cxt.input_set_message));
} else {
resetStringInfo(&(*u_sess->utils_cxt.input_set_message));
}
HASH_SEQ_STATUS hash_seq;
hash_seq_init(&hash_seq, u_sess->utils_cxt.set_params_htab);
GucParamsEntry* entry = NULL;
/* Get all session params from the hash table to rebuild message string */
while ((entry = (GucParamsEntry*)hash_seq_search(&hash_seq)) != NULL) {
PG_TRY();
{
appendStringInfoString(&(*u_sess->utils_cxt.input_set_message), entry->query);
appendStringInfoString(&(*u_sess->utils_cxt.input_set_message), ";");
}
PG_CATCH();
{
hash_seq_term(&hash_seq);
MemoryContextSwitchTo(oldcontext);
PG_RE_THROW();
}
PG_END_TRY();
}
MemoryContextSwitchTo(oldcontext);
}
/*
* @Description: init params hash table
* @IN void
* @Return: void
* @See also:
*/
void init_set_params_htab(void)
{
HASHCTL hash_ctl;
errno_t errval = memset_s(&hash_ctl, sizeof(hash_ctl), 0, sizeof(hash_ctl));
securec_check_errval(errval, , LOG);
hash_ctl.keysize = NAMEDATALEN;
hash_ctl.hcxt = u_sess->top_mem_cxt;
hash_ctl.entrysize = sizeof(GucParamsEntry);
hash_ctl.hash = string_hash;
u_sess->utils_cxt.set_params_htab = hash_create(
"set params hash table", WORKLOAD_STAT_HASH_SIZE, &hash_ctl, HASH_CONTEXT | HASH_ELEM | HASH_FUNCTION);
}
/*
* @Description: check message for sending
* @IN stmt: variable set statement
* @IN queryString: query string
* @Return: 0: append
* 1: rebuild
* -1: none
* @See also:
*/
int check_set_message_to_send(const VariableSetStmt* stmt, const char* queryString)
{
/* no hash table, we can only choose appending mode */
if (u_sess->utils_cxt.set_params_htab == NULL) {
return 0;
}
/* variable name is invalid, ignore this */
if (!StringIsValid(stmt->name)) {
return -1;
}
bool found = false;
GucParamsEntry* entry =
(GucParamsEntry*)hash_search(u_sess->utils_cxt.set_params_htab, stmt->name, HASH_ENTER, &found);
USE_MEMORY_CONTEXT(u_sess->top_mem_cxt);
/* parameter is set, we will update the entry for making a new message */
if (found) {
if (entry->query) {
pfree_ext(entry->query);
}
entry->query = pstrdup(queryString);
return 1;
}
errno_t errval = strncpy_s(entry->name, sizeof(entry->name), stmt->name, sizeof(entry->name) - 1);
securec_check_errval(errval, , LOG);
entry->query = pstrdup(queryString);
return 0;
}
/* get set commant in input_set_message */
char* get_set_string()
{
if ((*u_sess->utils_cxt.input_set_message).len > 0) {
return (*u_sess->utils_cxt.input_set_message).data;
} else {
return NULL;
}
}
/*
* @Description: reset params hash table
* @IN htab: hash table to be reset
* @Return: void
* @See also:
*/
void reset_params_htab(HTAB* htab, bool isCommit)
{
/* need not process hash table */
if (htab == NULL || hash_get_num_entries(htab) <= 0) {
return;
}
HASH_SEQ_STATUS hash_seq;
hash_seq_init(&hash_seq, htab);
GucParamsEntry* entry = NULL;
/* remove all session params from the hash table. */
while ((entry = (GucParamsEntry*)hash_seq_search(&hash_seq)) != NULL) {
if (isCommit) {
register_pooler_session_param(entry->name, entry->query);
}
if (entry->query) {
pfree_ext(entry->query);
}
hash_search(htab, entry->name, HASH_REMOVE, NULL);
}
}
void reset_set_message(bool isCommit)
{
if ((*u_sess->utils_cxt.input_set_message).maxlen != 0) {
resetStringInfo(&(*u_sess->utils_cxt.input_set_message));
}
reset_params_htab(u_sess->utils_cxt.set_params_htab, isCommit);
}
#define ERRMSG_EMPTY_MODULE_NAME "empty module name"
#define ERRMSG_MODNAME_NOT_FOUND "module name \"%s\" not found"
#define ERRMSG_EMPTY_MODULE_LIST "empty module list"
#define ERRMSG_MODLIST_NOT_FOUND "module list not found"
#define HINT_MODULE_LIST_FMT "Module list begins with '(', ends with ')', and is delimited with '%c'."
#define HINT_QUERY_ALL_MODULES "Query all the existing modules by SHOW logging_module."
#define SKIP_SPACE(_p) \
do { \
while (*(_p) && ' ' == *(_p)) { \
++(_p); \
} \
} while (0)
/*
* @Description: check whether keyword "on"/"off" is matched.
* @IN/OUT start: input text which will be updated if true returned.
* @OUT turn_on: "on" --> true; "off" --> false;
* @Return: return false if any keyword is not found; or return true.
* @See also:
*/
static inline bool string_guc_keyword_matched(char** start, bool* turn_on)
{
char* p = *start;
SKIP_SPACE(p);
if (0 == pg_strncasecmp("on", p, 2)) {
p += 2;
*turn_on = true;
} else if (0 == pg_strncasecmp("off", p, 3)) {
p += 3;
*turn_on = false;
} else {
/* keyword "on"/"off" not found */
goto missing_kw;
}
if (*p && !(' ' == *p || '(' == *p)) {
/* "on"/"off" is the prefix of this word, error */
goto missing_kw;
}
/* update string position */
*start = p;
return true;
missing_kw:
/* bad format: not found key words "on" or "off" */
GUC_check_errmsg("missing keywords \"on\" or \"off\"");
GUC_check_errdetail("Must begin with keyword \"on\" or \"off\".");
return false;
}
/*
* @Description: check whether list starts with '(' and is not empty.
* @IN/OUT start: input text which will be updated if true returned.
* @Return: return true if list starts with '(' and this is not empty;
* otherwise return false.
* @See also:
*/
static inline bool string_guc_list_start(char** start)
{
char* p = *start;
SKIP_SPACE(p);
if (*p == '\0' || *p != '(') {
/* bad format: not found ( */
GUC_check_errmsg(ERRMSG_MODLIST_NOT_FOUND);
GUC_check_errdetail("'(' is not found.");
GUC_check_errhint(HINT_MODULE_LIST_FMT, MOD_DELIMITER);
return false;
}
++p; /* skip '(' */
SKIP_SPACE(p);
if (*p == '\0') {
/* bad format: '(' not match anything */
GUC_check_errmsg(ERRMSG_MODLIST_NOT_FOUND);
GUC_check_errhint(HINT_MODULE_LIST_FMT, MOD_DELIMITER);
return false;
} else if (*p == ')') {
/* bad format: empty list given */
GUC_check_errmsg(ERRMSG_EMPTY_MODULE_LIST);
GUC_check_errdetail("Must one or more modules are given, and delimited with '%c'.", MOD_DELIMITER);
return false;
}
*start = p; /* update string position */
return true;
}
/*
* @Description: check whether list ends with ')' and well formatted.
* @IN delim_found: "true" value means the last module name is empty.
* @IN/OUT start: input text which will be updated if true returned.
* @Return: true if it's well formatted; otherwise return false.
* @See also:
*/
static inline bool string_guc_list_end(char** start, bool delim_found)
{
char* p = *start;
if (*p == '\0') {
/* bad format: ')' not found */
GUC_check_errmsg(ERRMSG_MODLIST_NOT_FOUND);
GUC_check_errdetail("Module list does not end with ')'.");
GUC_check_errhint(HINT_MODULE_LIST_FMT, MOD_DELIMITER);
return false;
}
if (delim_found) {
/* bad format: the last module name is empty */
GUC_check_errmsg(ERRMSG_EMPTY_MODULE_NAME);
GUC_check_errdetail("The last module name is empty.");
GUC_check_errhint("Module name must be given between '%c' and ')'.", MOD_DELIMITER);
return false;
}
++p; /* until here *p is ')', skip it */
SKIP_SPACE(p);
if (*p != '\0') {
/* bad format: non-space found after ')' */
GUC_check_errmsg("extra text found after the first list of module names");
GUC_check_errhint("Remove the extra text after the first list of module names.");
return false;
}
*start = p; /* update string position */
return true;
}
/*
* @Description: find the next module name and start will point to it.
* @OUT delim_found: mainly for the last module name which cannot be empty.
* @IN/OUT start: input text which will be updated if true returned.
* @Return: true if next name found; otherwise false.
* @See also:
*/
static inline bool string_guc_list_find_next_name(char** start, bool* delim_found)
{
char* p = *start;
/* reset to be false */
*delim_found = false;
while (*p && (*p == ' ' || *p == MOD_DELIMITER)) {
if (*p == MOD_DELIMITER) {
if (!(*delim_found)) {
*delim_found = true;
} else {
/* bad format: empty module name */
GUC_check_errmsg(ERRMSG_EMPTY_MODULE_NAME);
GUC_check_errdetail("Module name cannot be empty.");
GUC_check_errhint("Module name must be given between '%c'.", MOD_DELIMITER);
return false;
}
}
++p; /* skip spaces and delimiter */
}
*start = p; /* update string position */
return true;
}
/*
* @Description: parse module name and check its validation.
* @OUT all_found: "ALL" modules name is found
* @IN/OUT mods: to remember all the found module id
* @IN/OUT mods_num: size of modes[]
* @IN mod_name: this module name
* @IN mod_name_len: size of this module name
* @Return:
* @See also:
*/
static inline bool logging_module_parse_name(
char* mod_name, int mod_name_len, ModuleId* mods, int* mods_num, bool* all_found)
{
if (mod_name_len > 0 && mod_name_len < MODULE_NAME_MAXLEN) {
ModuleId modid = MOD_MAX;
const char ch = mod_name[mod_name_len];
/* judge whether it's a valid module name */
mod_name[mod_name_len] = '\0';
modid = get_module_id(mod_name);
if (modid == MOD_MAX) {
/* bad format: not existing module name */
GUC_check_errmsg(ERRMSG_MODNAME_NOT_FOUND, mod_name);
GUC_check_errhint(HINT_QUERY_ALL_MODULES);
/* needn't to resotre the replaced char because it's a copy of new value. */
return false;
}
/* repeat set is not allow */
for (int i = 0; i < *mods_num; i++) {
if (mods[i] == modid) {
GUC_check_errmsg("repeat name: %s.", mod_name);
GUC_check_errdetail("Please don't set module name repeatedly.");
return false;
}
}
mod_name[mod_name_len] = ch; /* restore the replaced char */
if (modid == MOD_ALL) {
*all_found = true;
}
mods[*mods_num] = modid;
(*mods_num)++;
return true;
} else {
/* bad format: empty string or not valid module name */
if (mod_name_len == 0) {
GUC_check_errmsg(ERRMSG_EMPTY_MODULE_NAME);
GUC_check_errdetail("Module name cannot be empty.");
} else {
mod_name[mod_name_len] = '\0';
GUC_check_errmsg(ERRMSG_MODNAME_NOT_FOUND, mod_name);
/* needn't to resotre the replaced char because it's a copy of new value. */
}
GUC_check_errhint(HINT_QUERY_ALL_MODULES);
return false;
}
}
/*
* @Description: check whether the new GUC value is valid.
* 1. format is a) on(m1,m2,...) or b) off(m3,m4,..)
* 2. module name is valid
* if all the conditions hold, apply these changes to this
* session and return true; otherwise return false.
* @IN newval: logging_module's new value
* @IN assign: only check the new value if assign is false;
* otherwise check and assign.
* @Return: if newval is well-formatted, return true; otherwise return false.
* @See also:
*/
template <bool assign>
static bool logging_module_guc_check(char* newval)
{
char* p = newval;
bool all_found = false;
bool turn_on = false;
/* forbit that no module name appear between two delimiters.
* forbit that no module name appear between delimiter and ')'
*/
bool delim_found = false;
/* treat all the error type as syntax error. */
GUC_check_errcode(ERRCODE_SYNTAX_ERROR);
if (!string_guc_keyword_matched(&p, &turn_on)) {
return false;
}
if (!string_guc_list_start(&p)) {
return false;
}
ModuleId* mods = (ModuleId*)palloc(sizeof(ModuleId) * MOD_MAX);
int mods_num = 0;
while (*p && *p != ')') {
/* remember the start of module name */
char* mod_name = p;
/* fine the end char of module name */
while (*p && (*p != MOD_DELIMITER && *p != ' ' && *p != ')')) {
++p;
}
if (!logging_module_parse_name(mod_name, p - mod_name, mods, &mods_num, &all_found) ||
!string_guc_list_find_next_name(&p, &delim_found)) {
pfree_ext(mods);
return false;
}
}
if (!string_guc_list_end(&p, delim_found)) {
pfree_ext(mods);
return false;
}
if (assign) {
module_logging_batch_set(mods, mods_num, turn_on, all_found);
}
pfree_ext(mods);
return true;
}
/*
* @Description: show the content of GUC "logging_module"
* @Return: logging_module descripting text
* @See also:
*/
static const char* logging_module_guc_show(void)
{
/*
* showing results is as following:
* ALL,on(mod1,mod2,...),off(mod3,mod4,...)
*/
StringInfoData outbuf;
initStringInfo(&outbuf);
const char* mod_name = NULL;
bool rm_last_delim = false;
/* copy the special "ALL" */
mod_name = get_valid_module_name(MOD_ALL);
appendStringInfo(&outbuf, "%s%c", mod_name, MOD_DELIMITER);
/* copy the string "on(" */
appendStringInfo(&outbuf, "on(");
/* copy each module name whose logging is enable */
rm_last_delim = false;
for (int i = MOD_ALL + 1; i < MOD_MAX; i++) {
if (module_logging_is_on((ModuleId)i)) {
/* FOR condition and module_logging_is_on() will assure its requirement. */
mod_name = get_valid_module_name((ModuleId)i);
appendStringInfo(&outbuf, "%s%c", mod_name, MOD_DELIMITER);
rm_last_delim = true;
}
}
if (rm_last_delim) {
--outbuf.len;
outbuf.data[outbuf.len] = '\0';
}
/* copy the string "),off(" */
appendStringInfo(&outbuf, "),off(");
/* copy each module name whose logging is disable */
rm_last_delim = false;
for (int i = MOD_ALL + 1; i < MOD_MAX; i++) {
if (!module_logging_is_on((ModuleId)i)) {
/* FOR condition will assure its requirement. */
mod_name = get_valid_module_name((ModuleId)i);
appendStringInfo(&outbuf, "%s%c", mod_name, MOD_DELIMITER);
rm_last_delim = true;
}
}
if (rm_last_delim) {
--outbuf.len;
outbuf.data[outbuf.len] = '\0';
}
/* end with string ")" */
appendStringInfoChar(&outbuf, ')');
return outbuf.data;
}
/*
* @Description: check whether new value is well-formatted for GUC logging_module.
* @IN extra: unused
* @IN newval: new value
* @IN source: unused
* @Return: if newval is well-formatted, return true; otherwise return false.
* @See also:
*/
static bool logging_module_check(char** newval, void** extra, GucSource source)
{
((void)extra); /* not used argument */
((void)source); /* not used argument */
char* tmp_new_val = pstrdup(*newval);
bool ret = logging_module_guc_check<false>(tmp_new_val);
pfree(tmp_new_val);
return ret;
}
/*
* @Description: update logging_module according new value.
* @IN extra: unused
* @IN newval: new value
* @See also:
*/
static void logging_module_guc_assign(const char* newval, void* extra)
{
((void)extra); /* not used argument */
char* tmp_new_val = pstrdup(newval);
/* logging_module_check() will be called first, so here don't care returned value */
(void)logging_module_guc_check<true>(tmp_new_val);
pfree(tmp_new_val);
}
/*
* @Description: update plog_merge_age GUC argument according new value.
* @IN extra: unused
* @IN newval: new value about merging plog age, whose unit is MS.
* @See also:
*/
static void plog_merge_age_assign(int newval, void* extra)
{
((void)extra); /* not used argument */
t_thrd.log_cxt.plog_msg_switch_tm.tv_sec = newval / MS_PER_S;
t_thrd.log_cxt.plog_msg_switch_tm.tv_usec = (newval - MS_PER_S * t_thrd.log_cxt.plog_msg_switch_tm.tv_sec) * 1000;
}
/* ------------------------------------------------------------ */
/* GUC hooks for inplace/grey upgrade */
/* ------------------------------------------------------------ */
static bool check_is_upgrade(bool* newval, void** extra, GucSource source)
{
switch (source) {
case PGC_S_DYNAMIC_DEFAULT:
case PGC_S_ENV_VAR:
case PGC_S_ARGV:
GUC_check_errmsg("IsInplaceUpgrade GUC can only be set with SET command.");
return false;
case PGC_S_FILE:
switch (currentGucContext) {
case PGC_SIGHUP:
case PGC_POSTMASTER:
ereport(WARNING,
(errmsg("IsInplaceUpgrade GUC can not be set in postgresql.conf. Set to default (false).")));
*newval = false;
return true;
/* Should not come here */
default:
GUC_check_errmsg("IsInplaceUpgrade GUC can not be set in postgresql.conf.");
return false;
}
return false; /* Should not come here */
case PGC_S_DATABASE:
case PGC_S_USER:
case PGC_S_DATABASE_USER:
case PGC_S_CLIENT:
case PGC_S_OVERRIDE:
case PGC_S_INTERACTIVE:
case PGC_S_TEST:
ereport(WARNING,
(errmsg("IsInplaceUpgrade GUC can only be set with SET command. Set to default (false)"
".")));
*newval = false;
return true;
case PGC_S_DEFAULT:
case PGC_S_SESSION:
if (*newval && u_sess->attr.attr_common.upgrade_mode == 0) {
GUC_check_errmsg("Can not set IsInPlaceUpgrade to true while not performing upgrade.");
return false;
}
return true;
default:
GUC_check_errmsg("Unknown GUC source for setting IsInplaceUpgrade.");
return false;
}
}
static void assign_is_inplace_upgrade(const bool newval, void* extra)
{
if (newval && u_sess->attr.attr_common.XactReadOnly) {
u_sess->attr.attr_common.XactReadOnly = false;
}
}
#define atooid(x) ((Oid)strtoul((x), NULL, 10))
#define catalog_oid_list_length 7
#define proc_oid_list_length 2
#define type_oid_list_length 4
#define namespace_oid_list_length 2
#define general_oid_list_length 2
static bool check_and_assign_catalog_oids(List* elemlist)
{
if (list_length(elemlist) != catalog_oid_list_length) {
return false;
}
bool isshared = false;
bool needstorage = false;
Oid relid = InvalidOid;
Oid comtypeid = InvalidOid;
Oid toastrelid = InvalidOid;
Oid indexrelid = InvalidOid;
if (!parse_bool((char*)list_nth(elemlist, 1), &isshared) ||
!parse_bool((char*)list_nth(elemlist, 2), &needstorage) ||
(relid = atooid((char*)list_nth(elemlist, 3))) >= FirstBootstrapObjectId ||
(comtypeid = atooid((char*)list_nth(elemlist, 4))) >= FirstBootstrapObjectId ||
(toastrelid = atooid((char*)list_nth(elemlist, 5))) >= FirstBootstrapObjectId ||
(indexrelid = atooid((char*)list_nth(elemlist, 6))) >= FirstBootstrapObjectId) {
return false;
}
u_sess->upg_cxt.new_catalog_isshared = isshared;
u_sess->upg_cxt.new_catalog_need_storage = needstorage;
u_sess->upg_cxt.Inplace_upgrade_next_heap_pg_class_oid = relid;
u_sess->upg_cxt.Inplace_upgrade_next_pg_type_oid = comtypeid;
u_sess->upg_cxt.Inplace_upgrade_next_toast_pg_class_oid = toastrelid;
u_sess->upg_cxt.Inplace_upgrade_next_index_pg_class_oid = indexrelid;
if (isshared) {
MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(u_sess->top_mem_cxt);
if (OidIsValid(relid)) {
u_sess->upg_cxt.new_shared_catalog_list = lappend_oid(u_sess->upg_cxt.new_shared_catalog_list, relid);
}
if (OidIsValid(toastrelid)) {
u_sess->upg_cxt.new_shared_catalog_list = lappend_oid(u_sess->upg_cxt.new_shared_catalog_list, toastrelid);
}
if (OidIsValid(indexrelid)) {
u_sess->upg_cxt.new_shared_catalog_list = lappend_oid(u_sess->upg_cxt.new_shared_catalog_list, indexrelid);
}
MemoryContextSwitchTo(oldcxt);
}
return true;
}
static bool check_and_assign_proc_oids(List* elemlist)
{
if (list_length(elemlist) != proc_oid_list_length) {
return false;
}
Oid procid = InvalidOid;
if ((procid = atooid((char*)list_nth(elemlist, 1))) >= FirstBootstrapObjectId) {
return false;
}
u_sess->upg_cxt.Inplace_upgrade_next_pg_proc_oid = procid;
return true;
}
static bool check_and_assign_type_oids(List* elemlist)
{
if (list_length(elemlist) != type_oid_list_length) {
return false;
}
Oid typeoid = InvalidOid;
Oid arraytypeid = InvalidOid;
char typtype = TYPTYPE_BASE;
if ((typeoid = atooid((char*)list_nth(elemlist, 1))) >= FirstBootstrapObjectId ||
(arraytypeid = atooid((char*)list_nth(elemlist, 2))) >= FirstBootstrapObjectId ||
((typtype = *(char*)list_nth(elemlist, 3)) != TYPTYPE_BASE && typtype != TYPTYPE_PSEUDO)) {
return false;
}
u_sess->upg_cxt.Inplace_upgrade_next_pg_type_oid = typeoid;
u_sess->upg_cxt.Inplace_upgrade_next_array_pg_type_oid = arraytypeid;
u_sess->cmd_cxt.TypeCreateType = typtype;
return true;
}
static bool check_and_assign_namespace_oids(List* elemlist)
{
if (list_length(elemlist) != namespace_oid_list_length) {
return false;
}
Oid namespaceid = InvalidOid;
if ((namespaceid = atooid((char*)list_nth(elemlist, 1))) >= FirstBootstrapObjectId) {
return false;
}
u_sess->upg_cxt.Inplace_upgrade_next_pg_namespace_oid = namespaceid;
return true;
}
static bool check_and_assign_general_oids(List* elemlist)
{
if (list_length(elemlist) != general_oid_list_length) {
return false;
}
Oid generalid = InvalidOid;
if ((generalid = atooid((char*)list_nth(elemlist, 1))) >= FirstBootstrapObjectId) {
return false;
}
u_sess->upg_cxt.Inplace_upgrade_next_general_oid = generalid;
return true;
}
static bool check_inplace_upgrade_next_oids(char** newval, void** extra, GucSource source)
{
if (!u_sess->attr.attr_common.IsInplaceUpgrade && source != PGC_S_DEFAULT) {
ereport(WARNING, (errmsg("Can't set next object oids while not performing upgrade.")));
*newval = NULL;
}
if (*newval == NULL) {
return true;
}
char* rawstring = NULL;
List* elemlist = NIL;
/* Need a modifiable copy of string */
rawstring = pstrdup(*newval);
/* Parse string into list of identifiers */
if (!SplitIdentifierString(rawstring, ',', &elemlist)) {
/* syntax error in list */
GUC_check_errdetail("List syntax is invalid.");
pfree(rawstring);
list_free(elemlist);
return false;
}
char* objectkind = (char*)list_nth(elemlist, 0);
bool checkpass = false;
if (pg_strcasecmp(objectkind, "IUO_CATALOG") == 0) {
checkpass = check_and_assign_catalog_oids(elemlist);
} else if (pg_strcasecmp(objectkind, "IUO_PROC") == 0) {
checkpass = check_and_assign_proc_oids(elemlist);
} else if (pg_strcasecmp(objectkind, "IUO_TYPE") == 0) {
checkpass = check_and_assign_type_oids(elemlist);
} else if (pg_strcasecmp(objectkind, "IUO_NAMESPACE") == 0) {
checkpass = check_and_assign_namespace_oids(elemlist);
} else if (pg_strcasecmp(objectkind, "IUO_GENERAL") == 0) {
checkpass = check_and_assign_general_oids(elemlist);
} else {
GUC_check_errdetail("String of object kind is invalid.");
pfree(rawstring);
list_free(elemlist);
return false;
}
pfree(rawstring);
list_free(elemlist);
if (!checkpass) {
GUC_check_errdetail("Format of object oid assignment is invalid.");
return false;
} else {
return true;
}
}
/*
* @Description: parse analysis options name and check its validation.
* @in/out options : to remember all the found analysis option id
* @in/out opt_num : size of AnalysisOpt[]
* @in anls_opt_name : this analysis option name
* @in anls_opt_name_len : size of this analysis option name
* @out all_found : "ALL" analysis option name is found
* @return : true if parse options successfully
*/
static inline bool analysis_options_parse_name(
char* anls_opt_name, int anls_opt_name_len, AnalysisOpt* options, int* opt_num, bool* all_found)
{
if (anls_opt_name_len > 0 && anls_opt_name_len < ANLS_OPT_NAME_MAXLEN) {
AnalysisOpt anls_option = ANLS_MAX;
const char ch = anls_opt_name[anls_opt_name_len];
/* judge whether it's a valid analysis option name */
anls_opt_name[anls_opt_name_len] = '\0';
anls_option = get_anls_opt_id(anls_opt_name);
if (anls_option == ANLS_MAX) {
/* bad format: not existing analysis option name */
GUC_check_errmsg(ERRMSG_MODNAME_NOT_FOUND, anls_opt_name);
GUC_check_errhint(HINT_QUERY_ALL_MODULES);
/* needn't to resotre the replaced char because it's a copy of new value. */
return false;
}
/* repeat set is not allow */
for (int i = 0; i < *opt_num; i++) {
if (options[i] == anls_option) {
GUC_check_errmsg("repeat option: %s.", anls_opt_name);
GUC_check_errdetail("Please don't set analysis option name repeatedly.");
return false;
}
}
anls_opt_name[anls_opt_name_len] = ch; /* restore the replaced char */
if (anls_option == ANLS_ALL) {
*all_found = true;
}
options[*opt_num] = anls_option;
(*opt_num)++;
return true;
} else {
/* bad format: empty string or not valid module name */
if (anls_opt_name_len == 0) {
GUC_check_errmsg(ERRMSG_EMPTY_MODULE_NAME);
GUC_check_errdetail("analysis option name cannot be empty.");
} else {
/* needn't to resotre the replaced char because it's a copy of new value. */
anls_opt_name[anls_opt_name_len] = '\0';
GUC_check_errmsg(ERRMSG_MODNAME_NOT_FOUND, anls_opt_name);
}
GUC_check_errhint(HINT_QUERY_ALL_MODULES);
return false;
}
}
/*
* @Description:
* 1. format is a) on(anls_opt1, anls_opt2, ...) or b) off(anls_opt3, anls_opt4, ...)
* 2. analysis option name is valid
* If all the conditions hold, apply these changes to this session and return true;
* otherwise return false.
* @in newval : analysis-options's new value
* @return : if newval is well-formatted, return true; otherwise return false.
*/
template <bool assign>
static bool analysis_options_guc_check(char* newval)
{
char* p = newval;
bool all_found = false;
bool turn_on = false;
/* forbit that no option name appear between two delimiters, or between delimiter and ')' */
bool delim_found = false;
/* treat all the error type as syntax error. */
GUC_check_errcode(ERRCODE_SYNTAX_ERROR);
if (!string_guc_keyword_matched(&p, &turn_on)) {
return false;
}
if (!string_guc_list_start(&p)) {
return false;
}
AnalysisOpt* options = (AnalysisOpt*)palloc(sizeof(AnalysisOpt) * ANLS_MAX);
int opt_num = 0;
while (*p && *p != ')') {
/* remember the start of option name */
char* anls_opt_name = p;
/* fine the end char of option name */
while (*p && (*p != OPTION_DELIMITER && *p != ' ' && *p != ')')) {
++p;
}
if (!analysis_options_parse_name(anls_opt_name, p - anls_opt_name, options, &opt_num, &all_found) ||
!string_guc_list_find_next_name(&p, &delim_found)) {
pfree_ext(options);
return false;
}
}
if (!string_guc_list_end(&p, delim_found)) {
pfree_ext(options);
return false;
}
if (assign) {
anls_opt_batch_set(options, opt_num, turn_on, all_found);
}
pfree_ext(options);
return true;
}
/*
* @Description: show the content of GUC "analysis_options"
* @return : analysis_options descripting text
*/
static const char* analysis_options_guc_show(void)
{
/*
* showing results is as following:
* ALL, on(anls_opt1, anls_opt2, ...), off(anls_opt3, anls_opt4, ...)
*/
StringInfoData outbuf;
initStringInfo(&outbuf);
const char* anls_opt_name = NULL;
bool rm_last_delim = false;
/* copy the special "ALL" */
anls_opt_name = get_valid_anls_opt_name(ANLS_ALL);
appendStringInfo(&outbuf, "%s%c", anls_opt_name, OPTION_DELIMITER);
/* copy the string "on(" */
appendStringInfo(&outbuf, "on(");
/* copy each analysis option name whose analysis option is enable */
rm_last_delim = false;
for (int i = ANLS_ALL + 1; i < ANLS_MAX; i++) {
if (anls_opt_is_on((AnalysisOpt)i)) {
/* For condition and anls_opt_is_on() will assure its requirement. */
anls_opt_name = get_valid_anls_opt_name((AnalysisOpt)i);
appendStringInfo(&outbuf, "%s%c", anls_opt_name, OPTION_DELIMITER);
rm_last_delim = true;
}
}
if (rm_last_delim) {
--outbuf.len;
outbuf.data[outbuf.len] = '\0';
}
/* copy the string "), off(" */
appendStringInfo(&outbuf, "),off(");
/* copy each option name whose analysis is disable */
rm_last_delim = false;
for (int i = ANLS_ALL + 1; i < ANLS_MAX; i++) {
if (!anls_opt_is_on((AnalysisOpt)i)) {
/* For condition will assure its requirement. */
anls_opt_name = get_valid_anls_opt_name((AnalysisOpt)i);
appendStringInfo(&outbuf, "%s%c", anls_opt_name, OPTION_DELIMITER);
rm_last_delim = true;
}
}
if (rm_last_delim) {
--outbuf.len;
outbuf.data[outbuf.len] = '\0';
}
/* end with string ")" */
appendStringInfoChar(&outbuf, ')');
return outbuf.data;
}
static bool transparent_encrypt_kms_url_region_check(char** newval, void** extra, GucSource source)
{
char RFC3986_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~!*'();:@&=+$,/?#[]";
char* val = NULL;
const int MAX_URL_LEN = 2048; /* The max length of URL */
if (newval == NULL || *newval == NULL) {
return true;
}
/* Check if the url contains illegal characters. */
for (val = *newval; *val; val++) {
if (strchr(RFC3986_chars, *val) == NULL) {
return false;
}
}
if ((val - *newval) > MAX_URL_LEN) {
return false;
}
return true;
}
/*
* @Description: check whether new value is well-formatted for GUC analysis options.
* @in extra : unused
* @in source : unuse
* @in newval : new value
* @return : if newval is well-formatted, return true; otherwise return false.
*/
static bool analysis_options_check(char** newval, void** extra, GucSource source)
{
((void)extra); /* not used argument */
((void)source); /* not used argument */
char* tmp_new_val = pstrdup(*newval);
bool ret = analysis_options_guc_check<false>(tmp_new_val);
pfree(tmp_new_val);
return ret;
}
/*
* @Description: update analysis_options according new value.
* @in extra : unused
* @in newval : new value
*/
static void analysis_options_guc_assign(const char* newval, void* extra)
{
((void)extra); /* not used argument */
char* tmp_new_val = pstrdup(newval);
/* analysis_options_check() will be called first,
* so here don't care returned value */
(void)analysis_options_guc_check<true>(tmp_new_val);
pfree(tmp_new_val);
}
typedef struct behavior_compat_entry {
const char* name; /* name of behavior compat entry */
int flag; /* bit flag position */
} behavior_compat_entry;
static struct behavior_compat_entry behavior_compat_options[OPT_MAX] = {
{"display_leading_zero", OPT_DISPLAY_LEADING_ZERO},
{"end_month_calculate", OPT_END_MONTH_CALCULATE},
{"compat_analyze_sample", OPT_COMPAT_ANALYZE_SAMPLE},
{"bind_schema_tablespace", OPT_BIND_SCHEMA_TABLESPACE},
{"return_null_string", OPT_RETURN_NS_OR_NULL},
{"bind_procedure_searchpath", OPT_BIND_SEARCHPATH},
{"unbind_divide_bound", OPT_UNBIND_DIVIDE_BOUND},
{"correct_to_number", OPT_CORRECT_TO_NUMBER},
{"compat_concat_variadic", OPT_CONCAT_VARIADIC},
{"merge_update_multi", OPT_MEGRE_UPDATE_MULTI},
{"convert_string_digit_to_numeric", OPT_CONVERT_TO_NUMERIC}};
/*
* check_behavior_compat_options: GUC check_hook for behavior compat options
*/
static bool check_behavior_compat_options(char** newval, void** extra, GucSource source)
{
char* rawstring = NULL;
List* elemlist = NULL;
ListCell* cell = NULL;
int start = 0;
/* Need a modifiable copy of string */
rawstring = pstrdup(*newval);
/* Parse string into list of identifiers */
if (!SplitIdentifierString(rawstring, ',', &elemlist)) {
/* syntax error in list */
GUC_check_errdetail("invalid paramater for behavior compat information.");
pfree(rawstring);
list_free(elemlist);
return false;
}
foreach (cell, elemlist) {
const char* item = (const char*)lfirst(cell);
bool nfound = true;
for (start = 0; start < OPT_MAX; start++) {
if (0 == strcmp(item, behavior_compat_options[start].name)) {
nfound = false;
break;
}
}
if (nfound) {
GUC_check_errdetail("invalid behavior compat option \"%s\"", item);
pfree(rawstring);
list_free(elemlist);
return false;
}
}
pfree(rawstring);
list_free(elemlist);
return true;
}
/*
* assign_distribute_test_param: GUC assign_hook for distribute_test_param
*/
static void assign_behavior_compat_options(const char* newval, void* extra)
{
char* rawstring = NULL;
List* elemlist = NULL;
ListCell* cell = NULL;
int start = 0;
int result = 0;
rawstring = pstrdup(newval);
(void)SplitIdentifierString(rawstring, ',', &elemlist);
u_sess->utils_cxt.behavior_compat_flags = 0;
foreach (cell, elemlist) {
for (start = 0; start < OPT_MAX; start++) {
const char* item = (const char*)lfirst(cell);
if (0 == strcmp(item, behavior_compat_options[start].name))
result += behavior_compat_options[start].flag;
}
}
pfree(rawstring);
list_free(elemlist);
u_sess->utils_cxt.behavior_compat_flags = result;
}
#ifdef ENABLE_MULTIPLE_NODES
void assign_control_group(const bool newval, void* extra)
{
if (t_thrd.proc_cxt.MyProcPid != PostmasterPid) {
return;
}
g_instance.wlm_cxt->gscgroup_init_done =
newval && u_sess->attr.attr_resource.use_workload_manager && g_instance.wlm_cxt->gscgroup_config_parsed;
}
#endif
static void assign_convert_string_to_digit(bool newval, void* extra)
{
if (u_sess->attr.attr_sql.convert_string_to_digit != newval) {
/*
* Invalidate the old operator cache whenever the convert_string_to_digit
* changed, as its change will modify type conversion priority which need
* refresh operator cache.
*/
InvalidateOprCacheCallBack(0, 0, 0);
}
return;
}
bool check_percentile(char** newval, void** extra, GucSource source)
{
char* rawname = NULL;
List* namelist = NIL;
/* Need a modifiable copy of string */
rawname = pstrdup(*newval);
/* Parse string into list of identifiers */
if (!SplitIdentifierInteger(rawname, ',', &namelist)) {
/* syntax error in name list */
GUC_check_errdetail("List syntax is invalid.");
pfree_ext(rawname);
list_free_ext(namelist);
return false;
}
/*
* We used to try to check that the named schemas exist, but there are
* many valid use-cases for having search_path settings that include
* schemas that don't exist; and often, we are not inside a transaction
* here and so can't consult the system catalogs anyway. So now, the only
* requirement is syntactic validity of the identifier list.
*/
pfree_ext(rawname);
list_free_ext(namelist);
return true;
}
static void assign_instr_unique_sql_count(int newval, void* extra)
{
/* oid of reset_instr_unique_sql */
#define RESET_UNIQUE_SQL_FUNC 5716
/* only let WLMProcessThread do the cleanup */
if (AmWLMWorkerProcess() && IS_PGXC_COORDINATOR && u_sess->attr.attr_common.instr_unique_sql_count > newval) {
bool result = DatumGetBool(OidFunctionCall3(RESET_UNIQUE_SQL_FUNC,
CStringGetTextDatum("GLOBAL"),
CStringGetTextDatum("BY_GUC"),
Int32GetDatum(newval)));
ereport(LOG,
(errmodule(MOD_INSTR),
errmsg("[UniqueSQL] cleanup unique sql due to instr_unique_sql_count shrunk: %s",
result ? "success" : "fail")));
}
}
/*
* callback function for numa_distribute_mode checking.
*/
bool check_numa_distribute_mode(char** newval, void** extra, GucSource source)
{
#ifdef __USE_NUMA
if (strcmp(*newval, "all") == 0) {
return true;
}
#endif
if (strcmp(*newval, "none") == 0) {
return true;
}
return false;
}
#include "guc-file.cpp"
Reference in New Issue View Git Blame Copy Permalink