PostgreSQL Source Code  git master
guc_tables.c
Go to the documentation of this file.
1 /*--------------------------------------------------------------------
2  *
3  * guc_tables.c
4  *
5  * Static tables for the Grand Unified Configuration scheme.
6  *
7  * Many of these tables are const. However, ConfigureNamesBool[]
8  * and so on are not, because the structs in those arrays are actually
9  * the live per-variable state data that guc.c manipulates. While many of
10  * their fields are intended to be constant, some fields change at runtime.
11  *
12  *
13  * Copyright (c) 2000-2023, PostgreSQL Global Development Group
14  * Written by Peter Eisentraut <peter_e@gmx.net>.
15  *
16  * IDENTIFICATION
17  * src/backend/utils/misc/guc_tables.c
18  *
19  *--------------------------------------------------------------------
20  */
21 #include "postgres.h"
22 
23 #include <float.h>
24 #include <limits.h>
25 #ifdef HAVE_SYSLOG
26 #include <syslog.h>
27 #endif
28 
29 #include "access/commit_ts.h"
30 #include "access/gin.h"
31 #include "access/toast_compression.h"
32 #include "access/twophase.h"
33 #include "access/xlog_internal.h"
34 #include "access/xlogprefetcher.h"
35 #include "access/xlogrecovery.h"
36 #include "archive/archive_module.h"
37 #include "catalog/namespace.h"
38 #include "catalog/storage.h"
39 #include "commands/async.h"
40 #include "commands/tablespace.h"
41 #include "commands/trigger.h"
42 #include "commands/user.h"
43 #include "commands/vacuum.h"
44 #include "common/scram-common.h"
45 #include "jit/jit.h"
46 #include "libpq/auth.h"
47 #include "libpq/libpq.h"
48 #include "libpq/scram.h"
49 #include "nodes/queryjumble.h"
50 #include "optimizer/cost.h"
51 #include "optimizer/geqo.h"
52 #include "optimizer/optimizer.h"
53 #include "optimizer/paths.h"
54 #include "optimizer/planmain.h"
55 #include "parser/parse_expr.h"
56 #include "parser/parser.h"
57 #include "pgstat.h"
58 #include "postmaster/autovacuum.h"
59 #include "postmaster/bgworker_internals.h"
60 #include "postmaster/bgwriter.h"
61 #include "postmaster/postmaster.h"
62 #include "postmaster/startup.h"
63 #include "postmaster/syslogger.h"
64 #include "postmaster/walwriter.h"
65 #include "replication/logicallauncher.h"
66 #include "replication/slot.h"
67 #include "replication/syncrep.h"
68 #include "storage/bufmgr.h"
69 #include "storage/large_object.h"
70 #include "storage/pg_shmem.h"
71 #include "storage/predicate.h"
72 #include "storage/standby.h"
73 #include "tcop/tcopprot.h"
74 #include "tsearch/ts_cache.h"
75 #include "utils/builtins.h"
76 #include "utils/bytea.h"
77 #include "utils/float.h"
78 #include "utils/guc_hooks.h"
79 #include "utils/guc_tables.h"
80 #include "utils/memutils.h"
81 #include "utils/pg_locale.h"
82 #include "utils/portal.h"
83 #include "utils/ps_status.h"
84 #include "utils/inval.h"
85 #include "utils/xml.h"
86 
87 /* This value is normally passed in from the Makefile */
88 #ifndef PG_KRB_SRVTAB
89 #define PG_KRB_SRVTAB ""
90 #endif
91 
92 /* XXX these should appear in other modules' header files */
93 extern bool Log_disconnections;
94 extern int CommitDelay;
95 extern int CommitSiblings;
96 extern char *default_tablespace;
97 extern char *temp_tablespaces;
98 extern bool ignore_checksum_failure;
99 extern bool ignore_invalid_pages;
100 extern bool synchronize_seqscans;
101 
102 #ifdef TRACE_SYNCSCAN
103 extern bool trace_syncscan;
104 #endif
105 #ifdef DEBUG_BOUNDED_SORT
106 extern bool optimize_bounded_sort;
107 #endif
108 
109 /*
110  * Options for enum values defined in this module.
111  *
112  * NOTE! Option values may not contain double quotes!
113  */
114 
115 static const struct config_enum_entry bytea_output_options[] = {
116  {"escape", BYTEA_OUTPUT_ESCAPE, false},
117  {"hex", BYTEA_OUTPUT_HEX, false},
118  {NULL, 0, false}
119 };
120 
121 StaticAssertDecl(lengthof(bytea_output_options) == (BYTEA_OUTPUT_HEX + 2),
122  "array length mismatch");
123 
124 /*
125  * We have different sets for client and server message level options because
126  * they sort slightly different (see "log" level), and because "fatal"/"panic"
127  * aren't sensible for client_min_messages.
128  */
129 static const struct config_enum_entry client_message_level_options[] = {
130  {"debug5", DEBUG5, false},
131  {"debug4", DEBUG4, false},
132  {"debug3", DEBUG3, false},
133  {"debug2", DEBUG2, false},
134  {"debug1", DEBUG1, false},
135  {"debug", DEBUG2, true},
136  {"log", LOG, false},
137  {"info", INFO, true},
138  {"notice", NOTICE, false},
139  {"warning", WARNING, false},
140  {"error", ERROR, false},
141  {NULL, 0, false}
142 };
143 
144 static const struct config_enum_entry server_message_level_options[] = {
145  {"debug5", DEBUG5, false},
146  {"debug4", DEBUG4, false},
147  {"debug3", DEBUG3, false},
148  {"debug2", DEBUG2, false},
149  {"debug1", DEBUG1, false},
150  {"debug", DEBUG2, true},
151  {"info", INFO, false},
152  {"notice", NOTICE, false},
153  {"warning", WARNING, false},
154  {"error", ERROR, false},
155  {"log", LOG, false},
156  {"fatal", FATAL, false},
157  {"panic", PANIC, false},
158  {NULL, 0, false}
159 };
160 
161 static const struct config_enum_entry intervalstyle_options[] = {
162  {"postgres", INTSTYLE_POSTGRES, false},
163  {"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
164  {"sql_standard", INTSTYLE_SQL_STANDARD, false},
165  {"iso_8601", INTSTYLE_ISO_8601, false},
166  {NULL, 0, false}
167 };
168 
169 static const struct config_enum_entry icu_validation_level_options[] = {
170  {"disabled", -1, false},
171  {"debug5", DEBUG5, false},
172  {"debug4", DEBUG4, false},
173  {"debug3", DEBUG3, false},
174  {"debug2", DEBUG2, false},
175  {"debug1", DEBUG1, false},
176  {"debug", DEBUG2, true},
177  {"log", LOG, false},
178  {"info", INFO, true},
179  {"notice", NOTICE, false},
180  {"warning", WARNING, false},
181  {"error", ERROR, false},
182  {NULL, 0, false}
183 };
184 
185 StaticAssertDecl(lengthof(intervalstyle_options) == (INTSTYLE_ISO_8601 + 2),
186  "array length mismatch");
187 
188 static const struct config_enum_entry log_error_verbosity_options[] = {
189  {"terse", PGERROR_TERSE, false},
190  {"default", PGERROR_DEFAULT, false},
191  {"verbose", PGERROR_VERBOSE, false},
192  {NULL, 0, false}
193 };
194 
195 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
196  "array length mismatch");
197 
198 static const struct config_enum_entry log_statement_options[] = {
199  {"none", LOGSTMT_NONE, false},
200  {"ddl", LOGSTMT_DDL, false},
201  {"mod", LOGSTMT_MOD, false},
202  {"all", LOGSTMT_ALL, false},
203  {NULL, 0, false}
204 };
205 
206 StaticAssertDecl(lengthof(log_statement_options) == (LOGSTMT_ALL + 2),
207  "array length mismatch");
208 
209 static const struct config_enum_entry isolation_level_options[] = {
210  {"serializable", XACT_SERIALIZABLE, false},
211  {"repeatable read", XACT_REPEATABLE_READ, false},
212  {"read committed", XACT_READ_COMMITTED, false},
213  {"read uncommitted", XACT_READ_UNCOMMITTED, false},
214  {NULL, 0}
215 };
216 
217 static const struct config_enum_entry session_replication_role_options[] = {
218  {"origin", SESSION_REPLICATION_ROLE_ORIGIN, false},
219  {"replica", SESSION_REPLICATION_ROLE_REPLICA, false},
220  {"local", SESSION_REPLICATION_ROLE_LOCAL, false},
221  {NULL, 0, false}
222 };
223 
224 StaticAssertDecl(lengthof(session_replication_role_options) == (SESSION_REPLICATION_ROLE_LOCAL + 2),
225  "array length mismatch");
226 
227 static const struct config_enum_entry syslog_facility_options[] = {
228 #ifdef HAVE_SYSLOG
229  {"local0", LOG_LOCAL0, false},
230  {"local1", LOG_LOCAL1, false},
231  {"local2", LOG_LOCAL2, false},
232  {"local3", LOG_LOCAL3, false},
233  {"local4", LOG_LOCAL4, false},
234  {"local5", LOG_LOCAL5, false},
235  {"local6", LOG_LOCAL6, false},
236  {"local7", LOG_LOCAL7, false},
237 #else
238  {"none", 0, false},
239 #endif
240  {NULL, 0}
241 };
242 
243 static const struct config_enum_entry track_function_options[] = {
244  {"none", TRACK_FUNC_OFF, false},
245  {"pl", TRACK_FUNC_PL, false},
246  {"all", TRACK_FUNC_ALL, false},
247  {NULL, 0, false}
248 };
249 
250 StaticAssertDecl(lengthof(track_function_options) == (TRACK_FUNC_ALL + 2),
251  "array length mismatch");
252 
253 static const struct config_enum_entry stats_fetch_consistency[] = {
254  {"none", PGSTAT_FETCH_CONSISTENCY_NONE, false},
255  {"cache", PGSTAT_FETCH_CONSISTENCY_CACHE, false},
256  {"snapshot", PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, false},
257  {NULL, 0, false}
258 };
259 
260 StaticAssertDecl(lengthof(stats_fetch_consistency) == (PGSTAT_FETCH_CONSISTENCY_SNAPSHOT + 2),
261  "array length mismatch");
262 
263 static const struct config_enum_entry xmlbinary_options[] = {
264  {"base64", XMLBINARY_BASE64, false},
265  {"hex", XMLBINARY_HEX, false},
266  {NULL, 0, false}
267 };
268 
269 StaticAssertDecl(lengthof(xmlbinary_options) == (XMLBINARY_HEX + 2),
270  "array length mismatch");
271 
272 static const struct config_enum_entry xmloption_options[] = {
273  {"content", XMLOPTION_CONTENT, false},
274  {"document", XMLOPTION_DOCUMENT, false},
275  {NULL, 0, false}
276 };
277 
278 StaticAssertDecl(lengthof(xmloption_options) == (XMLOPTION_CONTENT + 2),
279  "array length mismatch");
280 
281 /*
282  * Although only "on", "off", and "safe_encoding" are documented, we
283  * accept all the likely variants of "on" and "off".
284  */
285 static const struct config_enum_entry backslash_quote_options[] = {
286  {"safe_encoding", BACKSLASH_QUOTE_SAFE_ENCODING, false},
287  {"on", BACKSLASH_QUOTE_ON, false},
288  {"off", BACKSLASH_QUOTE_OFF, false},
289  {"true", BACKSLASH_QUOTE_ON, true},
290  {"false", BACKSLASH_QUOTE_OFF, true},
291  {"yes", BACKSLASH_QUOTE_ON, true},
292  {"no", BACKSLASH_QUOTE_OFF, true},
293  {"1", BACKSLASH_QUOTE_ON, true},
294  {"0", BACKSLASH_QUOTE_OFF, true},
295  {NULL, 0, false}
296 };
297 
298 /*
299  * Although only "on", "off", and "auto" are documented, we accept
300  * all the likely variants of "on" and "off".
301  */
302 static const struct config_enum_entry compute_query_id_options[] = {
303  {"auto", COMPUTE_QUERY_ID_AUTO, false},
304  {"regress", COMPUTE_QUERY_ID_REGRESS, false},
305  {"on", COMPUTE_QUERY_ID_ON, false},
306  {"off", COMPUTE_QUERY_ID_OFF, false},
307  {"true", COMPUTE_QUERY_ID_ON, true},
308  {"false", COMPUTE_QUERY_ID_OFF, true},
309  {"yes", COMPUTE_QUERY_ID_ON, true},
310  {"no", COMPUTE_QUERY_ID_OFF, true},
311  {"1", COMPUTE_QUERY_ID_ON, true},
312  {"0", COMPUTE_QUERY_ID_OFF, true},
313  {NULL, 0, false}
314 };
315 
316 /*
317  * Although only "on", "off", and "partition" are documented, we
318  * accept all the likely variants of "on" and "off".
319  */
320 static const struct config_enum_entry constraint_exclusion_options[] = {
321  {"partition", CONSTRAINT_EXCLUSION_PARTITION, false},
322  {"on", CONSTRAINT_EXCLUSION_ON, false},
323  {"off", CONSTRAINT_EXCLUSION_OFF, false},
324  {"true", CONSTRAINT_EXCLUSION_ON, true},
325  {"false", CONSTRAINT_EXCLUSION_OFF, true},
326  {"yes", CONSTRAINT_EXCLUSION_ON, true},
327  {"no", CONSTRAINT_EXCLUSION_OFF, true},
328  {"1", CONSTRAINT_EXCLUSION_ON, true},
329  {"0", CONSTRAINT_EXCLUSION_OFF, true},
330  {NULL, 0, false}
331 };
332 
333 /*
334  * Although only "on", "off", "remote_apply", "remote_write", and "local" are
335  * documented, we accept all the likely variants of "on" and "off".
336  */
337 static const struct config_enum_entry synchronous_commit_options[] = {
338  {"local", SYNCHRONOUS_COMMIT_LOCAL_FLUSH, false},
339  {"remote_write", SYNCHRONOUS_COMMIT_REMOTE_WRITE, false},
340  {"remote_apply", SYNCHRONOUS_COMMIT_REMOTE_APPLY, false},
341  {"on", SYNCHRONOUS_COMMIT_ON, false},
342  {"off", SYNCHRONOUS_COMMIT_OFF, false},
343  {"true", SYNCHRONOUS_COMMIT_ON, true},
344  {"false", SYNCHRONOUS_COMMIT_OFF, true},
345  {"yes", SYNCHRONOUS_COMMIT_ON, true},
346  {"no", SYNCHRONOUS_COMMIT_OFF, true},
347  {"1", SYNCHRONOUS_COMMIT_ON, true},
348  {"0", SYNCHRONOUS_COMMIT_OFF, true},
349  {NULL, 0, false}
350 };
351 
352 /*
353  * Although only "on", "off", "try" are documented, we accept all the likely
354  * variants of "on" and "off".
355  */
356 static const struct config_enum_entry huge_pages_options[] = {
357  {"off", HUGE_PAGES_OFF, false},
358  {"on", HUGE_PAGES_ON, false},
359  {"try", HUGE_PAGES_TRY, false},
360  {"true", HUGE_PAGES_ON, true},
361  {"false", HUGE_PAGES_OFF, true},
362  {"yes", HUGE_PAGES_ON, true},
363  {"no", HUGE_PAGES_OFF, true},
364  {"1", HUGE_PAGES_ON, true},
365  {"0", HUGE_PAGES_OFF, true},
366  {NULL, 0, false}
367 };
368 
369 static const struct config_enum_entry recovery_prefetch_options[] = {
370  {"off", RECOVERY_PREFETCH_OFF, false},
371  {"on", RECOVERY_PREFETCH_ON, false},
372  {"try", RECOVERY_PREFETCH_TRY, false},
373  {"true", RECOVERY_PREFETCH_ON, true},
374  {"false", RECOVERY_PREFETCH_OFF, true},
375  {"yes", RECOVERY_PREFETCH_ON, true},
376  {"no", RECOVERY_PREFETCH_OFF, true},
377  {"1", RECOVERY_PREFETCH_ON, true},
378  {"0", RECOVERY_PREFETCH_OFF, true},
379  {NULL, 0, false}
380 };
381 
382 static const struct config_enum_entry debug_parallel_query_options[] = {
383  {"off", DEBUG_PARALLEL_OFF, false},
384  {"on", DEBUG_PARALLEL_ON, false},
385  {"regress", DEBUG_PARALLEL_REGRESS, false},
386  {"true", DEBUG_PARALLEL_ON, true},
387  {"false", DEBUG_PARALLEL_OFF, true},
388  {"yes", DEBUG_PARALLEL_ON, true},
389  {"no", DEBUG_PARALLEL_OFF, true},
390  {"1", DEBUG_PARALLEL_ON, true},
391  {"0", DEBUG_PARALLEL_OFF, true},
392  {NULL, 0, false}
393 };
394 
395 static const struct config_enum_entry plan_cache_mode_options[] = {
396  {"auto", PLAN_CACHE_MODE_AUTO, false},
397  {"force_generic_plan", PLAN_CACHE_MODE_FORCE_GENERIC_PLAN, false},
398  {"force_custom_plan", PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN, false},
399  {NULL, 0, false}
400 };
401 
402 static const struct config_enum_entry password_encryption_options[] = {
403  {"md5", PASSWORD_TYPE_MD5, false},
404  {"scram-sha-256", PASSWORD_TYPE_SCRAM_SHA_256, false},
405  {NULL, 0, false}
406 };
407 
408 static const struct config_enum_entry ssl_protocol_versions_info[] = {
409  {"", PG_TLS_ANY, false},
410  {"TLSv1", PG_TLS1_VERSION, false},
411  {"TLSv1.1", PG_TLS1_1_VERSION, false},
412  {"TLSv1.2", PG_TLS1_2_VERSION, false},
413  {"TLSv1.3", PG_TLS1_3_VERSION, false},
414  {NULL, 0, false}
415 };
416 
417 static const struct config_enum_entry logical_replication_mode_options[] = {
418  {"buffered", LOGICAL_REP_MODE_BUFFERED, false},
419  {"immediate", LOGICAL_REP_MODE_IMMEDIATE, false},
420  {NULL, 0, false}
421 };
422 
423 StaticAssertDecl(lengthof(ssl_protocol_versions_info) == (PG_TLS1_3_VERSION + 2),
424  "array length mismatch");
425 
426 static const struct config_enum_entry recovery_init_sync_method_options[] = {
427  {"fsync", RECOVERY_INIT_SYNC_METHOD_FSYNC, false},
428 #ifdef HAVE_SYNCFS
429  {"syncfs", RECOVERY_INIT_SYNC_METHOD_SYNCFS, false},
430 #endif
431  {NULL, 0, false}
432 };
433 
434 static const struct config_enum_entry shared_memory_options[] = {
435 #ifndef WIN32
436  {"sysv", SHMEM_TYPE_SYSV, false},
437 #endif
438 #ifndef EXEC_BACKEND
439  {"mmap", SHMEM_TYPE_MMAP, false},
440 #endif
441 #ifdef WIN32
442  {"windows", SHMEM_TYPE_WINDOWS, false},
443 #endif
444  {NULL, 0, false}
445 };
446 
447 static const struct config_enum_entry default_toast_compression_options[] = {
448  {"pglz", TOAST_PGLZ_COMPRESSION, false},
449 #ifdef USE_LZ4
450  {"lz4", TOAST_LZ4_COMPRESSION, false},
451 #endif
452  {NULL, 0, false}
453 };
454 
455 static const struct config_enum_entry wal_compression_options[] = {
456  {"pglz", WAL_COMPRESSION_PGLZ, false},
457 #ifdef USE_LZ4
458  {"lz4", WAL_COMPRESSION_LZ4, false},
459 #endif
460 #ifdef USE_ZSTD
461  {"zstd", WAL_COMPRESSION_ZSTD, false},
462 #endif
463  {"on", WAL_COMPRESSION_PGLZ, false},
464  {"off", WAL_COMPRESSION_NONE, false},
465  {"true", WAL_COMPRESSION_PGLZ, true},
466  {"false", WAL_COMPRESSION_NONE, true},
467  {"yes", WAL_COMPRESSION_PGLZ, true},
468  {"no", WAL_COMPRESSION_NONE, true},
469  {"1", WAL_COMPRESSION_PGLZ, true},
470  {"0", WAL_COMPRESSION_NONE, true},
471  {NULL, 0, false}
472 };
473 
474 /*
475  * Options for enum values stored in other modules
476  */
477 extern const struct config_enum_entry wal_level_options[];
478 extern const struct config_enum_entry archive_mode_options[];
479 extern const struct config_enum_entry recovery_target_action_options[];
480 extern const struct config_enum_entry sync_method_options[];
481 extern const struct config_enum_entry dynamic_shared_memory_options[];
482 
483 /*
484  * GUC option variables that are exported from this module
485  */
486 bool log_duration = false;
487 bool Debug_print_plan = false;
488 bool Debug_print_parse = false;
489 bool Debug_print_rewritten = false;
490 bool Debug_pretty_print = true;
491 
492 bool log_parser_stats = false;
493 bool log_planner_stats = false;
494 bool log_executor_stats = false;
495 bool log_statement_stats = false; /* this is sort of all three above
496  * together */
497 bool log_btree_build_stats = false;
498 char *event_source;
499 
500 bool row_security;
501 bool check_function_bodies = true;
502 
503 /*
504  * This GUC exists solely for backward compatibility, check its definition for
505  * details.
506  */
507 bool default_with_oids = false;
508 bool session_auth_is_superuser;
509 
510 int log_min_error_statement = ERROR;
511 int log_min_messages = WARNING;
512 int client_min_messages = NOTICE;
513 int log_min_duration_sample = -1;
514 int log_min_duration_statement = -1;
515 int log_parameter_max_length = -1;
516 int log_parameter_max_length_on_error = 0;
517 int log_temp_files = -1;
518 double log_statement_sample_rate = 1.0;
519 double log_xact_sample_rate = 0;
520 int trace_recovery_messages = LOG;
521 char *backtrace_functions;
522 
523 int temp_file_limit = -1;
524 
525 int num_temp_buffers = 1024;
526 
527 char *cluster_name = "";
528 char *ConfigFileName;
529 char *HbaFileName;
530 char *IdentFileName;
531 char *external_pid_file;
532 
533 char *pgstat_temp_directory;
534 
535 char *application_name;
536 
537 int tcp_keepalives_idle;
538 int tcp_keepalives_interval;
539 int tcp_keepalives_count;
540 int tcp_user_timeout;
541 
542 /*
543  * SSL renegotiation was been removed in PostgreSQL 9.5, but we tolerate it
544  * being set to zero (meaning never renegotiate) for backward compatibility.
545  * This avoids breaking compatibility with clients that have never supported
546  * renegotiation and therefore always try to zero it.
547  */
548 int ssl_renegotiation_limit;
549 
550 /*
551  * This really belongs in pg_shmem.c, but is defined here so that it doesn't
552  * need to be duplicated in all the different implementations of pg_shmem.c.
553  */
554 int huge_pages = HUGE_PAGES_TRY;
555 int huge_page_size;
556 
557 /*
558  * These variables are all dummies that don't do anything, except in some
559  * cases provide the value for SHOW to display. The real state is elsewhere
560  * and is kept in sync by assign_hooks.
561  */
562 static char *syslog_ident_str;
563 static double phony_random_seed;
564 static char *client_encoding_string;
565 static char *datestyle_string;
566 static char *locale_collate;
567 static char *locale_ctype;
568 static char *server_encoding_string;
569 static char *server_version_string;
570 static int server_version_num;
571 static char *io_direct_string;
572 
573 #ifdef HAVE_SYSLOG
574 #define DEFAULT_SYSLOG_FACILITY LOG_LOCAL0
575 #else
576 #define DEFAULT_SYSLOG_FACILITY 0
577 #endif
578 static int syslog_facility = DEFAULT_SYSLOG_FACILITY;
579 
580 static char *timezone_string;
581 static char *log_timezone_string;
582 static char *timezone_abbreviations_string;
583 static char *data_directory;
584 static char *session_authorization_string;
585 static int max_function_args;
586 static int max_index_keys;
587 static int max_identifier_length;
588 static int block_size;
589 static int segment_size;
590 static int shared_memory_size_mb;
591 static int shared_memory_size_in_huge_pages;
592 static int wal_block_size;
593 static bool data_checksums;
594 static bool integer_datetimes;
595 
596 #ifdef USE_ASSERT_CHECKING
597 #define DEFAULT_ASSERT_ENABLED true
598 #else
599 #define DEFAULT_ASSERT_ENABLED false
600 #endif
601 static bool assert_enabled = DEFAULT_ASSERT_ENABLED;
602 
603 static char *recovery_target_timeline_string;
604 static char *recovery_target_string;
605 static char *recovery_target_xid_string;
606 static char *recovery_target_name_string;
607 static char *recovery_target_lsn_string;
608 
609 /* should be static, but commands/variable.c needs to get at this */
610 char *role_string;
611 
612 /* should be static, but guc.c needs to get at this */
613 bool in_hot_standby_guc;
614 
615 
616 /*
617  * Displayable names for context types (enum GucContext)
618  *
619  * Note: these strings are deliberately not localized.
620  */
621 const char *const GucContext_Names[] =
622 {
623  /* PGC_INTERNAL */ "internal",
624  /* PGC_POSTMASTER */ "postmaster",
625  /* PGC_SIGHUP */ "sighup",
626  /* PGC_SU_BACKEND */ "superuser-backend",
627  /* PGC_BACKEND */ "backend",
628  /* PGC_SUSET */ "superuser",
629  /* PGC_USERSET */ "user"
630 };
631 
632 StaticAssertDecl(lengthof(GucContext_Names) == (PGC_USERSET + 1),
633  "array length mismatch");
634 
635 /*
636  * Displayable names for source types (enum GucSource)
637  *
638  * Note: these strings are deliberately not localized.
639  */
640 const char *const GucSource_Names[] =
641 {
642  /* PGC_S_DEFAULT */ "default",
643  /* PGC_S_DYNAMIC_DEFAULT */ "default",
644  /* PGC_S_ENV_VAR */ "environment variable",
645  /* PGC_S_FILE */ "configuration file",
646  /* PGC_S_ARGV */ "command line",
647  /* PGC_S_GLOBAL */ "global",
648  /* PGC_S_DATABASE */ "database",
649  /* PGC_S_USER */ "user",
650  /* PGC_S_DATABASE_USER */ "database user",
651  /* PGC_S_CLIENT */ "client",
652  /* PGC_S_OVERRIDE */ "override",
653  /* PGC_S_INTERACTIVE */ "interactive",
654  /* PGC_S_TEST */ "test",
655  /* PGC_S_SESSION */ "session"
656 };
657 
658 StaticAssertDecl(lengthof(GucSource_Names) == (PGC_S_SESSION + 1),
659  "array length mismatch");
660 
661 /*
662  * Displayable names for the groupings defined in enum config_group
663  */
664 const char *const config_group_names[] =
665 {
666  /* UNGROUPED */
667  gettext_noop("Ungrouped"),
668  /* FILE_LOCATIONS */
669  gettext_noop("File Locations"),
670  /* CONN_AUTH_SETTINGS */
671  gettext_noop("Connections and Authentication / Connection Settings"),
672  /* CONN_AUTH_TCP */
673  gettext_noop("Connections and Authentication / TCP Settings"),
674  /* CONN_AUTH_AUTH */
675  gettext_noop("Connections and Authentication / Authentication"),
676  /* CONN_AUTH_SSL */
677  gettext_noop("Connections and Authentication / SSL"),
678  /* RESOURCES_MEM */
679  gettext_noop("Resource Usage / Memory"),
680  /* RESOURCES_DISK */
681  gettext_noop("Resource Usage / Disk"),
682  /* RESOURCES_KERNEL */
683  gettext_noop("Resource Usage / Kernel Resources"),
684  /* RESOURCES_VACUUM_DELAY */
685  gettext_noop("Resource Usage / Cost-Based Vacuum Delay"),
686  /* RESOURCES_BGWRITER */
687  gettext_noop("Resource Usage / Background Writer"),
688  /* RESOURCES_ASYNCHRONOUS */
689  gettext_noop("Resource Usage / Asynchronous Behavior"),
690  /* WAL_SETTINGS */
691  gettext_noop("Write-Ahead Log / Settings"),
692  /* WAL_CHECKPOINTS */
693  gettext_noop("Write-Ahead Log / Checkpoints"),
694  /* WAL_ARCHIVING */
695  gettext_noop("Write-Ahead Log / Archiving"),
696  /* WAL_RECOVERY */
697  gettext_noop("Write-Ahead Log / Recovery"),
698  /* WAL_ARCHIVE_RECOVERY */
699  gettext_noop("Write-Ahead Log / Archive Recovery"),
700  /* WAL_RECOVERY_TARGET */
701  gettext_noop("Write-Ahead Log / Recovery Target"),
702  /* REPLICATION_SENDING */
703  gettext_noop("Replication / Sending Servers"),
704  /* REPLICATION_PRIMARY */
705  gettext_noop("Replication / Primary Server"),
706  /* REPLICATION_STANDBY */
707  gettext_noop("Replication / Standby Servers"),
708  /* REPLICATION_SUBSCRIBERS */
709  gettext_noop("Replication / Subscribers"),
710  /* QUERY_TUNING_METHOD */
711  gettext_noop("Query Tuning / Planner Method Configuration"),
712  /* QUERY_TUNING_COST */
713  gettext_noop("Query Tuning / Planner Cost Constants"),
714  /* QUERY_TUNING_GEQO */
715  gettext_noop("Query Tuning / Genetic Query Optimizer"),
716  /* QUERY_TUNING_OTHER */
717  gettext_noop("Query Tuning / Other Planner Options"),
718  /* LOGGING_WHERE */
719  gettext_noop("Reporting and Logging / Where to Log"),
720  /* LOGGING_WHEN */
721  gettext_noop("Reporting and Logging / When to Log"),
722  /* LOGGING_WHAT */
723  gettext_noop("Reporting and Logging / What to Log"),
724  /* PROCESS_TITLE */
725  gettext_noop("Reporting and Logging / Process Title"),
726  /* STATS_MONITORING */
727  gettext_noop("Statistics / Monitoring"),
728  /* STATS_CUMULATIVE */
729  gettext_noop("Statistics / Cumulative Query and Index Statistics"),
730  /* AUTOVACUUM */
731  gettext_noop("Autovacuum"),
732  /* CLIENT_CONN_STATEMENT */
733  gettext_noop("Client Connection Defaults / Statement Behavior"),
734  /* CLIENT_CONN_LOCALE */
735  gettext_noop("Client Connection Defaults / Locale and Formatting"),
736  /* CLIENT_CONN_PRELOAD */
737  gettext_noop("Client Connection Defaults / Shared Library Preloading"),
738  /* CLIENT_CONN_OTHER */
739  gettext_noop("Client Connection Defaults / Other Defaults"),
740  /* LOCK_MANAGEMENT */
741  gettext_noop("Lock Management"),
742  /* COMPAT_OPTIONS_PREVIOUS */
743  gettext_noop("Version and Platform Compatibility / Previous PostgreSQL Versions"),
744  /* COMPAT_OPTIONS_CLIENT */
745  gettext_noop("Version and Platform Compatibility / Other Platforms and Clients"),
746  /* ERROR_HANDLING_OPTIONS */
747  gettext_noop("Error Handling"),
748  /* PRESET_OPTIONS */
749  gettext_noop("Preset Options"),
750  /* CUSTOM_OPTIONS */
751  gettext_noop("Customized Options"),
752  /* DEVELOPER_OPTIONS */
753  gettext_noop("Developer Options"),
754  /* help_config wants this array to be null-terminated */
755  NULL
756 };
757 
758 StaticAssertDecl(lengthof(config_group_names) == (DEVELOPER_OPTIONS + 2),
759  "array length mismatch");
760 
761 /*
762  * Displayable names for GUC variable types (enum config_type)
763  *
764  * Note: these strings are deliberately not localized.
765  */
766 const char *const config_type_names[] =
767 {
768  /* PGC_BOOL */ "bool",
769  /* PGC_INT */ "integer",
770  /* PGC_REAL */ "real",
771  /* PGC_STRING */ "string",
772  /* PGC_ENUM */ "enum"
773 };
774 
775 StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
776  "array length mismatch");
777 
778 
779 /*
780  * Contents of GUC tables
781  *
782  * See src/backend/utils/misc/README for design notes.
783  *
784  * TO ADD AN OPTION:
785  *
786  * 1. Declare a global variable of type bool, int, double, or char*
787  * and make use of it.
788  *
789  * 2. Decide at what times it's safe to set the option. See guc.h for
790  * details.
791  *
792  * 3. Decide on a name, a default value, upper and lower bounds (if
793  * applicable), etc.
794  *
795  * 4. Add a record below.
796  *
797  * 5. Add it to src/backend/utils/misc/postgresql.conf.sample, if
798  * appropriate.
799  *
800  * 6. Don't forget to document the option (at least in config.sgml).
801  *
802  * 7. If it's a new GUC_LIST_QUOTE option, you must add it to
803  * variable_is_guc_list_quote() in src/bin/pg_dump/dumputils.c.
804  */
805 
806 struct config_bool ConfigureNamesBool[] =
807 {
808  {
809  {"enable_seqscan", PGC_USERSET, QUERY_TUNING_METHOD,
810  gettext_noop("Enables the planner's use of sequential-scan plans."),
811  NULL,
812  GUC_EXPLAIN
813  },
814  &enable_seqscan,
815  true,
816  NULL, NULL, NULL
817  },
818  {
819  {"enable_indexscan", PGC_USERSET, QUERY_TUNING_METHOD,
820  gettext_noop("Enables the planner's use of index-scan plans."),
821  NULL,
822  GUC_EXPLAIN
823  },
824  &enable_indexscan,
825  true,
826  NULL, NULL, NULL
827  },
828  {
829  {"enable_indexonlyscan", PGC_USERSET, QUERY_TUNING_METHOD,
830  gettext_noop("Enables the planner's use of index-only-scan plans."),
831  NULL,
832  GUC_EXPLAIN
833  },
834  &enable_indexonlyscan,
835  true,
836  NULL, NULL, NULL
837  },
838  {
839  {"enable_bitmapscan", PGC_USERSET, QUERY_TUNING_METHOD,
840  gettext_noop("Enables the planner's use of bitmap-scan plans."),
841  NULL,
842  GUC_EXPLAIN
843  },
844  &enable_bitmapscan,
845  true,
846  NULL, NULL, NULL
847  },
848  {
849  {"enable_tidscan", PGC_USERSET, QUERY_TUNING_METHOD,
850  gettext_noop("Enables the planner's use of TID scan plans."),
851  NULL,
852  GUC_EXPLAIN
853  },
854  &enable_tidscan,
855  true,
856  NULL, NULL, NULL
857  },
858  {
859  {"enable_sort", PGC_USERSET, QUERY_TUNING_METHOD,
860  gettext_noop("Enables the planner's use of explicit sort steps."),
861  NULL,
862  GUC_EXPLAIN
863  },
864  &enable_sort,
865  true,
866  NULL, NULL, NULL
867  },
868  {
869  {"enable_incremental_sort", PGC_USERSET, QUERY_TUNING_METHOD,
870  gettext_noop("Enables the planner's use of incremental sort steps."),
871  NULL,
872  GUC_EXPLAIN
873  },
874  &enable_incremental_sort,
875  true,
876  NULL, NULL, NULL
877  },
878  {
879  {"enable_hashagg", PGC_USERSET, QUERY_TUNING_METHOD,
880  gettext_noop("Enables the planner's use of hashed aggregation plans."),
881  NULL,
882  GUC_EXPLAIN
883  },
884  &enable_hashagg,
885  true,
886  NULL, NULL, NULL
887  },
888  {
889  {"enable_material", PGC_USERSET, QUERY_TUNING_METHOD,
890  gettext_noop("Enables the planner's use of materialization."),
891  NULL,
892  GUC_EXPLAIN
893  },
894  &enable_material,
895  true,
896  NULL, NULL, NULL
897  },
898  {
899  {"enable_memoize", PGC_USERSET, QUERY_TUNING_METHOD,
900  gettext_noop("Enables the planner's use of memoization."),
901  NULL,
902  GUC_EXPLAIN
903  },
904  &enable_memoize,
905  true,
906  NULL, NULL, NULL
907  },
908  {
909  {"enable_nestloop", PGC_USERSET, QUERY_TUNING_METHOD,
910  gettext_noop("Enables the planner's use of nested-loop join plans."),
911  NULL,
912  GUC_EXPLAIN
913  },
914  &enable_nestloop,
915  true,
916  NULL, NULL, NULL
917  },
918  {
919  {"enable_mergejoin", PGC_USERSET, QUERY_TUNING_METHOD,
920  gettext_noop("Enables the planner's use of merge join plans."),
921  NULL,
922  GUC_EXPLAIN
923  },
924  &enable_mergejoin,
925  true,
926  NULL, NULL, NULL
927  },
928  {
929  {"enable_hashjoin", PGC_USERSET, QUERY_TUNING_METHOD,
930  gettext_noop("Enables the planner's use of hash join plans."),
931  NULL,
932  GUC_EXPLAIN
933  },
934  &enable_hashjoin,
935  true,
936  NULL, NULL, NULL
937  },
938  {
939  {"enable_gathermerge", PGC_USERSET, QUERY_TUNING_METHOD,
940  gettext_noop("Enables the planner's use of gather merge plans."),
941  NULL,
942  GUC_EXPLAIN
943  },
944  &enable_gathermerge,
945  true,
946  NULL, NULL, NULL
947  },
948  {
949  {"enable_partitionwise_join", PGC_USERSET, QUERY_TUNING_METHOD,
950  gettext_noop("Enables partitionwise join."),
951  NULL,
952  GUC_EXPLAIN
953  },
954  &enable_partitionwise_join,
955  false,
956  NULL, NULL, NULL
957  },
958  {
959  {"enable_partitionwise_aggregate", PGC_USERSET, QUERY_TUNING_METHOD,
960  gettext_noop("Enables partitionwise aggregation and grouping."),
961  NULL,
962  GUC_EXPLAIN
963  },
964  &enable_partitionwise_aggregate,
965  false,
966  NULL, NULL, NULL
967  },
968  {
969  {"enable_parallel_append", PGC_USERSET, QUERY_TUNING_METHOD,
970  gettext_noop("Enables the planner's use of parallel append plans."),
971  NULL,
972  GUC_EXPLAIN
973  },
974  &enable_parallel_append,
975  true,
976  NULL, NULL, NULL
977  },
978  {
979  {"enable_parallel_hash", PGC_USERSET, QUERY_TUNING_METHOD,
980  gettext_noop("Enables the planner's use of parallel hash plans."),
981  NULL,
982  GUC_EXPLAIN
983  },
984  &enable_parallel_hash,
985  true,
986  NULL, NULL, NULL
987  },
988  {
989  {"enable_partition_pruning", PGC_USERSET, QUERY_TUNING_METHOD,
990  gettext_noop("Enables plan-time and execution-time partition pruning."),
991  gettext_noop("Allows the query planner and executor to compare partition "
992  "bounds to conditions in the query to determine which "
993  "partitions must be scanned."),
994  GUC_EXPLAIN
995  },
996  &enable_partition_pruning,
997  true,
998  NULL, NULL, NULL
999  },
1000  {
1001  {"enable_presorted_aggregate", PGC_USERSET, QUERY_TUNING_METHOD,
1002  gettext_noop("Enables the planner's ability to produce plans which "
1003  "provide presorted input for ORDER BY / DISTINCT aggregate "
1004  "functions."),
1005  gettext_noop("Allows the query planner to build plans which provide "
1006  "presorted input for aggregate functions with an ORDER BY / "
1007  "DISTINCT clause. When disabled, implicit sorts are always "
1008  "performed during execution."),
1009  GUC_EXPLAIN
1010  },
1011  &enable_presorted_aggregate,
1012  true,
1013  NULL, NULL, NULL
1014  },
1015  {
1016  {"enable_async_append", PGC_USERSET, QUERY_TUNING_METHOD,
1017  gettext_noop("Enables the planner's use of async append plans."),
1018  NULL,
1019  GUC_EXPLAIN
1020  },
1021  &enable_async_append,
1022  true,
1023  NULL, NULL, NULL
1024  },
1025  {
1026  {"geqo", PGC_USERSET, QUERY_TUNING_GEQO,
1027  gettext_noop("Enables genetic query optimization."),
1028  gettext_noop("This algorithm attempts to do planning without "
1029  "exhaustive searching."),
1030  GUC_EXPLAIN
1031  },
1032  &enable_geqo,
1033  true,
1034  NULL, NULL, NULL
1035  },
1036  {
1037  /* Not for general use --- used by SET SESSION AUTHORIZATION */
1038  {"is_superuser", PGC_INTERNAL, UNGROUPED,
1039  gettext_noop("Shows whether the current user is a superuser."),
1040  NULL,
1041  GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1042  },
1043  &session_auth_is_superuser,
1044  false,
1045  NULL, NULL, NULL
1046  },
1047  {
1048  {"bonjour", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
1049  gettext_noop("Enables advertising the server via Bonjour."),
1050  NULL
1051  },
1052  &enable_bonjour,
1053  false,
1054  check_bonjour, NULL, NULL
1055  },
1056  {
1057  {"track_commit_timestamp", PGC_POSTMASTER, REPLICATION_SENDING,
1058  gettext_noop("Collects transaction commit time."),
1059  NULL
1060  },
1061  &track_commit_timestamp,
1062  false,
1063  NULL, NULL, NULL
1064  },
1065  {
1066  {"ssl", PGC_SIGHUP, CONN_AUTH_SSL,
1067  gettext_noop("Enables SSL connections."),
1068  NULL
1069  },
1070  &EnableSSL,
1071  false,
1072  check_ssl, NULL, NULL
1073  },
1074  {
1075  {"ssl_passphrase_command_supports_reload", PGC_SIGHUP, CONN_AUTH_SSL,
1076  gettext_noop("Controls whether ssl_passphrase_command is called during server reload."),
1077  NULL
1078  },
1079  &ssl_passphrase_command_supports_reload,
1080  false,
1081  NULL, NULL, NULL
1082  },
1083  {
1084  {"ssl_prefer_server_ciphers", PGC_SIGHUP, CONN_AUTH_SSL,
1085  gettext_noop("Give priority to server ciphersuite order."),
1086  NULL
1087  },
1088  &SSLPreferServerCiphers,
1089  true,
1090  NULL, NULL, NULL
1091  },
1092  {
1093  {"fsync", PGC_SIGHUP, WAL_SETTINGS,
1094  gettext_noop("Forces synchronization of updates to disk."),
1095  gettext_noop("The server will use the fsync() system call in several places to make "
1096  "sure that updates are physically written to disk. This insures "
1097  "that a database cluster will recover to a consistent state after "
1098  "an operating system or hardware crash.")
1099  },
1100  &enableFsync,
1101  true,
1102  NULL, NULL, NULL
1103  },
1104  {
1105  {"ignore_checksum_failure", PGC_SUSET, DEVELOPER_OPTIONS,
1106  gettext_noop("Continues processing after a checksum failure."),
1107  gettext_noop("Detection of a checksum failure normally causes PostgreSQL to "
1108  "report an error, aborting the current transaction. Setting "
1109  "ignore_checksum_failure to true causes the system to ignore the failure "
1110  "(but still report a warning), and continue processing. This "
1111  "behavior could cause crashes or other serious problems. Only "
1112  "has an effect if checksums are enabled."),
1113  GUC_NOT_IN_SAMPLE
1114  },
1115  &ignore_checksum_failure,
1116  false,
1117  NULL, NULL, NULL
1118  },
1119  {
1120  {"zero_damaged_pages", PGC_SUSET, DEVELOPER_OPTIONS,
1121  gettext_noop("Continues processing past damaged page headers."),
1122  gettext_noop("Detection of a damaged page header normally causes PostgreSQL to "
1123  "report an error, aborting the current transaction. Setting "
1124  "zero_damaged_pages to true causes the system to instead report a "
1125  "warning, zero out the damaged page, and continue processing. This "
1126  "behavior will destroy data, namely all the rows on the damaged page."),
1127  GUC_NOT_IN_SAMPLE
1128  },
1129  &zero_damaged_pages,
1130  false,
1131  NULL, NULL, NULL
1132  },
1133  {
1134  {"ignore_invalid_pages", PGC_POSTMASTER, DEVELOPER_OPTIONS,
1135  gettext_noop("Continues recovery after an invalid pages failure."),
1136  gettext_noop("Detection of WAL records having references to "
1137  "invalid pages during recovery causes PostgreSQL to "
1138  "raise a PANIC-level error, aborting the recovery. "
1139  "Setting ignore_invalid_pages to true causes "
1140  "the system to ignore invalid page references "
1141  "in WAL records (but still report a warning), "
1142  "and continue recovery. This behavior may cause "
1143  "crashes, data loss, propagate or hide corruption, "
1144  "or other serious problems. Only has an effect "
1145  "during recovery or in standby mode."),
1146  GUC_NOT_IN_SAMPLE
1147  },
1148  &ignore_invalid_pages,
1149  false,
1150  NULL, NULL, NULL
1151  },
1152  {
1153  {"full_page_writes", PGC_SIGHUP, WAL_SETTINGS,
1154  gettext_noop("Writes full pages to WAL when first modified after a checkpoint."),
1155  gettext_noop("A page write in process during an operating system crash might be "
1156  "only partially written to disk. During recovery, the row changes "
1157  "stored in WAL are not enough to recover. This option writes "
1158  "pages when first modified after a checkpoint to WAL so full recovery "
1159  "is possible.")
1160  },
1161  &fullPageWrites,
1162  true,
1163  NULL, NULL, NULL
1164  },
1165 
1166  {
1167  {"wal_log_hints", PGC_POSTMASTER, WAL_SETTINGS,
1168  gettext_noop("Writes full pages to WAL when first modified after a checkpoint, even for a non-critical modification."),
1169  NULL
1170  },
1171  &wal_log_hints,
1172  false,
1173  NULL, NULL, NULL
1174  },
1175 
1176  {
1177  {"wal_init_zero", PGC_SUSET, WAL_SETTINGS,
1178  gettext_noop("Writes zeroes to new WAL files before first use."),
1179  NULL
1180  },
1181  &wal_init_zero,
1182  true,
1183  NULL, NULL, NULL
1184  },
1185 
1186  {
1187  {"wal_recycle", PGC_SUSET, WAL_SETTINGS,
1188  gettext_noop("Recycles WAL files by renaming them."),
1189  NULL
1190  },
1191  &wal_recycle,
1192  true,
1193  NULL, NULL, NULL
1194  },
1195 
1196  {
1197  {"log_checkpoints", PGC_SIGHUP, LOGGING_WHAT,
1198  gettext_noop("Logs each checkpoint."),
1199  NULL
1200  },
1201  &log_checkpoints,
1202  true,
1203  NULL, NULL, NULL
1204  },
1205  {
1206  {"log_connections", PGC_SU_BACKEND, LOGGING_WHAT,
1207  gettext_noop("Logs each successful connection."),
1208  NULL
1209  },
1210  &Log_connections,
1211  false,
1212  NULL, NULL, NULL
1213  },
1214  {
1215  {"log_disconnections", PGC_SU_BACKEND, LOGGING_WHAT,
1216  gettext_noop("Logs end of a session, including duration."),
1217  NULL
1218  },
1219  &Log_disconnections,
1220  false,
1221  NULL, NULL, NULL
1222  },
1223  {
1224  {"log_replication_commands", PGC_SUSET, LOGGING_WHAT,
1225  gettext_noop("Logs each replication command."),
1226  NULL
1227  },
1228  &log_replication_commands,
1229  false,
1230  NULL, NULL, NULL
1231  },
1232  {
1233  {"debug_assertions", PGC_INTERNAL, PRESET_OPTIONS,
1234  gettext_noop("Shows whether the running server has assertion checks enabled."),
1235  NULL,
1236  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1237  },
1238  &assert_enabled,
1239  DEFAULT_ASSERT_ENABLED,
1240  NULL, NULL, NULL
1241  },
1242 
1243  {
1244  {"exit_on_error", PGC_USERSET, ERROR_HANDLING_OPTIONS,
1245  gettext_noop("Terminate session on any error."),
1246  NULL
1247  },
1248  &ExitOnAnyError,
1249  false,
1250  NULL, NULL, NULL
1251  },
1252  {
1253  {"restart_after_crash", PGC_SIGHUP, ERROR_HANDLING_OPTIONS,
1254  gettext_noop("Reinitialize server after backend crash."),
1255  NULL
1256  },
1257  &restart_after_crash,
1258  true,
1259  NULL, NULL, NULL
1260  },
1261  {
1262  {"remove_temp_files_after_crash", PGC_SIGHUP, DEVELOPER_OPTIONS,
1263  gettext_noop("Remove temporary files after backend crash."),
1264  NULL,
1265  GUC_NOT_IN_SAMPLE
1266  },
1267  &remove_temp_files_after_crash,
1268  true,
1269  NULL, NULL, NULL
1270  },
1271  {
1272  {"send_abort_for_crash", PGC_SIGHUP, DEVELOPER_OPTIONS,
1273  gettext_noop("Send SIGABRT not SIGQUIT to child processes after backend crash."),
1274  NULL,
1275  GUC_NOT_IN_SAMPLE
1276  },
1277  &send_abort_for_crash,
1278  false,
1279  NULL, NULL, NULL
1280  },
1281  {
1282  {"send_abort_for_kill", PGC_SIGHUP, DEVELOPER_OPTIONS,
1283  gettext_noop("Send SIGABRT not SIGKILL to stuck child processes."),
1284  NULL,
1285  GUC_NOT_IN_SAMPLE
1286  },
1287  &send_abort_for_kill,
1288  false,
1289  NULL, NULL, NULL
1290  },
1291 
1292  {
1293  {"log_duration", PGC_SUSET, LOGGING_WHAT,
1294  gettext_noop("Logs the duration of each completed SQL statement."),
1295  NULL
1296  },
1297  &log_duration,
1298  false,
1299  NULL, NULL, NULL
1300  },
1301  {
1302  {"debug_print_parse", PGC_USERSET, LOGGING_WHAT,
1303  gettext_noop("Logs each query's parse tree."),
1304  NULL
1305  },
1306  &Debug_print_parse,
1307  false,
1308  NULL, NULL, NULL
1309  },
1310  {
1311  {"debug_print_rewritten", PGC_USERSET, LOGGING_WHAT,
1312  gettext_noop("Logs each query's rewritten parse tree."),
1313  NULL
1314  },
1315  &Debug_print_rewritten,
1316  false,
1317  NULL, NULL, NULL
1318  },
1319  {
1320  {"debug_print_plan", PGC_USERSET, LOGGING_WHAT,
1321  gettext_noop("Logs each query's execution plan."),
1322  NULL
1323  },
1324  &Debug_print_plan,
1325  false,
1326  NULL, NULL, NULL
1327  },
1328  {
1329  {"debug_pretty_print", PGC_USERSET, LOGGING_WHAT,
1330  gettext_noop("Indents parse and plan tree displays."),
1331  NULL
1332  },
1333  &Debug_pretty_print,
1334  true,
1335  NULL, NULL, NULL
1336  },
1337  {
1338  {"log_parser_stats", PGC_SUSET, STATS_MONITORING,
1339  gettext_noop("Writes parser performance statistics to the server log."),
1340  NULL
1341  },
1342  &log_parser_stats,
1343  false,
1344  check_stage_log_stats, NULL, NULL
1345  },
1346  {
1347  {"log_planner_stats", PGC_SUSET, STATS_MONITORING,
1348  gettext_noop("Writes planner performance statistics to the server log."),
1349  NULL
1350  },
1351  &log_planner_stats,
1352  false,
1353  check_stage_log_stats, NULL, NULL
1354  },
1355  {
1356  {"log_executor_stats", PGC_SUSET, STATS_MONITORING,
1357  gettext_noop("Writes executor performance statistics to the server log."),
1358  NULL
1359  },
1360  &log_executor_stats,
1361  false,
1362  check_stage_log_stats, NULL, NULL
1363  },
1364  {
1365  {"log_statement_stats", PGC_SUSET, STATS_MONITORING,
1366  gettext_noop("Writes cumulative performance statistics to the server log."),
1367  NULL
1368  },
1369  &log_statement_stats,
1370  false,
1371  check_log_stats, NULL, NULL
1372  },
1373 #ifdef BTREE_BUILD_STATS
1374  {
1375  {"log_btree_build_stats", PGC_SUSET, DEVELOPER_OPTIONS,
1376  gettext_noop("Logs system resource usage statistics (memory and CPU) on various B-tree operations."),
1377  NULL,
1378  GUC_NOT_IN_SAMPLE
1379  },
1380  &log_btree_build_stats,
1381  false,
1382  NULL, NULL, NULL
1383  },
1384 #endif
1385 
1386  {
1387  {"track_activities", PGC_SUSET, STATS_CUMULATIVE,
1388  gettext_noop("Collects information about executing commands."),
1389  gettext_noop("Enables the collection of information on the currently "
1390  "executing command of each session, along with "
1391  "the time at which that command began execution.")
1392  },
1393  &pgstat_track_activities,
1394  true,
1395  NULL, NULL, NULL
1396  },
1397  {
1398  {"track_counts", PGC_SUSET, STATS_CUMULATIVE,
1399  gettext_noop("Collects statistics on database activity."),
1400  NULL
1401  },
1402  &pgstat_track_counts,
1403  true,
1404  NULL, NULL, NULL
1405  },
1406  {
1407  {"track_io_timing", PGC_SUSET, STATS_CUMULATIVE,
1408  gettext_noop("Collects timing statistics for database I/O activity."),
1409  NULL
1410  },
1411  &track_io_timing,
1412  false,
1413  NULL, NULL, NULL
1414  },
1415  {
1416  {"track_wal_io_timing", PGC_SUSET, STATS_CUMULATIVE,
1417  gettext_noop("Collects timing statistics for WAL I/O activity."),
1418  NULL
1419  },
1420  &track_wal_io_timing,
1421  false,
1422  NULL, NULL, NULL
1423  },
1424 
1425  {
1426  {"update_process_title", PGC_SUSET, PROCESS_TITLE,
1427  gettext_noop("Updates the process title to show the active SQL command."),
1428  gettext_noop("Enables updating of the process title every time a new SQL command is received by the server.")
1429  },
1430  &update_process_title,
1431  DEFAULT_UPDATE_PROCESS_TITLE,
1432  NULL, NULL, NULL
1433  },
1434 
1435  {
1436  {"autovacuum", PGC_SIGHUP, AUTOVACUUM,
1437  gettext_noop("Starts the autovacuum subprocess."),
1438  NULL
1439  },
1440  &autovacuum_start_daemon,
1441  true,
1442  NULL, NULL, NULL
1443  },
1444 
1445  {
1446  {"trace_notify", PGC_USERSET, DEVELOPER_OPTIONS,
1447  gettext_noop("Generates debugging output for LISTEN and NOTIFY."),
1448  NULL,
1449  GUC_NOT_IN_SAMPLE
1450  },
1451  &Trace_notify,
1452  false,
1453  NULL, NULL, NULL
1454  },
1455 
1456 #ifdef LOCK_DEBUG
1457  {
1458  {"trace_locks", PGC_SUSET, DEVELOPER_OPTIONS,
1459  gettext_noop("Emits information about lock usage."),
1460  NULL,
1461  GUC_NOT_IN_SAMPLE
1462  },
1463  &Trace_locks,
1464  false,
1465  NULL, NULL, NULL
1466  },
1467  {
1468  {"trace_userlocks", PGC_SUSET, DEVELOPER_OPTIONS,
1469  gettext_noop("Emits information about user lock usage."),
1470  NULL,
1471  GUC_NOT_IN_SAMPLE
1472  },
1473  &Trace_userlocks,
1474  false,
1475  NULL, NULL, NULL
1476  },
1477  {
1478  {"trace_lwlocks", PGC_SUSET, DEVELOPER_OPTIONS,
1479  gettext_noop("Emits information about lightweight lock usage."),
1480  NULL,
1481  GUC_NOT_IN_SAMPLE
1482  },
1483  &Trace_lwlocks,
1484  false,
1485  NULL, NULL, NULL
1486  },
1487  {
1488  {"debug_deadlocks", PGC_SUSET, DEVELOPER_OPTIONS,
1489  gettext_noop("Dumps information about all current locks when a deadlock timeout occurs."),
1490  NULL,
1491  GUC_NOT_IN_SAMPLE
1492  },
1493  &Debug_deadlocks,
1494  false,
1495  NULL, NULL, NULL
1496  },
1497 #endif
1498 
1499  {
1500  {"log_lock_waits", PGC_SUSET, LOGGING_WHAT,
1501  gettext_noop("Logs long lock waits."),
1502  NULL
1503  },
1504  &log_lock_waits,
1505  false,
1506  NULL, NULL, NULL
1507  },
1508  {
1509  {"log_recovery_conflict_waits", PGC_SIGHUP, LOGGING_WHAT,
1510  gettext_noop("Logs standby recovery conflict waits."),
1511  NULL
1512  },
1513  &log_recovery_conflict_waits,
1514  false,
1515  NULL, NULL, NULL
1516  },
1517  {
1518  {"log_hostname", PGC_SIGHUP, LOGGING_WHAT,
1519  gettext_noop("Logs the host name in the connection logs."),
1520  gettext_noop("By default, connection logs only show the IP address "
1521  "of the connecting host. If you want them to show the host name you "
1522  "can turn this on, but depending on your host name resolution "
1523  "setup it might impose a non-negligible performance penalty.")
1524  },
1525  &log_hostname,
1526  false,
1527  NULL, NULL, NULL
1528  },
1529  {
1530  {"transform_null_equals", PGC_USERSET, COMPAT_OPTIONS_CLIENT,
1531  gettext_noop("Treats \"expr=NULL\" as \"expr IS NULL\"."),
1532  gettext_noop("When turned on, expressions of the form expr = NULL "
1533  "(or NULL = expr) are treated as expr IS NULL, that is, they "
1534  "return true if expr evaluates to the null value, and false "
1535  "otherwise. The correct behavior of expr = NULL is to always "
1536  "return null (unknown).")
1537  },
1538  &Transform_null_equals,
1539  false,
1540  NULL, NULL, NULL
1541  },
1542  {
1543  {"db_user_namespace", PGC_SIGHUP, CONN_AUTH_AUTH,
1544  gettext_noop("Enables per-database user names."),
1545  NULL
1546  },
1547  &Db_user_namespace,
1548  false,
1549  NULL, NULL, NULL
1550  },
1551  {
1552  {"default_transaction_read_only", PGC_USERSET, CLIENT_CONN_STATEMENT,
1553  gettext_noop("Sets the default read-only status of new transactions."),
1554  NULL,
1555  GUC_REPORT
1556  },
1557  &DefaultXactReadOnly,
1558  false,
1559  NULL, NULL, NULL
1560  },
1561  {
1562  {"transaction_read_only", PGC_USERSET, CLIENT_CONN_STATEMENT,
1563  gettext_noop("Sets the current transaction's read-only status."),
1564  NULL,
1565  GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1566  },
1567  &XactReadOnly,
1568  false,
1569  check_transaction_read_only, NULL, NULL
1570  },
1571  {
1572  {"default_transaction_deferrable", PGC_USERSET, CLIENT_CONN_STATEMENT,
1573  gettext_noop("Sets the default deferrable status of new transactions."),
1574  NULL
1575  },
1576  &DefaultXactDeferrable,
1577  false,
1578  NULL, NULL, NULL
1579  },
1580  {
1581  {"transaction_deferrable", PGC_USERSET, CLIENT_CONN_STATEMENT,
1582  gettext_noop("Whether to defer a read-only serializable transaction until it can be executed with no possible serialization failures."),
1583  NULL,
1584  GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1585  },
1586  &XactDeferrable,
1587  false,
1588  check_transaction_deferrable, NULL, NULL
1589  },
1590  {
1591  {"row_security", PGC_USERSET, CLIENT_CONN_STATEMENT,
1592  gettext_noop("Enable row security."),
1593  gettext_noop("When enabled, row security will be applied to all users.")
1594  },
1595  &row_security,
1596  true,
1597  NULL, NULL, NULL
1598  },
1599  {
1600  {"check_function_bodies", PGC_USERSET, CLIENT_CONN_STATEMENT,
1601  gettext_noop("Check routine bodies during CREATE FUNCTION and CREATE PROCEDURE."),
1602  NULL
1603  },
1604  &check_function_bodies,
1605  true,
1606  NULL, NULL, NULL
1607  },
1608  {
1609  {"array_nulls", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1610  gettext_noop("Enable input of NULL elements in arrays."),
1611  gettext_noop("When turned on, unquoted NULL in an array input "
1612  "value means a null value; "
1613  "otherwise it is taken literally.")
1614  },
1615  &Array_nulls,
1616  true,
1617  NULL, NULL, NULL
1618  },
1619 
1620  /*
1621  * WITH OIDS support, and consequently default_with_oids, was removed in
1622  * PostgreSQL 12, but we tolerate the parameter being set to false to
1623  * avoid unnecessarily breaking older dump files.
1624  */
1625  {
1626  {"default_with_oids", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1627  gettext_noop("WITH OIDS is no longer supported; this can only be false."),
1628  NULL,
1629  GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE
1630  },
1631  &default_with_oids,
1632  false,
1633  check_default_with_oids, NULL, NULL
1634  },
1635  {
1636  {"logging_collector", PGC_POSTMASTER, LOGGING_WHERE,
1637  gettext_noop("Start a subprocess to capture stderr output and/or csvlogs into log files."),
1638  NULL
1639  },
1640  &Logging_collector,
1641  false,
1642  NULL, NULL, NULL
1643  },
1644  {
1645  {"log_truncate_on_rotation", PGC_SIGHUP, LOGGING_WHERE,
1646  gettext_noop("Truncate existing log files of same name during log rotation."),
1647  NULL
1648  },
1649  &Log_truncate_on_rotation,
1650  false,
1651  NULL, NULL, NULL
1652  },
1653 
1654 #ifdef TRACE_SORT
1655  {
1656  {"trace_sort", PGC_USERSET, DEVELOPER_OPTIONS,
1657  gettext_noop("Emit information about resource usage in sorting."),
1658  NULL,
1659  GUC_NOT_IN_SAMPLE
1660  },
1661  &trace_sort,
1662  false,
1663  NULL, NULL, NULL
1664  },
1665 #endif
1666 
1667 #ifdef TRACE_SYNCSCAN
1668  /* this is undocumented because not exposed in a standard build */
1669  {
1670  {"trace_syncscan", PGC_USERSET, DEVELOPER_OPTIONS,
1671  gettext_noop("Generate debugging output for synchronized scanning."),
1672  NULL,
1673  GUC_NOT_IN_SAMPLE
1674  },
1675  &trace_syncscan,
1676  false,
1677  NULL, NULL, NULL
1678  },
1679 #endif
1680 
1681 #ifdef DEBUG_BOUNDED_SORT
1682  /* this is undocumented because not exposed in a standard build */
1683  {
1684  {
1685  "optimize_bounded_sort", PGC_USERSET, QUERY_TUNING_METHOD,
1686  gettext_noop("Enable bounded sorting using heap sort."),
1687  NULL,
1688  GUC_NOT_IN_SAMPLE | GUC_EXPLAIN
1689  },
1690  &optimize_bounded_sort,
1691  true,
1692  NULL, NULL, NULL
1693  },
1694 #endif
1695 
1696 #ifdef WAL_DEBUG
1697  {
1698  {"wal_debug", PGC_SUSET, DEVELOPER_OPTIONS,
1699  gettext_noop("Emit WAL-related debugging output."),
1700  NULL,
1701  GUC_NOT_IN_SAMPLE
1702  },
1703  &XLOG_DEBUG,
1704  false,
1705  NULL, NULL, NULL
1706  },
1707 #endif
1708 
1709  {
1710  {"integer_datetimes", PGC_INTERNAL, PRESET_OPTIONS,
1711  gettext_noop("Shows whether datetimes are integer based."),
1712  NULL,
1713  GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1714  },
1715  &integer_datetimes,
1716  true,
1717  NULL, NULL, NULL
1718  },
1719 
1720  {
1721  {"krb_caseins_users", PGC_SIGHUP, CONN_AUTH_AUTH,
1722  gettext_noop("Sets whether Kerberos and GSSAPI user names should be treated as case-insensitive."),
1723  NULL
1724  },
1725  &pg_krb_caseins_users,
1726  false,
1727  NULL, NULL, NULL
1728  },
1729 
1730  {
1731  {"gss_accept_delegation", PGC_SIGHUP, CONN_AUTH_AUTH,
1732  gettext_noop("Sets whether GSSAPI delegation should be accepted from the client."),
1733  NULL
1734  },
1735  &pg_gss_accept_delegation,
1736  false,
1737  NULL, NULL, NULL
1738  },
1739 
1740  {
1741  {"escape_string_warning", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1742  gettext_noop("Warn about backslash escapes in ordinary string literals."),
1743  NULL
1744  },
1745  &escape_string_warning,
1746  true,
1747  NULL, NULL, NULL
1748  },
1749 
1750  {
1751  {"standard_conforming_strings", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1752  gettext_noop("Causes '...' strings to treat backslashes literally."),
1753  NULL,
1754  GUC_REPORT
1755  },
1756  &standard_conforming_strings,
1757  true,
1758  NULL, NULL, NULL
1759  },
1760 
1761  {
1762  {"synchronize_seqscans", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1763  gettext_noop("Enable synchronized sequential scans."),
1764  NULL
1765  },
1766  &synchronize_seqscans,
1767  true,
1768  NULL, NULL, NULL
1769  },
1770 
1771  {
1772  {"recovery_target_inclusive", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
1773  gettext_noop("Sets whether to include or exclude transaction with recovery target."),
1774  NULL
1775  },
1776  &recoveryTargetInclusive,
1777  true,
1778  NULL, NULL, NULL
1779  },
1780 
1781  {
1782  {"hot_standby", PGC_POSTMASTER, REPLICATION_STANDBY,
1783  gettext_noop("Allows connections and queries during recovery."),
1784  NULL
1785  },
1786  &EnableHotStandby,
1787  true,
1788  NULL, NULL, NULL
1789  },
1790 
1791  {
1792  {"hot_standby_feedback", PGC_SIGHUP, REPLICATION_STANDBY,
1793  gettext_noop("Allows feedback from a hot standby to the primary that will avoid query conflicts."),
1794  NULL
1795  },
1796  &hot_standby_feedback,
1797  false,
1798  NULL, NULL, NULL
1799  },
1800 
1801  {
1802  {"in_hot_standby", PGC_INTERNAL, PRESET_OPTIONS,
1803  gettext_noop("Shows whether hot standby is currently active."),
1804  NULL,
1805  GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1806  },
1807  &in_hot_standby_guc,
1808  false,
1809  NULL, NULL, show_in_hot_standby
1810  },
1811 
1812  {
1813  {"allow_system_table_mods", PGC_SUSET, DEVELOPER_OPTIONS,
1814  gettext_noop("Allows modifications of the structure of system tables."),
1815  NULL,
1816  GUC_NOT_IN_SAMPLE
1817  },
1818  &allowSystemTableMods,
1819  false,
1820  NULL, NULL, NULL
1821  },
1822 
1823  {
1824  {"ignore_system_indexes", PGC_BACKEND, DEVELOPER_OPTIONS,
1825  gettext_noop("Disables reading from system indexes."),
1826  gettext_noop("It does not prevent updating the indexes, so it is safe "
1827  "to use. The worst consequence is slowness."),
1828  GUC_NOT_IN_SAMPLE
1829  },
1830  &IgnoreSystemIndexes,
1831  false,
1832  NULL, NULL, NULL
1833  },
1834 
1835  {
1836  {"allow_in_place_tablespaces", PGC_SUSET, DEVELOPER_OPTIONS,
1837  gettext_noop("Allows tablespaces directly inside pg_tblspc, for testing."),
1838  NULL,
1839  GUC_NOT_IN_SAMPLE
1840  },
1841  &allow_in_place_tablespaces,
1842  false,
1843  NULL, NULL, NULL
1844  },
1845 
1846  {
1847  {"lo_compat_privileges", PGC_SUSET, COMPAT_OPTIONS_PREVIOUS,
1848  gettext_noop("Enables backward compatibility mode for privilege checks on large objects."),
1849  gettext_noop("Skips privilege checks when reading or modifying large objects, "
1850  "for compatibility with PostgreSQL releases prior to 9.0.")
1851  },
1852  &lo_compat_privileges,
1853  false,
1854  NULL, NULL, NULL
1855  },
1856 
1857  {
1858  {"quote_all_identifiers", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1859  gettext_noop("When generating SQL fragments, quote all identifiers."),
1860  NULL,
1861  },
1862  &quote_all_identifiers,
1863  false,
1864  NULL, NULL, NULL
1865  },
1866 
1867  {
1868  {"data_checksums", PGC_INTERNAL, PRESET_OPTIONS,
1869  gettext_noop("Shows whether data checksums are turned on for this cluster."),
1870  NULL,
1871  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
1872  },
1873  &data_checksums,
1874  false,
1875  NULL, NULL, NULL
1876  },
1877 
1878  {
1879  {"syslog_sequence_numbers", PGC_SIGHUP, LOGGING_WHERE,
1880  gettext_noop("Add sequence number to syslog messages to avoid duplicate suppression."),
1881  NULL
1882  },
1883  &syslog_sequence_numbers,
1884  true,
1885  NULL, NULL, NULL
1886  },
1887 
1888  {
1889  {"syslog_split_messages", PGC_SIGHUP, LOGGING_WHERE,
1890  gettext_noop("Split messages sent to syslog by lines and to fit into 1024 bytes."),
1891  NULL
1892  },
1893  &syslog_split_messages,
1894  true,
1895  NULL, NULL, NULL
1896  },
1897 
1898  {
1899  {"parallel_leader_participation", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
1900  gettext_noop("Controls whether Gather and Gather Merge also run subplans."),
1901  gettext_noop("Should gather nodes also run subplans or just gather tuples?"),
1902  GUC_EXPLAIN
1903  },
1904  &parallel_leader_participation,
1905  true,
1906  NULL, NULL, NULL
1907  },
1908 
1909  {
1910  {"jit", PGC_USERSET, QUERY_TUNING_OTHER,
1911  gettext_noop("Allow JIT compilation."),
1912  NULL,
1913  GUC_EXPLAIN
1914  },
1915  &jit_enabled,
1916  true,
1917  NULL, NULL, NULL
1918  },
1919 
1920  {
1921  {"jit_debugging_support", PGC_SU_BACKEND, DEVELOPER_OPTIONS,
1922  gettext_noop("Register JIT-compiled functions with debugger."),
1923  NULL,
1924  GUC_NOT_IN_SAMPLE
1925  },
1926  &jit_debugging_support,
1927  false,
1928 
1929  /*
1930  * This is not guaranteed to be available, but given it's a developer
1931  * oriented option, it doesn't seem worth adding code checking
1932  * availability.
1933  */
1934  NULL, NULL, NULL
1935  },
1936 
1937  {
1938  {"jit_dump_bitcode", PGC_SUSET, DEVELOPER_OPTIONS,
1939  gettext_noop("Write out LLVM bitcode to facilitate JIT debugging."),
1940  NULL,
1941  GUC_NOT_IN_SAMPLE
1942  },
1943  &jit_dump_bitcode,
1944  false,
1945  NULL, NULL, NULL
1946  },
1947 
1948  {
1949  {"jit_expressions", PGC_USERSET, DEVELOPER_OPTIONS,
1950  gettext_noop("Allow JIT compilation of expressions."),
1951  NULL,
1952  GUC_NOT_IN_SAMPLE
1953  },
1954  &jit_expressions,
1955  true,
1956  NULL, NULL, NULL
1957  },
1958 
1959  {
1960  {"jit_profiling_support", PGC_SU_BACKEND, DEVELOPER_OPTIONS,
1961  gettext_noop("Register JIT-compiled functions with perf profiler."),
1962  NULL,
1963  GUC_NOT_IN_SAMPLE
1964  },
1965  &jit_profiling_support,
1966  false,
1967 
1968  /*
1969  * This is not guaranteed to be available, but given it's a developer
1970  * oriented option, it doesn't seem worth adding code checking
1971  * availability.
1972  */
1973  NULL, NULL, NULL
1974  },
1975 
1976  {
1977  {"jit_tuple_deforming", PGC_USERSET, DEVELOPER_OPTIONS,
1978  gettext_noop("Allow JIT compilation of tuple deforming."),
1979  NULL,
1980  GUC_NOT_IN_SAMPLE
1981  },
1982  &jit_tuple_deforming,
1983  true,
1984  NULL, NULL, NULL
1985  },
1986 
1987  {
1988  {"data_sync_retry", PGC_POSTMASTER, ERROR_HANDLING_OPTIONS,
1989  gettext_noop("Whether to continue running after a failure to sync data files."),
1990  },
1991  &data_sync_retry,
1992  false,
1993  NULL, NULL, NULL
1994  },
1995 
1996  {
1997  {"wal_receiver_create_temp_slot", PGC_SIGHUP, REPLICATION_STANDBY,
1998  gettext_noop("Sets whether a WAL receiver should create a temporary replication slot if no permanent slot is configured."),
1999  },
2000  &wal_receiver_create_temp_slot,
2001  false,
2002  NULL, NULL, NULL
2003  },
2004 
2005  /* End-of-list marker */
2006  {
2007  {NULL, 0, 0, NULL, NULL}, NULL, false, NULL, NULL, NULL
2008  }
2009 };
2010 
2011 
2012 struct config_int ConfigureNamesInt[] =
2013 {
2014  {
2015  {"archive_timeout", PGC_SIGHUP, WAL_ARCHIVING,
2016  gettext_noop("Sets the amount of time to wait before forcing a "
2017  "switch to the next WAL file."),
2018  NULL,
2019  GUC_UNIT_S
2020  },
2021  &XLogArchiveTimeout,
2022  0, 0, INT_MAX / 2,
2023  NULL, NULL, NULL
2024  },
2025  {
2026  {"post_auth_delay", PGC_BACKEND, DEVELOPER_OPTIONS,
2027  gettext_noop("Sets the amount of time to wait after "
2028  "authentication on connection startup."),
2029  gettext_noop("This allows attaching a debugger to the process."),
2030  GUC_NOT_IN_SAMPLE | GUC_UNIT_S
2031  },
2032  &PostAuthDelay,
2033  0, 0, INT_MAX / 1000000,
2034  NULL, NULL, NULL
2035  },
2036  {
2037  {"default_statistics_target", PGC_USERSET, QUERY_TUNING_OTHER,
2038  gettext_noop("Sets the default statistics target."),
2039  gettext_noop("This applies to table columns that have not had a "
2040  "column-specific target set via ALTER TABLE SET STATISTICS.")
2041  },
2042  &default_statistics_target,
2043  100, 1, 10000,
2044  NULL, NULL, NULL
2045  },
2046  {
2047  {"from_collapse_limit", PGC_USERSET, QUERY_TUNING_OTHER,
2048  gettext_noop("Sets the FROM-list size beyond which subqueries "
2049  "are not collapsed."),
2050  gettext_noop("The planner will merge subqueries into upper "
2051  "queries if the resulting FROM list would have no more than "
2052  "this many items."),
2053  GUC_EXPLAIN
2054  },
2055  &from_collapse_limit,
2056  8, 1, INT_MAX,
2057  NULL, NULL, NULL
2058  },
2059  {
2060  {"join_collapse_limit", PGC_USERSET, QUERY_TUNING_OTHER,
2061  gettext_noop("Sets the FROM-list size beyond which JOIN "
2062  "constructs are not flattened."),
2063  gettext_noop("The planner will flatten explicit JOIN "
2064  "constructs into lists of FROM items whenever a "
2065  "list of no more than this many items would result."),
2066  GUC_EXPLAIN
2067  },
2068  &join_collapse_limit,
2069  8, 1, INT_MAX,
2070  NULL, NULL, NULL
2071  },
2072  {
2073  {"geqo_threshold", PGC_USERSET, QUERY_TUNING_GEQO,
2074  gettext_noop("Sets the threshold of FROM items beyond which GEQO is used."),
2075  NULL,
2076  GUC_EXPLAIN
2077  },
2078  &geqo_threshold,
2079  12, 2, INT_MAX,
2080  NULL, NULL, NULL
2081  },
2082  {
2083  {"geqo_effort", PGC_USERSET, QUERY_TUNING_GEQO,
2084  gettext_noop("GEQO: effort is used to set the default for other GEQO parameters."),
2085  NULL,
2086  GUC_EXPLAIN
2087  },
2088  &Geqo_effort,
2089  DEFAULT_GEQO_EFFORT, MIN_GEQO_EFFORT, MAX_GEQO_EFFORT,
2090  NULL, NULL, NULL
2091  },
2092  {
2093  {"geqo_pool_size", PGC_USERSET, QUERY_TUNING_GEQO,
2094  gettext_noop("GEQO: number of individuals in the population."),
2095  gettext_noop("Zero selects a suitable default value."),
2096  GUC_EXPLAIN
2097  },
2098  &Geqo_pool_size,
2099  0, 0, INT_MAX,
2100  NULL, NULL, NULL
2101  },
2102  {
2103  {"geqo_generations", PGC_USERSET, QUERY_TUNING_GEQO,
2104  gettext_noop("GEQO: number of iterations of the algorithm."),
2105  gettext_noop("Zero selects a suitable default value."),
2106  GUC_EXPLAIN
2107  },
2108  &Geqo_generations,
2109  0, 0, INT_MAX,
2110  NULL, NULL, NULL
2111  },
2112 
2113  {
2114  /* This is PGC_SUSET to prevent hiding from log_lock_waits. */
2115  {"deadlock_timeout", PGC_SUSET, LOCK_MANAGEMENT,
2116  gettext_noop("Sets the time to wait on a lock before checking for deadlock."),
2117  NULL,
2118  GUC_UNIT_MS
2119  },
2120  &DeadlockTimeout,
2121  1000, 1, INT_MAX,
2122  NULL, NULL, NULL
2123  },
2124 
2125  {
2126  {"max_standby_archive_delay", PGC_SIGHUP, REPLICATION_STANDBY,
2127  gettext_noop("Sets the maximum delay before canceling queries when a hot standby server is processing archived WAL data."),
2128  NULL,
2129  GUC_UNIT_MS
2130  },
2131  &max_standby_archive_delay,
2132  30 * 1000, -1, INT_MAX,
2133  NULL, NULL, NULL
2134  },
2135 
2136  {
2137  {"max_standby_streaming_delay", PGC_SIGHUP, REPLICATION_STANDBY,
2138  gettext_noop("Sets the maximum delay before canceling queries when a hot standby server is processing streamed WAL data."),
2139  NULL,
2140  GUC_UNIT_MS
2141  },
2142  &max_standby_streaming_delay,
2143  30 * 1000, -1, INT_MAX,
2144  NULL, NULL, NULL
2145  },
2146 
2147  {
2148  {"recovery_min_apply_delay", PGC_SIGHUP, REPLICATION_STANDBY,
2149  gettext_noop("Sets the minimum delay for applying changes during recovery."),
2150  NULL,
2151  GUC_UNIT_MS
2152  },
2153  &recovery_min_apply_delay,
2154  0, 0, INT_MAX,
2155  NULL, NULL, NULL
2156  },
2157 
2158  {
2159  {"wal_receiver_status_interval", PGC_SIGHUP, REPLICATION_STANDBY,
2160  gettext_noop("Sets the maximum interval between WAL receiver status reports to the sending server."),
2161  NULL,
2162  GUC_UNIT_S
2163  },
2164  &wal_receiver_status_interval,
2165  10, 0, INT_MAX / 1000,
2166  NULL, NULL, NULL
2167  },
2168 
2169  {
2170  {"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
2171  gettext_noop("Sets the maximum wait time to receive data from the sending server."),
2172  NULL,
2173  GUC_UNIT_MS
2174  },
2175  &wal_receiver_timeout,
2176  60 * 1000, 0, INT_MAX,
2177  NULL, NULL, NULL
2178  },
2179 
2180  {
2181  {"max_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2182  gettext_noop("Sets the maximum number of concurrent connections."),
2183  NULL
2184  },
2185  &MaxConnections,
2186  100, 1, MAX_BACKENDS,
2187  check_max_connections, NULL, NULL
2188  },
2189 
2190  {
2191  /* see max_connections */
2192  {"superuser_reserved_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2193  gettext_noop("Sets the number of connection slots reserved for superusers."),
2194  NULL
2195  },
2196  &SuperuserReservedConnections,
2197  3, 0, MAX_BACKENDS,
2198  NULL, NULL, NULL
2199  },
2200 
2201  {
2202  {"reserved_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2203  gettext_noop("Sets the number of connection slots reserved for roles "
2204  "with privileges of pg_use_reserved_connections."),
2205  NULL
2206  },
2207  &ReservedConnections,
2208  0, 0, MAX_BACKENDS,
2209  NULL, NULL, NULL
2210  },
2211 
2212  {
2213  {"min_dynamic_shared_memory", PGC_POSTMASTER, RESOURCES_MEM,
2214  gettext_noop("Amount of dynamic shared memory reserved at startup."),
2215  NULL,
2216  GUC_UNIT_MB
2217  },
2218  &min_dynamic_shared_memory,
2219  0, 0, (int) Min((size_t) INT_MAX, SIZE_MAX / (1024 * 1024)),
2220  NULL, NULL, NULL
2221  },
2222 
2223  /*
2224  * We sometimes multiply the number of shared buffers by two without
2225  * checking for overflow, so we mustn't allow more than INT_MAX / 2.
2226  */
2227  {
2228  {"shared_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2229  gettext_noop("Sets the number of shared memory buffers used by the server."),
2230  NULL,
2231  GUC_UNIT_BLOCKS
2232  },
2233  &NBuffers,
2234  16384, 16, INT_MAX / 2,
2235  NULL, NULL, NULL
2236  },
2237 
2238  {
2239  {"vacuum_buffer_usage_limit", PGC_USERSET, RESOURCES_MEM,
2240  gettext_noop("Sets the buffer pool size for VACUUM, ANALYZE, and autovacuum."),
2241  NULL,
2242  GUC_UNIT_KB
2243  },
2244  &VacuumBufferUsageLimit,
2245  256, 0, MAX_BAS_VAC_RING_SIZE_KB,
2246  check_vacuum_buffer_usage_limit, NULL, NULL
2247  },
2248 
2249  {
2250  {"shared_memory_size", PGC_INTERNAL, PRESET_OPTIONS,
2251  gettext_noop("Shows the size of the server's main shared memory area (rounded up to the nearest MB)."),
2252  NULL,
2253  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_UNIT_MB | GUC_RUNTIME_COMPUTED
2254  },
2255  &shared_memory_size_mb,
2256  0, 0, INT_MAX,
2257  NULL, NULL, NULL
2258  },
2259 
2260  {
2261  {"shared_memory_size_in_huge_pages", PGC_INTERNAL, PRESET_OPTIONS,
2262  gettext_noop("Shows the number of huge pages needed for the main shared memory area."),
2263  gettext_noop("-1 indicates that the value could not be determined."),
2264  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
2265  },
2266  &shared_memory_size_in_huge_pages,
2267  -1, -1, INT_MAX,
2268  NULL, NULL, NULL
2269  },
2270 
2271  {
2272  {"temp_buffers", PGC_USERSET, RESOURCES_MEM,
2273  gettext_noop("Sets the maximum number of temporary buffers used by each session."),
2274  NULL,
2275  GUC_UNIT_BLOCKS | GUC_EXPLAIN
2276  },
2277  &num_temp_buffers,
2278  1024, 100, INT_MAX / 2,
2279  check_temp_buffers, NULL, NULL
2280  },
2281 
2282  {
2283  {"port", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2284  gettext_noop("Sets the TCP port the server listens on."),
2285  NULL
2286  },
2287  &PostPortNumber,
2288  DEF_PGPORT, 1, 65535,
2289  NULL, NULL, NULL
2290  },
2291 
2292  {
2293  {"unix_socket_permissions", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2294  gettext_noop("Sets the access permissions of the Unix-domain socket."),
2295  gettext_noop("Unix-domain sockets use the usual Unix file system "
2296  "permission set. The parameter value is expected "
2297  "to be a numeric mode specification in the form "
2298  "accepted by the chmod and umask system calls. "
2299  "(To use the customary octal format the number must "
2300  "start with a 0 (zero).)")
2301  },
2302  &Unix_socket_permissions,
2303  0777, 0000, 0777,
2304  NULL, NULL, show_unix_socket_permissions
2305  },
2306 
2307  {
2308  {"log_file_mode", PGC_SIGHUP, LOGGING_WHERE,
2309  gettext_noop("Sets the file permissions for log files."),
2310  gettext_noop("The parameter value is expected "
2311  "to be a numeric mode specification in the form "
2312  "accepted by the chmod and umask system calls. "
2313  "(To use the customary octal format the number must "
2314  "start with a 0 (zero).)")
2315  },
2316  &Log_file_mode,
2317  0600, 0000, 0777,
2318  NULL, NULL, show_log_file_mode
2319  },
2320 
2321 
2322  {
2323  {"data_directory_mode", PGC_INTERNAL, PRESET_OPTIONS,
2324  gettext_noop("Shows the mode of the data directory."),
2325  gettext_noop("The parameter value is a numeric mode specification "
2326  "in the form accepted by the chmod and umask system "
2327  "calls. (To use the customary octal format the number "
2328  "must start with a 0 (zero).)"),
2329  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
2330  },
2331  &data_directory_mode,
2332  0700, 0000, 0777,
2333  NULL, NULL, show_data_directory_mode
2334  },
2335 
2336  {
2337  {"work_mem", PGC_USERSET, RESOURCES_MEM,
2338  gettext_noop("Sets the maximum memory to be used for query workspaces."),
2339  gettext_noop("This much memory can be used by each internal "
2340  "sort operation and hash table before switching to "
2341  "temporary disk files."),
2342  GUC_UNIT_KB | GUC_EXPLAIN
2343  },
2344  &work_mem,
2345  4096, 64, MAX_KILOBYTES,
2346  NULL, NULL, NULL
2347  },
2348 
2349  {
2350  {"maintenance_work_mem", PGC_USERSET, RESOURCES_MEM,
2351  gettext_noop("Sets the maximum memory to be used for maintenance operations."),
2352  gettext_noop("This includes operations such as VACUUM and CREATE INDEX."),
2353  GUC_UNIT_KB
2354  },
2355  &maintenance_work_mem,
2356  65536, 1024, MAX_KILOBYTES,
2357  NULL, NULL, NULL
2358  },
2359 
2360  {
2361  {"logical_decoding_work_mem", PGC_USERSET, RESOURCES_MEM,
2362  gettext_noop("Sets the maximum memory to be used for logical decoding."),
2363  gettext_noop("This much memory can be used by each internal "
2364  "reorder buffer before spilling to disk."),
2365  GUC_UNIT_KB
2366  },
2367  &logical_decoding_work_mem,
2368  65536, 64, MAX_KILOBYTES,
2369  NULL, NULL, NULL
2370  },
2371 
2372  /*
2373  * We use the hopefully-safely-small value of 100kB as the compiled-in
2374  * default for max_stack_depth. InitializeGUCOptions will increase it if
2375  * possible, depending on the actual platform-specific stack limit.
2376  */
2377  {
2378  {"max_stack_depth", PGC_SUSET, RESOURCES_MEM,
2379  gettext_noop("Sets the maximum stack depth, in kilobytes."),
2380  NULL,
2381  GUC_UNIT_KB
2382  },
2383  &max_stack_depth,
2384  100, 100, MAX_KILOBYTES,
2385  check_max_stack_depth, assign_max_stack_depth, NULL
2386  },
2387 
2388  {
2389  {"temp_file_limit", PGC_SUSET, RESOURCES_DISK,
2390  gettext_noop("Limits the total size of all temporary files used by each process."),
2391  gettext_noop("-1 means no limit."),
2392  GUC_UNIT_KB
2393  },
2394  &temp_file_limit,
2395  -1, -1, INT_MAX,
2396  NULL, NULL, NULL
2397  },
2398 
2399  {
2400  {"vacuum_cost_page_hit", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2401  gettext_noop("Vacuum cost for a page found in the buffer cache."),
2402  NULL
2403  },
2404  &VacuumCostPageHit,
2405  1, 0, 10000,
2406  NULL, NULL, NULL
2407  },
2408 
2409  {
2410  {"vacuum_cost_page_miss", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2411  gettext_noop("Vacuum cost for a page not found in the buffer cache."),
2412  NULL
2413  },
2414  &VacuumCostPageMiss,
2415  2, 0, 10000,
2416  NULL, NULL, NULL
2417  },
2418 
2419  {
2420  {"vacuum_cost_page_dirty", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2421  gettext_noop("Vacuum cost for a page dirtied by vacuum."),
2422  NULL
2423  },
2424  &VacuumCostPageDirty,
2425  20, 0, 10000,
2426  NULL, NULL, NULL
2427  },
2428 
2429  {
2430  {"vacuum_cost_limit", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2431  gettext_noop("Vacuum cost amount available before napping."),
2432  NULL
2433  },
2434  &VacuumCostLimit,
2435  200, 1, 10000,
2436  NULL, NULL, NULL
2437  },
2438 
2439  {
2440  {"autovacuum_vacuum_cost_limit", PGC_SIGHUP, AUTOVACUUM,
2441  gettext_noop("Vacuum cost amount available before napping, for autovacuum."),
2442  NULL
2443  },
2444  &autovacuum_vac_cost_limit,
2445  -1, -1, 10000,
2446  NULL, NULL, NULL
2447  },
2448 
2449  {
2450  {"max_files_per_process", PGC_POSTMASTER, RESOURCES_KERNEL,
2451  gettext_noop("Sets the maximum number of simultaneously open files for each server process."),
2452  NULL
2453  },
2454  &max_files_per_process,
2455  1000, 64, INT_MAX,
2456  NULL, NULL, NULL
2457  },
2458 
2459  /*
2460  * See also CheckRequiredParameterValues() if this parameter changes
2461  */
2462  {
2463  {"max_prepared_transactions", PGC_POSTMASTER, RESOURCES_MEM,
2464  gettext_noop("Sets the maximum number of simultaneously prepared transactions."),
2465  NULL
2466  },
2467  &max_prepared_xacts,
2468  0, 0, MAX_BACKENDS,
2469  NULL, NULL, NULL
2470  },
2471 
2472 #ifdef LOCK_DEBUG
2473  {
2474  {"trace_lock_oidmin", PGC_SUSET, DEVELOPER_OPTIONS,
2475  gettext_noop("Sets the minimum OID of tables for tracking locks."),
2476  gettext_noop("Is used to avoid output on system tables."),
2477  GUC_NOT_IN_SAMPLE
2478  },
2479  &Trace_lock_oidmin,
2480  FirstNormalObjectId, 0, INT_MAX,
2481  NULL, NULL, NULL
2482  },
2483  {
2484  {"trace_lock_table", PGC_SUSET, DEVELOPER_OPTIONS,
2485  gettext_noop("Sets the OID of the table with unconditionally lock tracing."),
2486  NULL,
2487  GUC_NOT_IN_SAMPLE
2488  },
2489  &Trace_lock_table,
2490  0, 0, INT_MAX,
2491  NULL, NULL, NULL
2492  },
2493 #endif
2494 
2495  {
2496  {"statement_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2497  gettext_noop("Sets the maximum allowed duration of any statement."),
2498  gettext_noop("A value of 0 turns off the timeout."),
2499  GUC_UNIT_MS
2500  },
2501  &StatementTimeout,
2502  0, 0, INT_MAX,
2503  NULL, NULL, NULL
2504  },
2505 
2506  {
2507  {"lock_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2508  gettext_noop("Sets the maximum allowed duration of any wait for a lock."),
2509  gettext_noop("A value of 0 turns off the timeout."),
2510  GUC_UNIT_MS
2511  },
2512  &LockTimeout,
2513  0, 0, INT_MAX,
2514  NULL, NULL, NULL
2515  },
2516 
2517  {
2518  {"idle_in_transaction_session_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2519  gettext_noop("Sets the maximum allowed idle time between queries, when in a transaction."),
2520  gettext_noop("A value of 0 turns off the timeout."),
2521  GUC_UNIT_MS
2522  },
2523  &IdleInTransactionSessionTimeout,
2524  0, 0, INT_MAX,
2525  NULL, NULL, NULL
2526  },
2527 
2528  {
2529  {"idle_session_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2530  gettext_noop("Sets the maximum allowed idle time between queries, when not in a transaction."),
2531  gettext_noop("A value of 0 turns off the timeout."),
2532  GUC_UNIT_MS
2533  },
2534  &IdleSessionTimeout,
2535  0, 0, INT_MAX,
2536  NULL, NULL, NULL
2537  },
2538 
2539  {
2540  {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2541  gettext_noop("Minimum age at which VACUUM should freeze a table row."),
2542  NULL
2543  },
2544  &vacuum_freeze_min_age,
2545  50000000, 0, 1000000000,
2546  NULL, NULL, NULL
2547  },
2548 
2549  {
2550  {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2551  gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
2552  NULL
2553  },
2554  &vacuum_freeze_table_age,
2555  150000000, 0, 2000000000,
2556  NULL, NULL, NULL
2557  },
2558 
2559  {
2560  {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2561  gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
2562  NULL
2563  },
2564  &vacuum_multixact_freeze_min_age,
2565  5000000, 0, 1000000000,
2566  NULL, NULL, NULL
2567  },
2568 
2569  {
2570  {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2571  gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
2572  NULL
2573  },
2574  &vacuum_multixact_freeze_table_age,
2575  150000000, 0, 2000000000,
2576  NULL, NULL, NULL
2577  },
2578 
2579  {
2580  {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2581  gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
2582  NULL
2583  },
2584  &vacuum_failsafe_age,
2585  1600000000, 0, 2100000000,
2586  NULL, NULL, NULL
2587  },
2588  {
2589  {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2590  gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
2591  NULL
2592  },
2593  &vacuum_multixact_failsafe_age,
2594  1600000000, 0, 2100000000,
2595  NULL, NULL, NULL
2596  },
2597 
2598  /*
2599  * See also CheckRequiredParameterValues() if this parameter changes
2600  */
2601  {
2602  {"max_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
2603  gettext_noop("Sets the maximum number of locks per transaction."),
2604  gettext_noop("The shared lock table is sized on the assumption that at most "
2605  "max_locks_per_transaction objects per server process or prepared "
2606  "transaction will need to be locked at any one time.")
2607  },
2608  &max_locks_per_xact,
2609  64, 10, INT_MAX,
2610  NULL, NULL, NULL
2611  },
2612 
2613  {
2614  {"max_pred_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
2615  gettext_noop("Sets the maximum number of predicate locks per transaction."),
2616  gettext_noop("The shared predicate lock table is sized on the assumption that "
2617  "at most max_pred_locks_per_transaction objects per server process "
2618  "or prepared transaction will need to be locked at any one time.")
2619  },
2620  &max_predicate_locks_per_xact,
2621  64, 10, INT_MAX,
2622  NULL, NULL, NULL
2623  },
2624 
2625  {
2626  {"max_pred_locks_per_relation", PGC_SIGHUP, LOCK_MANAGEMENT,
2627  gettext_noop("Sets the maximum number of predicate-locked pages and tuples per relation."),
2628  gettext_noop("If more than this total of pages and tuples in the same relation are locked "
2629  "by a connection, those locks are replaced by a relation-level lock.")
2630  },
2631  &max_predicate_locks_per_relation,
2632  -2, INT_MIN, INT_MAX,
2633  NULL, NULL, NULL
2634  },
2635 
2636  {
2637  {"max_pred_locks_per_page", PGC_SIGHUP, LOCK_MANAGEMENT,
2638  gettext_noop("Sets the maximum number of predicate-locked tuples per page."),
2639  gettext_noop("If more than this number of tuples on the same page are locked "
2640  "by a connection, those locks are replaced by a page-level lock.")
2641  },
2642  &max_predicate_locks_per_page,
2643  2, 0, INT_MAX,
2644  NULL, NULL, NULL
2645  },
2646 
2647  {
2648  {"authentication_timeout", PGC_SIGHUP, CONN_AUTH_AUTH,
2649  gettext_noop("Sets the maximum allowed time to complete client authentication."),
2650  NULL,
2651  GUC_UNIT_S
2652  },
2653  &AuthenticationTimeout,
2654  60, 1, 600,
2655  NULL, NULL, NULL
2656  },
2657 
2658  {
2659  /* Not for general use */
2660  {"pre_auth_delay", PGC_SIGHUP, DEVELOPER_OPTIONS,
2661  gettext_noop("Sets the amount of time to wait before "
2662  "authentication on connection startup."),
2663  gettext_noop("This allows attaching a debugger to the process."),
2664  GUC_NOT_IN_SAMPLE | GUC_UNIT_S
2665  },
2666  &PreAuthDelay,
2667  0, 0, 60,
2668  NULL, NULL, NULL
2669  },
2670 
2671  {
2672  {"wal_decode_buffer_size", PGC_POSTMASTER, WAL_RECOVERY,
2673  gettext_noop("Buffer size for reading ahead in the WAL during recovery."),
2674  gettext_noop("Maximum distance to read ahead in the WAL to prefetch referenced data blocks."),
2675  GUC_UNIT_BYTE
2676  },
2677  &wal_decode_buffer_size,
2678  512 * 1024, 64 * 1024, MaxAllocSize,
2679  NULL, NULL, NULL
2680  },
2681 
2682  {
2683  {"wal_keep_size", PGC_SIGHUP, REPLICATION_SENDING,
2684  gettext_noop("Sets the size of WAL files held for standby servers."),
2685  NULL,
2686  GUC_UNIT_MB
2687  },
2688  &wal_keep_size_mb,
2689  0, 0, MAX_KILOBYTES,
2690  NULL, NULL, NULL
2691  },
2692 
2693  {
2694  {"min_wal_size", PGC_SIGHUP, WAL_CHECKPOINTS,
2695  gettext_noop("Sets the minimum size to shrink the WAL to."),
2696  NULL,
2697  GUC_UNIT_MB
2698  },
2699  &min_wal_size_mb,
2700  DEFAULT_MIN_WAL_SEGS * (DEFAULT_XLOG_SEG_SIZE / (1024 * 1024)),
2701  2, MAX_KILOBYTES,
2702  NULL, NULL, NULL
2703  },
2704 
2705  {
2706  {"max_wal_size", PGC_SIGHUP, WAL_CHECKPOINTS,
2707  gettext_noop("Sets the WAL size that triggers a checkpoint."),
2708  NULL,
2709  GUC_UNIT_MB
2710  },
2711  &max_wal_size_mb,
2712  DEFAULT_MAX_WAL_SEGS * (DEFAULT_XLOG_SEG_SIZE / (1024 * 1024)),
2713  2, MAX_KILOBYTES,
2714  NULL, assign_max_wal_size, NULL
2715  },
2716 
2717  {
2718  {"checkpoint_timeout", PGC_SIGHUP, WAL_CHECKPOINTS,
2719  gettext_noop("Sets the maximum time between automatic WAL checkpoints."),
2720  NULL,
2721  GUC_UNIT_S
2722  },
2723  &CheckPointTimeout,
2724  300, 30, 86400,
2725  NULL, NULL, NULL
2726  },
2727 
2728  {
2729  {"checkpoint_warning", PGC_SIGHUP, WAL_CHECKPOINTS,
2730  gettext_noop("Sets the maximum time before warning if checkpoints "
2731  "triggered by WAL volume happen too frequently."),
2732  gettext_noop("Write a message to the server log if checkpoints "
2733  "caused by the filling of WAL segment files happen more "
2734  "frequently than this amount of time. "
2735  "Zero turns off the warning."),
2736  GUC_UNIT_S
2737  },
2738  &CheckPointWarning,
2739  30, 0, INT_MAX,
2740  NULL, NULL, NULL
2741  },
2742 
2743  {
2744  {"checkpoint_flush_after", PGC_SIGHUP, WAL_CHECKPOINTS,
2745  gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
2746  NULL,
2747  GUC_UNIT_BLOCKS
2748  },
2749  &checkpoint_flush_after,
2750  DEFAULT_CHECKPOINT_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
2751  NULL, NULL, NULL
2752  },
2753 
2754  {
2755  {"wal_buffers", PGC_POSTMASTER, WAL_SETTINGS,
2756  gettext_noop("Sets the number of disk-page buffers in shared memory for WAL."),
2757  NULL,
2758  GUC_UNIT_XBLOCKS
2759  },
2760  &XLOGbuffers,
2761  -1, -1, (INT_MAX / XLOG_BLCKSZ),
2762  check_wal_buffers, NULL, NULL
2763  },
2764 
2765  {
2766  {"wal_writer_delay", PGC_SIGHUP, WAL_SETTINGS,
2767  gettext_noop("Time between WAL flushes performed in the WAL writer."),
2768  NULL,
2769  GUC_UNIT_MS
2770  },
2771  &WalWriterDelay,
2772  200, 1, 10000,
2773  NULL, NULL, NULL
2774  },
2775 
2776  {
2777  {"wal_writer_flush_after", PGC_SIGHUP, WAL_SETTINGS,
2778  gettext_noop("Amount of WAL written out by WAL writer that triggers a flush."),
2779  NULL,
2780  GUC_UNIT_XBLOCKS
2781  },
2782  &WalWriterFlushAfter,
2783  DEFAULT_WAL_WRITER_FLUSH_AFTER, 0, INT_MAX,
2784  NULL, NULL, NULL
2785  },
2786 
2787  {
2788  {"wal_skip_threshold", PGC_USERSET, WAL_SETTINGS,
2789  gettext_noop("Minimum size of new file to fsync instead of writing WAL."),
2790  NULL,
2791  GUC_UNIT_KB
2792  },
2793  &wal_skip_threshold,
2794  2048, 0, MAX_KILOBYTES,
2795  NULL, NULL, NULL
2796  },
2797 
2798  {
2799  {"max_wal_senders", PGC_POSTMASTER, REPLICATION_SENDING,
2800  gettext_noop("Sets the maximum number of simultaneously running WAL sender processes."),
2801  NULL
2802  },
2803  &max_wal_senders,
2804  10, 0, MAX_BACKENDS,
2805  check_max_wal_senders, NULL, NULL
2806  },
2807 
2808  {
2809  /* see max_wal_senders */
2810  {"max_replication_slots", PGC_POSTMASTER, REPLICATION_SENDING,
2811  gettext_noop("Sets the maximum number of simultaneously defined replication slots."),
2812  NULL
2813  },
2814  &max_replication_slots,
2815  10, 0, MAX_BACKENDS /* XXX? */ ,
2816  NULL, NULL, NULL
2817  },
2818 
2819  {
2820  {"max_slot_wal_keep_size", PGC_SIGHUP, REPLICATION_SENDING,
2821  gettext_noop("Sets the maximum WAL size that can be reserved by replication slots."),
2822  gettext_noop("Replication slots will be marked as failed, and segments released "
2823  "for deletion or recycling, if this much space is occupied by WAL "
2824  "on disk."),
2825  GUC_UNIT_MB
2826  },
2827  &max_slot_wal_keep_size_mb,
2828  -1, -1, MAX_KILOBYTES,
2829  NULL, NULL, NULL
2830  },
2831 
2832  {
2833  {"wal_sender_timeout", PGC_USERSET, REPLICATION_SENDING,
2834  gettext_noop("Sets the maximum time to wait for WAL replication."),
2835  NULL,
2836  GUC_UNIT_MS
2837  },
2838  &wal_sender_timeout,
2839  60 * 1000, 0, INT_MAX,
2840  NULL, NULL, NULL
2841  },
2842 
2843  {
2844  {"commit_delay", PGC_SUSET, WAL_SETTINGS,
2845  gettext_noop("Sets the delay in microseconds between transaction commit and "
2846  "flushing WAL to disk."),
2847  NULL
2848  /* we have no microseconds designation, so can't supply units here */
2849  },
2850  &CommitDelay,
2851  0, 0, 100000,
2852  NULL, NULL, NULL
2853  },
2854 
2855  {
2856  {"commit_siblings", PGC_USERSET, WAL_SETTINGS,
2857  gettext_noop("Sets the minimum number of concurrent open transactions "
2858  "required before performing commit_delay."),
2859  NULL
2860  },
2861  &CommitSiblings,
2862  5, 0, 1000,
2863  NULL, NULL, NULL
2864  },
2865 
2866  {
2867  {"extra_float_digits", PGC_USERSET, CLIENT_CONN_LOCALE,
2868  gettext_noop("Sets the number of digits displayed for floating-point values."),
2869  gettext_noop("This affects real, double precision, and geometric data types. "
2870  "A zero or negative parameter value is added to the standard "
2871  "number of digits (FLT_DIG or DBL_DIG as appropriate). "
2872  "Any value greater than zero selects precise output mode.")
2873  },
2874  &extra_float_digits,
2875  1, -15, 3,
2876  NULL, NULL, NULL
2877  },
2878 
2879  {
2880  {"log_min_duration_sample", PGC_SUSET, LOGGING_WHEN,
2881  gettext_noop("Sets the minimum execution time above which "
2882  "a sample of statements will be logged."
2883  " Sampling is determined by log_statement_sample_rate."),
2884  gettext_noop("Zero logs a sample of all queries. -1 turns this feature off."),
2885  GUC_UNIT_MS
2886  },
2887  &log_min_duration_sample,
2888  -1, -1, INT_MAX,
2889  NULL, NULL, NULL
2890  },
2891 
2892  {
2893  {"log_min_duration_statement", PGC_SUSET, LOGGING_WHEN,
2894  gettext_noop("Sets the minimum execution time above which "
2895  "all statements will be logged."),
2896  gettext_noop("Zero prints all queries. -1 turns this feature off."),
2897  GUC_UNIT_MS
2898  },
2899  &log_min_duration_statement,
2900  -1, -1, INT_MAX,
2901  NULL, NULL, NULL
2902  },
2903 
2904  {
2905  {"log_autovacuum_min_duration", PGC_SIGHUP, LOGGING_WHAT,
2906  gettext_noop("Sets the minimum execution time above which "
2907  "autovacuum actions will be logged."),
2908  gettext_noop("Zero prints all actions. -1 turns autovacuum logging off."),
2909  GUC_UNIT_MS
2910  },
2911  &Log_autovacuum_min_duration,
2912  600000, -1, INT_MAX,
2913  NULL, NULL, NULL
2914  },
2915 
2916  {
2917  {"log_parameter_max_length", PGC_SUSET, LOGGING_WHAT,
2918  gettext_noop("Sets the maximum length in bytes of data logged for bind "
2919  "parameter values when logging statements."),
2920  gettext_noop("-1 to print values in full."),
2921  GUC_UNIT_BYTE
2922  },
2923  &log_parameter_max_length,
2924  -1, -1, INT_MAX / 2,
2925  NULL, NULL, NULL
2926  },
2927 
2928  {
2929  {"log_parameter_max_length_on_error", PGC_USERSET, LOGGING_WHAT,
2930  gettext_noop("Sets the maximum length in bytes of data logged for bind "
2931  "parameter values when logging statements, on error."),
2932  gettext_noop("-1 to print values in full."),
2933  GUC_UNIT_BYTE
2934  },
2935  &log_parameter_max_length_on_error,
2936  0, -1, INT_MAX / 2,
2937  NULL, NULL, NULL
2938  },
2939 
2940  {
2941  {"bgwriter_delay", PGC_SIGHUP, RESOURCES_BGWRITER,
2942  gettext_noop("Background writer sleep time between rounds."),
2943  NULL,
2944  GUC_UNIT_MS
2945  },
2946  &BgWriterDelay,
2947  200, 10, 10000,
2948  NULL, NULL, NULL
2949  },
2950 
2951  {
2952  {"bgwriter_lru_maxpages", PGC_SIGHUP, RESOURCES_BGWRITER,
2953  gettext_noop("Background writer maximum number of LRU pages to flush per round."),
2954  NULL
2955  },
2956  &bgwriter_lru_maxpages,
2957  100, 0, INT_MAX / 2, /* Same upper limit as shared_buffers */
2958  NULL, NULL, NULL
2959  },
2960 
2961  {
2962  {"bgwriter_flush_after", PGC_SIGHUP, RESOURCES_BGWRITER,
2963  gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
2964  NULL,
2965  GUC_UNIT_BLOCKS
2966  },
2967  &bgwriter_flush_after,
2968  DEFAULT_BGWRITER_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
2969  NULL, NULL, NULL
2970  },
2971 
2972  {
2973  {"effective_io_concurrency",
2974  PGC_USERSET,
2975  RESOURCES_ASYNCHRONOUS,
2976  gettext_noop("Number of simultaneous requests that can be handled efficiently by the disk subsystem."),
2977  NULL,
2978  GUC_EXPLAIN
2979  },
2980  &effective_io_concurrency,
2981  DEFAULT_EFFECTIVE_IO_CONCURRENCY,
2982  0, MAX_IO_CONCURRENCY,
2983  check_effective_io_concurrency, NULL, NULL
2984  },
2985 
2986  {
2987  {"maintenance_io_concurrency",
2988  PGC_USERSET,
2989  RESOURCES_ASYNCHRONOUS,
2990  gettext_noop("A variant of effective_io_concurrency that is used for maintenance work."),
2991  NULL,
2992  GUC_EXPLAIN
2993  },
2994  &maintenance_io_concurrency,
2995  DEFAULT_MAINTENANCE_IO_CONCURRENCY,
2996  0, MAX_IO_CONCURRENCY,
2997  check_maintenance_io_concurrency, assign_maintenance_io_concurrency,
2998  NULL
2999  },
3000 
3001  {
3002  {"backend_flush_after", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3003  gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
3004  NULL,
3005  GUC_UNIT_BLOCKS
3006  },
3007  &backend_flush_after,
3008  DEFAULT_BACKEND_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
3009  NULL, NULL, NULL
3010  },
3011 
3012  {
3013  {"max_worker_processes",
3014  PGC_POSTMASTER,
3015  RESOURCES_ASYNCHRONOUS,
3016  gettext_noop("Maximum number of concurrent worker processes."),
3017  NULL,
3018  },
3019  &max_worker_processes,
3020  8, 0, MAX_BACKENDS,
3021  check_max_worker_processes, NULL, NULL
3022  },
3023 
3024  {
3025  {"max_logical_replication_workers",
3026  PGC_POSTMASTER,
3027  REPLICATION_SUBSCRIBERS,
3028  gettext_noop("Maximum number of logical replication worker processes."),
3029  NULL,
3030  },
3031  &max_logical_replication_workers,
3032  4, 0, MAX_BACKENDS,
3033  NULL, NULL, NULL
3034  },
3035 
3036  {
3037  {"max_sync_workers_per_subscription",
3038  PGC_SIGHUP,
3039  REPLICATION_SUBSCRIBERS,
3040  gettext_noop("Maximum number of table synchronization workers per subscription."),
3041  NULL,
3042  },
3043  &max_sync_workers_per_subscription,
3044  2, 0, MAX_BACKENDS,
3045  NULL, NULL, NULL
3046  },
3047 
3048  {
3049  {"max_parallel_apply_workers_per_subscription",
3050  PGC_SIGHUP,
3051  REPLICATION_SUBSCRIBERS,
3052  gettext_noop("Maximum number of parallel apply workers per subscription."),
3053  NULL,
3054  },
3055  &max_parallel_apply_workers_per_subscription,
3056  2, 0, MAX_PARALLEL_WORKER_LIMIT,
3057  NULL, NULL, NULL
3058  },
3059 
3060  {
3061  {"log_rotation_age", PGC_SIGHUP, LOGGING_WHERE,
3062  gettext_noop("Sets the amount of time to wait before forcing "
3063  "log file rotation."),
3064  NULL,
3065  GUC_UNIT_MIN
3066  },
3067  &Log_RotationAge,
3068  HOURS_PER_DAY * MINS_PER_HOUR, 0, INT_MAX / SECS_PER_MINUTE,
3069  NULL, NULL, NULL
3070  },
3071 
3072  {
3073  {"log_rotation_size", PGC_SIGHUP, LOGGING_WHERE,
3074  gettext_noop("Sets the maximum size a log file can reach before "
3075  "being rotated."),
3076  NULL,
3077  GUC_UNIT_KB
3078  },
3079  &Log_RotationSize,
3080  10 * 1024, 0, INT_MAX / 1024,
3081  NULL, NULL, NULL
3082  },
3083 
3084  {
3085  {"max_function_args", PGC_INTERNAL, PRESET_OPTIONS,
3086  gettext_noop("Shows the maximum number of function arguments."),
3087  NULL,
3088  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3089  },
3090  &max_function_args,
3091  FUNC_MAX_ARGS, FUNC_MAX_ARGS, FUNC_MAX_ARGS,
3092  NULL, NULL, NULL
3093  },
3094 
3095  {
3096  {"max_index_keys", PGC_INTERNAL, PRESET_OPTIONS,
3097  gettext_noop("Shows the maximum number of index keys."),
3098  NULL,
3099  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3100  },
3101  &max_index_keys,
3102  INDEX_MAX_KEYS, INDEX_MAX_KEYS, INDEX_MAX_KEYS,
3103  NULL, NULL, NULL
3104  },
3105 
3106  {
3107  {"max_identifier_length", PGC_INTERNAL, PRESET_OPTIONS,
3108  gettext_noop("Shows the maximum identifier length."),
3109  NULL,
3110  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3111  },
3112  &max_identifier_length,
3113  NAMEDATALEN - 1, NAMEDATALEN - 1, NAMEDATALEN - 1,
3114  NULL, NULL, NULL
3115  },
3116 
3117  {
3118  {"block_size", PGC_INTERNAL, PRESET_OPTIONS,
3119  gettext_noop("Shows the size of a disk block."),
3120  NULL,
3121  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3122  },
3123  &block_size,
3124  BLCKSZ, BLCKSZ, BLCKSZ,
3125  NULL, NULL, NULL
3126  },
3127 
3128  {
3129  {"segment_size", PGC_INTERNAL, PRESET_OPTIONS,
3130  gettext_noop("Shows the number of pages per disk file."),
3131  NULL,
3132  GUC_UNIT_BLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3133  },
3134  &segment_size,
3135  RELSEG_SIZE, RELSEG_SIZE, RELSEG_SIZE,
3136  NULL, NULL, NULL
3137  },
3138 
3139  {
3140  {"wal_block_size", PGC_INTERNAL, PRESET_OPTIONS,
3141  gettext_noop("Shows the block size in the write ahead log."),
3142  NULL,
3143  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3144  },
3145  &wal_block_size,
3146  XLOG_BLCKSZ, XLOG_BLCKSZ, XLOG_BLCKSZ,
3147  NULL, NULL, NULL
3148  },
3149 
3150  {
3151  {"wal_retrieve_retry_interval", PGC_SIGHUP, REPLICATION_STANDBY,
3152  gettext_noop("Sets the time to wait before retrying to retrieve WAL "
3153  "after a failed attempt."),
3154  NULL,
3155  GUC_UNIT_MS
3156  },
3157  &wal_retrieve_retry_interval,
3158  5000, 1, INT_MAX,
3159  NULL, NULL, NULL
3160  },
3161 
3162  {
3163  {"wal_segment_size", PGC_INTERNAL, PRESET_OPTIONS,
3164  gettext_noop("Shows the size of write ahead log segments."),
3165  NULL,
3166  GUC_UNIT_BYTE | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
3167  },
3168  &wal_segment_size,
3169  DEFAULT_XLOG_SEG_SIZE,
3170  WalSegMinSize,
3171  WalSegMaxSize,
3172  NULL, NULL, NULL
3173  },
3174 
3175  {
3176  {"autovacuum_naptime", PGC_SIGHUP, AUTOVACUUM,
3177  gettext_noop("Time to sleep between autovacuum runs."),
3178  NULL,
3179  GUC_UNIT_S
3180  },
3181  &autovacuum_naptime,
3182  60, 1, INT_MAX / 1000,
3183  NULL, NULL, NULL
3184  },
3185  {
3186  {"autovacuum_vacuum_threshold", PGC_SIGHUP, AUTOVACUUM,
3187  gettext_noop("Minimum number of tuple updates or deletes prior to vacuum."),
3188  NULL
3189  },
3190  &autovacuum_vac_thresh,
3191  50, 0, INT_MAX,
3192  NULL, NULL, NULL
3193  },
3194  {
3195  {"autovacuum_vacuum_insert_threshold", PGC_SIGHUP, AUTOVACUUM,
3196  gettext_noop("Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums."),
3197  NULL
3198  },
3199  &autovacuum_vac_ins_thresh,
3200  1000, -1, INT_MAX,
3201  NULL, NULL, NULL
3202  },
3203  {
3204  {"autovacuum_analyze_threshold", PGC_SIGHUP, AUTOVACUUM,
3205  gettext_noop("Minimum number of tuple inserts, updates, or deletes prior to analyze."),
3206  NULL
3207  },
3208  &autovacuum_anl_thresh,
3209  50, 0, INT_MAX,
3210  NULL, NULL, NULL
3211  },
3212  {
3213  /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
3214  {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
3215  gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
3216  NULL
3217  },
3218  &autovacuum_freeze_max_age,
3219 
3220  /* see vacuum_failsafe_age if you change the upper-limit value. */
3221  200000000, 100000, 2000000000,
3222  NULL, NULL, NULL
3223  },
3224  {
3225  /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
3226  {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
3227  gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
3228  NULL
3229  },
3230  &autovacuum_multixact_freeze_max_age,
3231  400000000, 10000, 2000000000,
3232  NULL, NULL, NULL
3233  },
3234  {
3235  /* see max_connections */
3236  {"autovacuum_max_workers", PGC_POSTMASTER, AUTOVACUUM,
3237  gettext_noop("Sets the maximum number of simultaneously running autovacuum worker processes."),
3238  NULL
3239  },
3240  &autovacuum_max_workers,
3241  3, 1, MAX_BACKENDS,
3242  check_autovacuum_max_workers, NULL, NULL
3243  },
3244 
3245  {
3246  {"max_parallel_maintenance_workers", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3247  gettext_noop("Sets the maximum number of parallel processes per maintenance operation."),
3248  NULL
3249  },
3250  &max_parallel_maintenance_workers,
3251  2, 0, 1024,
3252  NULL, NULL, NULL
3253  },
3254 
3255  {
3256  {"max_parallel_workers_per_gather", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3257  gettext_noop("Sets the maximum number of parallel processes per executor node."),
3258  NULL,
3259  GUC_EXPLAIN
3260  },
3261  &max_parallel_workers_per_gather,
3262  2, 0, MAX_PARALLEL_WORKER_LIMIT,
3263  NULL, NULL, NULL
3264  },
3265 
3266  {
3267  {"max_parallel_workers", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3268  gettext_noop("Sets the maximum number of parallel workers that can be active at one time."),
3269  NULL,
3270  GUC_EXPLAIN
3271  },
3272  &max_parallel_workers,
3273  8, 0, MAX_PARALLEL_WORKER_LIMIT,
3274  NULL, NULL, NULL
3275  },
3276 
3277  {
3278  {"autovacuum_work_mem", PGC_SIGHUP, RESOURCES_MEM,
3279  gettext_noop("Sets the maximum memory to be used by each autovacuum worker process."),
3280  NULL,
3281  GUC_UNIT_KB
3282  },
3283  &autovacuum_work_mem,
3284  -1, -1, MAX_KILOBYTES,
3285  check_autovacuum_work_mem, NULL, NULL
3286  },
3287 
3288  {
3289  {"old_snapshot_threshold", PGC_POSTMASTER, RESOURCES_ASYNCHRONOUS,
3290  gettext_noop("Time before a snapshot is too old to read pages changed after the snapshot was taken."),
3291  gettext_noop("A value of -1 disables this feature."),
3292  GUC_UNIT_MIN
3293  },
3294  &old_snapshot_threshold,
3295  -1, -1, MINS_PER_HOUR * HOURS_PER_DAY * 60,
3296  NULL, NULL, NULL
3297  },
3298 
3299  {
3300  {"tcp_keepalives_idle", PGC_USERSET, CONN_AUTH_TCP,
3301  gettext_noop("Time between issuing TCP keepalives."),
3302  gettext_noop("A value of 0 uses the system default."),
3303  GUC_UNIT_S
3304  },
3305  &tcp_keepalives_idle,
3306  0, 0, INT_MAX,
3307  NULL, assign_tcp_keepalives_idle, show_tcp_keepalives_idle
3308  },
3309 
3310  {
3311  {"tcp_keepalives_interval", PGC_USERSET, CONN_AUTH_TCP,
3312  gettext_noop("Time between TCP keepalive retransmits."),
3313  gettext_noop("A value of 0 uses the system default."),
3314  GUC_UNIT_S
3315  },
3316  &tcp_keepalives_interval,
3317  0, 0, INT_MAX,
3318  NULL, assign_tcp_keepalives_interval, show_tcp_keepalives_interval
3319  },
3320 
3321  {
3322  {"ssl_renegotiation_limit", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
3323  gettext_noop("SSL renegotiation is no longer supported; this can only be 0."),
3324  NULL,
3325  GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE,
3326  },
3327  &ssl_renegotiation_limit,
3328  0, 0, 0,
3329  NULL, NULL, NULL
3330  },
3331 
3332  {
3333  {"tcp_keepalives_count", PGC_USERSET, CONN_AUTH_TCP,
3334  gettext_noop("Maximum number of TCP keepalive retransmits."),
3335  gettext_noop("Number of consecutive keepalive retransmits that can be "
3336  "lost before a connection is considered dead. A value of 0 uses the "
3337  "system default."),
3338  },
3339  &tcp_keepalives_count,
3340  0, 0, INT_MAX,
3341  NULL, assign_tcp_keepalives_count, show_tcp_keepalives_count
3342  },
3343 
3344  {
3345  {"gin_fuzzy_search_limit", PGC_USERSET, CLIENT_CONN_OTHER,
3346  gettext_noop("Sets the maximum allowed result for exact search by GIN."),
3347  NULL,
3348  0
3349  },
3350  &GinFuzzySearchLimit,
3351  0, 0, INT_MAX,
3352  NULL, NULL, NULL
3353  },
3354 
3355  {
3356  {"effective_cache_size", PGC_USERSET, QUERY_TUNING_COST,
3357  gettext_noop("Sets the planner's assumption about the total size of the data caches."),
3358  gettext_noop("That is, the total size of the caches (kernel cache and shared buffers) used for PostgreSQL data files. "
3359  "This is measured in disk pages, which are normally 8 kB each."),
3360  GUC_UNIT_BLOCKS | GUC_EXPLAIN,
3361  },
3362  &effective_cache_size,
3363  DEFAULT_EFFECTIVE_CACHE_SIZE, 1, INT_MAX,
3364  NULL, NULL, NULL
3365  },
3366 
3367  {
3368  {"min_parallel_table_scan_size", PGC_USERSET, QUERY_TUNING_COST,
3369  gettext_noop("Sets the minimum amount of table data for a parallel scan."),
3370  gettext_noop("If the planner estimates that it will read a number of table pages too small to reach this limit, a parallel scan will not be considered."),
3371  GUC_UNIT_BLOCKS | GUC_EXPLAIN,
3372  },
3373  &min_parallel_table_scan_size,
3374  (8 * 1024 * 1024) / BLCKSZ, 0, INT_MAX / 3,
3375  NULL, NULL, NULL
3376  },
3377 
3378  {
3379  {"min_parallel_index_scan_size", PGC_USERSET, QUERY_TUNING_COST,
3380  gettext_noop("Sets the minimum amount of index data for a parallel scan."),
3381  gettext_noop("If the planner estimates that it will read a number of index pages too small to reach this limit, a parallel scan will not be considered."),
3382  GUC_UNIT_BLOCKS | GUC_EXPLAIN,
3383  },
3384  &min_parallel_index_scan_size,
3385  (512 * 1024) / BLCKSZ, 0, INT_MAX / 3,
3386  NULL, NULL, NULL
3387  },
3388 
3389  {
3390  /* Can't be set in postgresql.conf */
3391  {"server_version_num", PGC_INTERNAL, PRESET_OPTIONS,
3392  gettext_noop("Shows the server version as an integer."),
3393  NULL,
3394  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3395  },
3396  &server_version_num,
3397  PG_VERSION_NUM, PG_VERSION_NUM, PG_VERSION_NUM,
3398  NULL, NULL, NULL
3399  },
3400 
3401  {
3402  {"log_temp_files", PGC_SUSET, LOGGING_WHAT,
3403  gettext_noop("Log the use of temporary files larger than this number of kilobytes."),
3404  gettext_noop("Zero logs all files. The default is -1 (turning this feature off)."),
3405  GUC_UNIT_KB
3406  },
3407  &log_temp_files,
3408  -1, -1, INT_MAX,
3409  NULL, NULL, NULL
3410  },
3411 
3412  {
3413  {"track_activity_query_size", PGC_POSTMASTER, STATS_CUMULATIVE,
3414  gettext_noop("Sets the size reserved for pg_stat_activity.query, in bytes."),
3415  NULL,
3416  GUC_UNIT_BYTE
3417  },
3418  &pgstat_track_activity_query_size,
3419  1024, 100, 1048576,
3420  NULL, NULL, NULL
3421  },
3422 
3423  {
3424  {"gin_pending_list_limit", PGC_USERSET, CLIENT_CONN_STATEMENT,
3425  gettext_noop("Sets the maximum size of the pending list for GIN index."),
3426  NULL,
3427  GUC_UNIT_KB
3428  },
3429  &gin_pending_list_limit,
3430  4096, 64, MAX_KILOBYTES,
3431  NULL, NULL, NULL
3432  },
3433 
3434  {
3435  {"tcp_user_timeout", PGC_USERSET, CONN_AUTH_TCP,
3436  gettext_noop("TCP user timeout."),
3437  gettext_noop("A value of 0 uses the system default."),
3438  GUC_UNIT_MS
3439  },
3440  &tcp_user_timeout,
3441  0, 0, INT_MAX,
3442  NULL, assign_tcp_user_timeout, show_tcp_user_timeout
3443  },
3444 
3445  {
3446  {"huge_page_size", PGC_POSTMASTER, RESOURCES_MEM,
3447  gettext_noop("The size of huge page that should be requested."),
3448  NULL,
3449  GUC_UNIT_KB
3450  },
3451  &huge_page_size,
3452  0, 0, INT_MAX,
3453  check_huge_page_size, NULL, NULL
3454  },
3455 
3456  {
3457  {"debug_discard_caches", PGC_SUSET, DEVELOPER_OPTIONS,
3458  gettext_noop("Aggressively flush system caches for debugging purposes."),
3459  NULL,
3460  GUC_NOT_IN_SAMPLE
3461  },
3462  &debug_discard_caches,
3463 #ifdef DISCARD_CACHES_ENABLED
3464  /* Set default based on older compile-time-only cache clobber macros */
3465 #if defined(CLOBBER_CACHE_RECURSIVELY)
3466  3,
3467 #elif defined(CLOBBER_CACHE_ALWAYS)
3468  1,
3469 #else
3470  0,
3471 #endif
3472  0, 5,
3473 #else /* not DISCARD_CACHES_ENABLED */
3474  0, 0, 0,
3475 #endif /* not DISCARD_CACHES_ENABLED */
3476  NULL, NULL, NULL
3477  },
3478 
3479  {
3480  {"client_connection_check_interval", PGC_USERSET, CONN_AUTH_TCP,
3481  gettext_noop("Sets the time interval between checks for disconnection while running queries."),
3482  NULL,
3483  GUC_UNIT_MS
3484  },
3485  &client_connection_check_interval,
3486  0, 0, INT_MAX,
3487  check_client_connection_check_interval, NULL, NULL
3488  },
3489 
3490  {
3491  {"log_startup_progress_interval", PGC_SIGHUP, LOGGING_WHEN,
3492  gettext_noop("Time between progress updates for "
3493  "long-running startup operations."),
3494  gettext_noop("0 turns this feature off."),
3495  GUC_UNIT_MS,
3496  },
3497  &log_startup_progress_interval,
3498  10000, 0, INT_MAX,
3499  NULL, NULL, NULL
3500  },
3501 
3502  {
3503  {"scram_iterations", PGC_USERSET, CONN_AUTH_AUTH,
3504  gettext_noop("Sets the iteration count for SCRAM secret generation."),
3505  NULL,
3506  GUC_REPORT
3507  },
3508  &scram_sha_256_iterations,
3509  SCRAM_SHA_256_DEFAULT_ITERATIONS, 1, INT_MAX,
3510  NULL, NULL, NULL
3511  },
3512 
3513  /* End-of-list marker */
3514  {
3515  {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
3516  }
3517 };
3518 
3519 
3520 struct config_real ConfigureNamesReal[] =
3521 {
3522  {
3523  {"seq_page_cost", PGC_USERSET, QUERY_TUNING_COST,
3524  gettext_noop("Sets the planner's estimate of the cost of a "
3525  "sequentially fetched disk page."),
3526  NULL,
3527  GUC_EXPLAIN
3528  },
3529  &seq_page_cost,
3530  DEFAULT_SEQ_PAGE_COST, 0, DBL_MAX,
3531  NULL, NULL, NULL
3532  },
3533  {
3534  {"random_page_cost", PGC_USERSET, QUERY_TUNING_COST,
3535  gettext_noop("Sets the planner's estimate of the cost of a "
3536  "nonsequentially fetched disk page."),
3537  NULL,
3538  GUC_EXPLAIN
3539  },
3540  &random_page_cost,
3541  DEFAULT_RANDOM_PAGE_COST, 0, DBL_MAX,
3542  NULL, NULL, NULL
3543  },
3544  {
3545  {"cpu_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
3546  gettext_noop("Sets the planner's estimate of the cost of "
3547  "processing each tuple (row)."),
3548  NULL,
3549  GUC_EXPLAIN
3550  },
3551  &cpu_tuple_cost,
3552  DEFAULT_CPU_TUPLE_COST, 0, DBL_MAX,
3553  NULL, NULL, NULL
3554  },
3555  {
3556  {"cpu_index_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
3557  gettext_noop("Sets the planner's estimate of the cost of "
3558  "processing each index entry during an index scan."),
3559  NULL,
3560  GUC_EXPLAIN
3561  },
3562  &cpu_index_tuple_cost,
3563  DEFAULT_CPU_INDEX_TUPLE_COST, 0, DBL_MAX,
3564  NULL, NULL, NULL
3565  },
3566  {
3567  {"cpu_operator_cost", PGC_USERSET, QUERY_TUNING_COST,
3568  gettext_noop("Sets the planner's estimate of the cost of "
3569  "processing each operator or function call."),
3570  NULL,
3571  GUC_EXPLAIN
3572  },
3573  &cpu_operator_cost,
3574  DEFAULT_CPU_OPERATOR_COST, 0, DBL_MAX,
3575  NULL, NULL, NULL
3576  },
3577  {
3578  {"parallel_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
3579  gettext_noop("Sets the planner's estimate of the cost of "
3580  "passing each tuple (row) from worker to leader backend."),
3581  NULL,
3582  GUC_EXPLAIN
3583  },
3584  &parallel_tuple_cost,
3585  DEFAULT_PARALLEL_TUPLE_COST, 0, DBL_MAX,
3586  NULL, NULL, NULL
3587  },
3588  {
3589  {"parallel_setup_cost", PGC_USERSET, QUERY_TUNING_COST,
3590  gettext_noop("Sets the planner's estimate of the cost of "
3591  "starting up worker processes for parallel query."),
3592  NULL,
3593  GUC_EXPLAIN
3594  },
3595  &parallel_setup_cost,
3596  DEFAULT_PARALLEL_SETUP_COST, 0, DBL_MAX,
3597  NULL, NULL, NULL
3598  },
3599 
3600  {
3601  {"jit_above_cost", PGC_USERSET, QUERY_TUNING_COST,
3602  gettext_noop("Perform JIT compilation if query is more expensive."),
3603  gettext_noop("-1 disables JIT compilation."),
3604  GUC_EXPLAIN
3605  },
3606  &jit_above_cost,
3607  100000, -1, DBL_MAX,
3608  NULL, NULL, NULL
3609  },
3610 
3611  {
3612  {"jit_optimize_above_cost", PGC_USERSET, QUERY_TUNING_COST,
3613  gettext_noop("Optimize JIT-compiled functions if query is more expensive."),
3614  gettext_noop("-1 disables optimization."),
3615  GUC_EXPLAIN
3616  },
3617  &jit_optimize_above_cost,
3618  500000, -1, DBL_MAX,
3619  NULL, NULL, NULL
3620  },
3621 
3622  {
3623  {"jit_inline_above_cost", PGC_USERSET, QUERY_TUNING_COST,
3624  gettext_noop("Perform JIT inlining if query is more expensive."),
3625  gettext_noop("-1 disables inlining."),
3626  GUC_EXPLAIN
3627  },
3628  &jit_inline_above_cost,
3629  500000, -1, DBL_MAX,
3630  NULL, NULL, NULL
3631  },
3632 
3633  {
3634  {"cursor_tuple_fraction", PGC_USERSET, QUERY_TUNING_OTHER,
3635  gettext_noop("Sets the planner's estimate of the fraction of "
3636  "a cursor's rows that will be retrieved."),
3637  NULL,
3638  GUC_EXPLAIN
3639  },
3640  &cursor_tuple_fraction,
3641  DEFAULT_CURSOR_TUPLE_FRACTION, 0.0, 1.0,
3642  NULL, NULL, NULL
3643  },
3644 
3645  {
3646  {"recursive_worktable_factor", PGC_USERSET, QUERY_TUNING_OTHER,
3647  gettext_noop("Sets the planner's estimate of the average size "
3648  "of a recursive query's working table."),
3649  NULL,
3650  GUC_EXPLAIN
3651  },
3652  &recursive_worktable_factor,
3653  DEFAULT_RECURSIVE_WORKTABLE_FACTOR, 0.001, 1000000.0,
3654  NULL, NULL, NULL
3655  },
3656 
3657  {
3658  {"geqo_selection_bias", PGC_USERSET, QUERY_TUNING_GEQO,
3659  gettext_noop("GEQO: selective pressure within the population."),
3660  NULL,
3661  GUC_EXPLAIN
3662  },
3663  &Geqo_selection_bias,
3664  DEFAULT_GEQO_SELECTION_BIAS,
3665  MIN_GEQO_SELECTION_BIAS, MAX_GEQO_SELECTION_BIAS,
3666  NULL, NULL, NULL
3667  },
3668  {
3669  {"geqo_seed", PGC_USERSET, QUERY_TUNING_GEQO,
3670  gettext_noop("GEQO: seed for random path selection."),
3671  NULL,
3672  GUC_EXPLAIN
3673  },
3674  &Geqo_seed,
3675  0.0, 0.0, 1.0,
3676  NULL, NULL, NULL
3677  },
3678 
3679  {
3680  {"hash_mem_multiplier", PGC_USERSET, RESOURCES_MEM,
3681  gettext_noop("Multiple of work_mem to use for hash tables."),
3682  NULL,
3683  GUC_EXPLAIN
3684  },
3685  &hash_mem_multiplier,
3686  2.0, 1.0, 1000.0,
3687  NULL, NULL, NULL
3688  },
3689 
3690  {
3691  {"bgwriter_lru_multiplier", PGC_SIGHUP, RESOURCES_BGWRITER,
3692  gettext_noop("Multiple of the average buffer usage to free per round."),
3693  NULL
3694  },
3695  &bgwriter_lru_multiplier,
3696  2.0, 0.0, 10.0,
3697  NULL, NULL, NULL
3698  },
3699 
3700  {
3701  {"seed", PGC_USERSET, UNGROUPED,
3702  gettext_noop("Sets the seed for random-number generation."),
3703  NULL,
3704  GUC_NO_SHOW_ALL | GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3705  },
3706  &phony_random_seed,
3707  0.0, -1.0, 1.0,
3708  check_random_seed, assign_random_seed, show_random_seed
3709  },
3710 
3711  {
3712  {"vacuum_cost_delay", PGC_USERSET, RESOURCES_VACUUM_DELAY,
3713  gettext_noop("Vacuum cost delay in milliseconds."),
3714  NULL,
3715  GUC_UNIT_MS
3716  },
3717  &VacuumCostDelay,
3718  0, 0, 100,
3719  NULL, NULL, NULL
3720  },
3721 
3722  {
3723  {"autovacuum_vacuum_cost_delay", PGC_SIGHUP, AUTOVACUUM,
3724  gettext_noop("Vacuum cost delay in milliseconds, for autovacuum."),
3725  NULL,
3726  GUC_UNIT_MS
3727  },
3728  &autovacuum_vac_cost_delay,
3729  2, -1, 100,
3730  NULL, NULL, NULL
3731  },
3732 
3733  {
3734  {"autovacuum_vacuum_scale_factor", PGC_SIGHUP, AUTOVACUUM,
3735  gettext_noop("Number of tuple updates or deletes prior to vacuum as a fraction of reltuples."),
3736  NULL
3737  },
3738  &autovacuum_vac_scale,
3739  0.2, 0.0, 100.0,
3740  NULL, NULL, NULL
3741  },
3742 
3743  {
3744  {"autovacuum_vacuum_insert_scale_factor", PGC_SIGHUP, AUTOVACUUM,
3745  gettext_noop("Number of tuple inserts prior to vacuum as a fraction of reltuples."),
3746  NULL
3747  },
3748  &autovacuum_vac_ins_scale,
3749  0.2, 0.0, 100.0,
3750  NULL, NULL, NULL
3751  },
3752 
3753  {
3754  {"autovacuum_analyze_scale_factor", PGC_SIGHUP, AUTOVACUUM,
3755  gettext_noop("Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples."),
3756  NULL
3757  },
3758  &autovacuum_anl_scale,
3759  0.1, 0.0, 100.0,
3760  NULL, NULL, NULL
3761  },
3762 
3763  {
3764  {"checkpoint_completion_target", PGC_SIGHUP, WAL_CHECKPOINTS,
3765  gettext_noop("Time spent flushing dirty buffers during checkpoint, as fraction of checkpoint interval."),
3766  NULL
3767  },
3768  &CheckPointCompletionTarget,
3769  0.9, 0.0, 1.0,
3770  NULL, assign_checkpoint_completion_target, NULL
3771  },
3772 
3773  {
3774  {"log_statement_sample_rate", PGC_SUSET, LOGGING_WHEN,
3775  gettext_noop("Fraction of statements exceeding log_min_duration_sample to be logged."),
3776  gettext_noop("Use a value between 0.0 (never log) and 1.0 (always log).")
3777  },
3778  &log_statement_sample_rate,
3779  1.0, 0.0, 1.0,
3780  NULL, NULL, NULL
3781  },
3782 
3783  {
3784  {"log_transaction_sample_rate", PGC_SUSET, LOGGING_WHEN,
3785  gettext_noop("Sets the fraction of transactions from which to log all statements."),
3786  gettext_noop("Use a value between 0.0 (never log) and 1.0 (log all "
3787  "statements for all transactions).")
3788  },
3789  &log_xact_sample_rate,
3790  0.0, 0.0, 1.0,
3791  NULL, NULL, NULL
3792  },
3793 
3794  /* End-of-list marker */
3795  {
3796  {NULL, 0, 0, NULL, NULL}, NULL, 0.0, 0.0, 0.0, NULL, NULL, NULL
3797  }
3798 };
3799 
3800 
3801 struct config_string ConfigureNamesString[] =
3802 {
3803  {
3804  {"archive_command", PGC_SIGHUP, WAL_ARCHIVING,
3805  gettext_noop("Sets the shell command that will be called to archive a WAL file."),
3806  gettext_noop("This is used only if \"archive_library\" is not set.")
3807  },
3808  &XLogArchiveCommand,
3809  "",
3810  NULL, NULL, show_archive_command
3811  },
3812 
3813  {
3814  {"archive_library", PGC_SIGHUP, WAL_ARCHIVING,
3815  gettext_noop("Sets the library that will be called to archive a WAL file."),
3816  gettext_noop("An empty string indicates that \"archive_command\" should be used.")
3817  },
3818  &XLogArchiveLibrary,
3819  "",
3820  NULL, NULL, NULL
3821  },
3822 
3823  {
3824  {"restore_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
3825  gettext_noop("Sets the shell command that will be called to retrieve an archived WAL file."),
3826  NULL
3827  },
3828  &recoveryRestoreCommand,
3829  "",
3830  NULL, NULL, NULL
3831  },
3832 
3833  {
3834  {"archive_cleanup_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
3835  gettext_noop("Sets the shell command that will be executed at every restart point."),
3836  NULL
3837  },
3838  &archiveCleanupCommand,
3839  "",
3840  NULL, NULL, NULL
3841  },
3842 
3843  {
3844  {"recovery_end_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
3845  gettext_noop("Sets the shell command that will be executed once at the end of recovery."),
3846  NULL
3847  },
3848  &recoveryEndCommand,
3849  "",
3850  NULL, NULL, NULL
3851  },
3852 
3853  {
3854  {"recovery_target_timeline", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
3855  gettext_noop("Specifies the timeline to recover into."),
3856  NULL
3857  },
3858  &recovery_target_timeline_string,
3859  "latest",
3860  check_recovery_target_timeline, assign_recovery_target_timeline, NULL
3861  },
3862 
3863  {
3864  {"recovery_target", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
3865  gettext_noop("Set to \"immediate\" to end recovery as soon as a consistent state is reached."),
3866  NULL
3867  },
3868  &recovery_target_string,
3869  "",
3870  check_recovery_target, assign_recovery_target, NULL
3871  },
3872  {
3873  {"recovery_target_xid", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
3874  gettext_noop("Sets the transaction ID up to which recovery will proceed."),
3875  NULL
3876  },
3877  &recovery_target_xid_string,
3878  "",
3879  check_recovery_target_xid, assign_recovery_target_xid, NULL
3880  },
3881  {
3882  {"recovery_target_time", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
3883  gettext_noop("Sets the time stamp up to which recovery will proceed."),
3884  NULL
3885  },
3886  &recovery_target_time_string,
3887  "",
3888  check_recovery_target_time, assign_recovery_target_time, NULL
3889  },
3890  {
3891  {"recovery_target_name", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
3892  gettext_noop("Sets the named restore point up to which recovery will proceed."),
3893  NULL
3894  },
3895  &recovery_target_name_string,
3896  "",
3897  check_recovery_target_name, assign_recovery_target_name, NULL
3898  },
3899  {
3900  {"recovery_target_lsn", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
3901  gettext_noop("Sets the LSN of the write-ahead log location up to which recovery will proceed."),
3902  NULL
3903  },
3904  &recovery_target_lsn_string,
3905  "",
3906  check_recovery_target_lsn, assign_recovery_target_lsn, NULL
3907  },
3908 
3909  {
3910  {"primary_conninfo", PGC_SIGHUP, REPLICATION_STANDBY,
3911  gettext_noop("Sets the connection string to be used to connect to the sending server."),
3912  NULL,
3913  GUC_SUPERUSER_ONLY
3914  },
3915  &PrimaryConnInfo,
3916  "",
3917  NULL, NULL, NULL
3918  },
3919 
3920  {
3921  {"primary_slot_name", PGC_SIGHUP, REPLICATION_STANDBY,
3922  gettext_noop("Sets the name of the replication slot to use on the sending server."),
3923  NULL
3924  },
3925  &PrimarySlotName,
3926  "",
3927  check_primary_slot_name, NULL, NULL
3928  },
3929 
3930  {
3931  {"client_encoding", PGC_USERSET, CLIENT_CONN_LOCALE,
3932  gettext_noop("Sets the client's character set encoding."),
3933  NULL,
3934  GUC_IS_NAME | GUC_REPORT
3935  },
3936  &client_encoding_string,
3937  "SQL_ASCII",
3938  check_client_encoding, assign_client_encoding, NULL
3939  },
3940 
3941  {
3942  {"log_line_prefix", PGC_SIGHUP, LOGGING_WHAT,
3943  gettext_noop("Controls information prefixed to each log line."),
3944  gettext_noop("If blank, no prefix is used.")
3945  },
3946  &Log_line_prefix,
3947  "%m [%p] ",
3948  NULL, NULL, NULL
3949  },
3950 
3951  {
3952  {"log_timezone", PGC_SIGHUP, LOGGING_WHAT,
3953  gettext_noop("Sets the time zone to use in log messages."),
3954  NULL
3955  },
3956  &log_timezone_string,
3957  "GMT",
3958  check_log_timezone, assign_log_timezone, show_log_timezone
3959  },
3960 
3961  {
3962  {"DateStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
3963  gettext_noop("Sets the display format for date and time values."),
3964  gettext_noop("Also controls interpretation of ambiguous "
3965  "date inputs."),
3966  GUC_LIST_INPUT | GUC_REPORT
3967  },
3968  &datestyle_string,
3969  "ISO, MDY",
3970  check_datestyle, assign_datestyle, NULL
3971  },
3972 
3973  {
3974  {"default_table_access_method", PGC_USERSET, CLIENT_CONN_STATEMENT,
3975  gettext_noop("Sets the default table access method for new tables."),
3976  NULL,
3977  GUC_IS_NAME
3978  },
3979  &default_table_access_method,
3980  DEFAULT_TABLE_ACCESS_METHOD,
3981  check_default_table_access_method, NULL, NULL
3982  },
3983 
3984  {
3985  {"default_tablespace", PGC_USERSET, CLIENT_CONN_STATEMENT,
3986  gettext_noop("Sets the default tablespace to create tables and indexes in."),
3987  gettext_noop("An empty string selects the database's default tablespace."),
3988  GUC_IS_NAME
3989  },
3990  &default_tablespace,
3991  "",
3992  check_default_tablespace, NULL, NULL
3993  },
3994 
3995  {
3996  {"temp_tablespaces", PGC_USERSET, CLIENT_CONN_STATEMENT,
3997  gettext_noop("Sets the tablespace(s) to use for temporary tables and sort files."),
3998  NULL,
3999  GUC_LIST_INPUT | GUC_LIST_QUOTE
4000  },
4001  &temp_tablespaces,
4002  "",
4003  check_temp_tablespaces, assign_temp_tablespaces, NULL
4004  },
4005 
4006  {
4007  {"createrole_self_grant", PGC_USERSET, CLIENT_CONN_STATEMENT,
4008  gettext_noop("Sets whether a CREATEROLE user automatically grants "
4009  "the role to themselves, and with which options."),
4010  NULL,
4011  GUC_LIST_INPUT
4012  },
4013  &createrole_self_grant,
4014  "",
4015  check_createrole_self_grant, assign_createrole_self_grant, NULL
4016  },
4017 
4018  {
4019  {"dynamic_library_path", PGC_SUSET, CLIENT_CONN_OTHER,
4020  gettext_noop("Sets the path for dynamically loadable modules."),
4021  gettext_noop("If a dynamically loadable module needs to be opened and "
4022  "the specified name does not have a directory component (i.e., the "
4023  "name does not contain a slash), the system will search this path for "
4024  "the specified file."),
4025  GUC_SUPERUSER_ONLY
4026  },
4027  &Dynamic_library_path,
4028  "$libdir",
4029  NULL, NULL, NULL
4030  },
4031 
4032  {
4033  {"krb_server_keyfile", PGC_SIGHUP, CONN_AUTH_AUTH,
4034  gettext_noop("Sets the location of the Kerberos server key file."),
4035  NULL,
4036  GUC_SUPERUSER_ONLY
4037  },
4038  &pg_krb_server_keyfile,
4039  PG_KRB_SRVTAB,
4040  NULL, NULL, NULL
4041  },
4042 
4043  {
4044  {"bonjour_name", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4045  gettext_noop("Sets the Bonjour service name."),
4046  NULL
4047  },
4048  &bonjour_name,
4049  "",
4050  NULL, NULL, NULL
4051  },
4052 
4053  /* See main.c about why defaults for LC_foo are not all alike */
4054 
4055  {
4056  {"lc_collate", PGC_INTERNAL, PRESET_OPTIONS,
4057  gettext_noop("Shows the collation order locale."),
4058  NULL,
4059  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4060  },
4061  &locale_collate,
4062  "C",
4063  NULL, NULL, NULL
4064  },
4065 
4066  {
4067  {"lc_ctype", PGC_INTERNAL, PRESET_OPTIONS,
4068  gettext_noop("Shows the character classification and case conversion locale."),
4069  NULL,
4070  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4071  },
4072  &locale_ctype,
4073  "C",
4074  NULL, NULL, NULL
4075  },
4076 
4077  {
4078  {"lc_messages", PGC_SUSET, CLIENT_CONN_LOCALE,
4079  gettext_noop("Sets the language in which messages are displayed."),
4080  NULL
4081  },
4082  &locale_messages,
4083  "",
4084  check_locale_messages, assign_locale_messages, NULL
4085  },
4086 
4087  {
4088  {"lc_monetary", PGC_USERSET, CLIENT_CONN_LOCALE,
4089  gettext_noop("Sets the locale for formatting monetary amounts."),
4090  NULL
4091  },
4092  &locale_monetary,
4093  "C",
4094  check_locale_monetary, assign_locale_monetary, NULL
4095  },
4096 
4097  {
4098  {"lc_numeric", PGC_USERSET, CLIENT_CONN_LOCALE,
4099  gettext_noop("Sets the locale for formatting numbers."),
4100  NULL
4101  },
4102  &locale_numeric,
4103  "C",
4104  check_locale_numeric, assign_locale_numeric, NULL
4105  },
4106 
4107  {
4108  {"lc_time", PGC_USERSET, CLIENT_CONN_LOCALE,
4109  gettext_noop("Sets the locale for formatting date and time values."),
4110  NULL
4111  },
4112  &locale_time,
4113  "C",
4114  check_locale_time, assign_locale_time, NULL
4115  },
4116 
4117  {
4118  {"session_preload_libraries", PGC_SUSET, CLIENT_CONN_PRELOAD,
4119  gettext_noop("Lists shared libraries to preload into each backend."),
4120  NULL,
4121  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
4122  },
4123  &session_preload_libraries_string,
4124  "",
4125  NULL, NULL, NULL
4126  },
4127 
4128  {
4129  {"shared_preload_libraries", PGC_POSTMASTER, CLIENT_CONN_PRELOAD,
4130  gettext_noop("Lists shared libraries to preload into server."),
4131  NULL,
4132  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
4133  },
4134  &shared_preload_libraries_string,
4135  "",
4136  NULL, NULL, NULL
4137  },
4138 
4139  {
4140  {"local_preload_libraries", PGC_USERSET, CLIENT_CONN_PRELOAD,
4141  gettext_noop("Lists unprivileged shared libraries to preload into each backend."),
4142  NULL,
4143  GUC_LIST_INPUT | GUC_LIST_QUOTE
4144  },
4145  &local_preload_libraries_string,
4146  "",
4147  NULL, NULL, NULL
4148  },
4149 
4150  {
4151  {"search_path", PGC_USERSET, CLIENT_CONN_STATEMENT,
4152  gettext_noop("Sets the schema search order for names that are not schema-qualified."),
4153  NULL,
4154  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_EXPLAIN
4155  },
4156  &namespace_search_path,
4157  "\"$user\", public",
4158  check_search_path, assign_search_path, NULL
4159  },
4160 
4161  {
4162  /* Can't be set in postgresql.conf */
4163  {"server_encoding", PGC_INTERNAL, PRESET_OPTIONS,
4164  gettext_noop("Shows the server (database) character set encoding."),
4165  NULL,
4166  GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4167  },
4168  &server_encoding_string,
4169  "SQL_ASCII",
4170  NULL, NULL, NULL
4171  },
4172 
4173  {
4174  /* Can't be set in postgresql.conf */
4175  {"server_version", PGC_INTERNAL, PRESET_OPTIONS,
4176  gettext_noop("Shows the server version."),
4177  NULL,
4178  GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4179  },
4180  &server_version_string,
4181  PG_VERSION,
4182  NULL, NULL, NULL
4183  },
4184 
4185  {
4186  /* Not for general use --- used by SET ROLE */
4187  {"role", PGC_USERSET, UNGROUPED,
4188  gettext_noop("Sets the current role."),
4189  NULL,
4190  GUC_IS_NAME | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_NOT_WHILE_SEC_REST
4191  },
4192  &role_string,
4193  "none",
4194  check_role, assign_role, show_role
4195  },
4196 
4197  {
4198  /* Not for general use --- used by SET SESSION AUTHORIZATION */
4199  {"session_authorization", PGC_USERSET, UNGROUPED,
4200  gettext_noop("Sets the session user name."),
4201  NULL,
4202  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
4203  },
4204  &session_authorization_string,
4205  NULL,
4206  check_session_authorization, assign_session_authorization, NULL
4207  },
4208 
4209  {
4210  {"log_destination", PGC_SIGHUP, LOGGING_WHERE,
4211  gettext_noop("Sets the destination for server log output."),
4212  gettext_noop("Valid values are combinations of \"stderr\", "
4213  "\"syslog\", \"csvlog\", \"jsonlog\", and \"eventlog\", "
4214  "depending on the platform."),
4215  GUC_LIST_INPUT
4216  },
4217  &Log_destination_string,
4218  "stderr",
4219  check_log_destination, assign_log_destination, NULL
4220  },
4221  {
4222  {"log_directory", PGC_SIGHUP, LOGGING_WHERE,
4223  gettext_noop("Sets the destination directory for log files."),
4224  gettext_noop("Can be specified as relative to the data directory "
4225  "or as absolute path."),
4226  GUC_SUPERUSER_ONLY
4227  },
4228  &Log_directory,
4229  "log",
4230  check_canonical_path, NULL, NULL
4231  },
4232  {
4233  {"log_filename", PGC_SIGHUP, LOGGING_WHERE,
4234  gettext_noop("Sets the file name pattern for log files."),
4235  NULL,
4236  GUC_SUPERUSER_ONLY
4237  },
4238  &Log_filename,
4239  "postgresql-%Y-%m-%d_%H%M%S.log",
4240  NULL, NULL, NULL
4241  },
4242 
4243  {
4244  {"syslog_ident", PGC_SIGHUP, LOGGING_WHERE,
4245  gettext_noop("Sets the program name used to identify PostgreSQL "
4246  "messages in syslog."),
4247  NULL
4248  },
4249  &syslog_ident_str,
4250  "postgres",
4251  NULL, assign_syslog_ident, NULL
4252  },
4253 
4254  {
4255  {"event_source", PGC_POSTMASTER, LOGGING_WHERE,
4256  gettext_noop("Sets the application name used to identify "
4257  "PostgreSQL messages in the event log."),
4258  NULL
4259  },
4260  &event_source,
4261  DEFAULT_EVENT_SOURCE,
4262  NULL, NULL, NULL
4263  },
4264 
4265  {
4266  {"TimeZone", PGC_USERSET, CLIENT_CONN_LOCALE,
4267  gettext_noop("Sets the time zone for displaying and interpreting time stamps."),
4268  NULL,
4269  GUC_REPORT
4270  },
4271  &timezone_string,
4272  "GMT",
4273  check_timezone, assign_timezone, show_timezone
4274  },
4275  {
4276  {"timezone_abbreviations", PGC_USERSET, CLIENT_CONN_LOCALE,
4277  gettext_noop("Selects a file of time zone abbreviations."),
4278  NULL
4279  },
4280  &timezone_abbreviations_string,
4281  NULL,
4282  check_timezone_abbreviations, assign_timezone_abbreviations, NULL
4283  },
4284 
4285  {
4286  {"unix_socket_group", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4287  gettext_noop("Sets the owning group of the Unix-domain socket."),
4288  gettext_noop("The owning user of the socket is always the user "
4289  "that starts the server.")
4290  },
4291  &Unix_socket_group,
4292  "",
4293  NULL, NULL, NULL
4294  },
4295 
4296  {
4297  {"unix_socket_directories", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4298  gettext_noop("Sets the directories where Unix-domain sockets will be created."),
4299  NULL,
4300  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
4301  },
4302  &Unix_socket_directories,
4303  DEFAULT_PGSOCKET_DIR,
4304  NULL, NULL, NULL
4305  },
4306 
4307  {
4308  {"listen_addresses", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4309  gettext_noop("Sets the host name or IP address(es) to listen to."),
4310  NULL,
4311  GUC_LIST_INPUT
4312  },
4313  &ListenAddresses,
4314  "localhost",
4315  NULL, NULL, NULL
4316  },
4317 
4318  {
4319  /*
4320  * Can't be set by ALTER SYSTEM as it can lead to recursive definition
4321  * of data_directory.
4322  */
4323  {"data_directory", PGC_POSTMASTER, FILE_LOCATIONS,
4324  gettext_noop("Sets the server's data directory."),
4325  NULL,
4326  GUC_SUPERUSER_ONLY | GUC_DISALLOW_IN_AUTO_FILE
4327  },
4328  &data_directory,
4329  NULL,
4330  NULL, NULL, NULL
4331  },
4332 
4333  {
4334  {"config_file", PGC_POSTMASTER, FILE_LOCATIONS,
4335  gettext_noop("Sets the server's main configuration file."),
4336  NULL,
4337  GUC_DISALLOW_IN_FILE | GUC_SUPERUSER_ONLY
4338  },
4339  &ConfigFileName,
4340  NULL,
4341  NULL, NULL, NULL
4342  },
4343 
4344  {
4345  {"hba_file", PGC_POSTMASTER, FILE_LOCATIONS,
4346  gettext_noop("Sets the server's \"hba\" configuration file."),
4347  NULL,
4348  GUC_SUPERUSER_ONLY
4349  },
4350  &HbaFileName,
4351  NULL,
4352  NULL, NULL, NULL
4353  },
4354 
4355  {
4356  {"ident_file", PGC_POSTMASTER, FILE_LOCATIONS,
4357  gettext_noop("Sets the server's \"ident\" configuration file."),
4358  NULL,
4359  GUC_SUPERUSER_ONLY
4360  },
4361  &IdentFileName,
4362  NULL,
4363  NULL, NULL, NULL
4364  },
4365 
4366  {
4367  {"external_pid_file", PGC_POSTMASTER, FILE_LOCATIONS,
4368  gettext_noop("Writes the postmaster PID to the specified file."),
4369  NULL,
4370  GUC_SUPERUSER_ONLY
4371  },
4372  &external_pid_file,
4373  NULL,
4374  check_canonical_path, NULL, NULL
4375  },
4376 
4377  {
4378  {"ssl_library", PGC_INTERNAL, PRESET_OPTIONS,
4379  gettext_noop("Shows the name of the SSL library."),
4380  NULL,
4381  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4382  },
4383  &ssl_library,
4384 #ifdef USE_SSL
4385  "OpenSSL",
4386 #else
4387  "",
4388 #endif
4389  NULL, NULL, NULL
4390  },
4391 
4392  {
4393  {"ssl_cert_file", PGC_SIGHUP, CONN_AUTH_SSL,
4394  gettext_noop("Location of the SSL server certificate file."),
4395  NULL
4396  },
4397  &ssl_cert_file,
4398  "server.crt",
4399  NULL, NULL, NULL
4400  },
4401 
4402  {
4403  {"ssl_key_file", PGC_SIGHUP, CONN_AUTH_SSL,
4404  gettext_noop("Location of the SSL server private key file."),
4405  NULL
4406  },
4407  &ssl_key_file,
4408  "server.key",
4409  NULL, NULL, NULL
4410  },
4411 
4412  {
4413  {"ssl_ca_file", PGC_SIGHUP, CONN_AUTH_SSL,
4414  gettext_noop("Location of the SSL certificate authority file."),
4415  NULL
4416  },
4417  &ssl_ca_file,
4418  "",
4419  NULL, NULL, NULL
4420  },
4421 
4422  {
4423  {"ssl_crl_file", PGC_SIGHUP, CONN_AUTH_SSL,
4424  gettext_noop("Location of the SSL certificate revocation list file."),
4425  NULL
4426  },
4427  &ssl_crl_file,
4428  "",
4429  NULL, NULL, NULL
4430  },
4431 
4432  {
4433  {"ssl_crl_dir", PGC_SIGHUP, CONN_AUTH_SSL,
4434  gettext_noop("Location of the SSL certificate revocation list directory."),
4435  NULL
4436  },
4437  &ssl_crl_dir,
4438  "",
4439  NULL, NULL, NULL
4440  },
4441 
4442  {
4443  {"synchronous_standby_names", PGC_SIGHUP, REPLICATION_PRIMARY,
4444  gettext_noop("Number of synchronous standbys and list of names of potential synchronous ones."),
4445  NULL,
4446  GUC_LIST_INPUT
4447  },
4448  &SyncRepStandbyNames,
4449  "",
4450  check_synchronous_standby_names, assign_synchronous_standby_names, NULL
4451  },
4452 
4453  {
4454  {"default_text_search_config", PGC_USERSET, CLIENT_CONN_LOCALE,
4455  gettext_noop("Sets default text search configuration."),
4456  NULL
4457  },
4458  &TSCurrentConfig,
4459  "pg_catalog.simple",
4460  check_default_text_search_config, assign_default_text_search_config, NULL
4461  },
4462 
4463  {
4464  {"ssl_ciphers", PGC_SIGHUP, CONN_AUTH_SSL,
4465  gettext_noop("Sets the list of allowed SSL ciphers."),
4466  NULL,
4467  GUC_SUPERUSER_ONLY
4468  },
4469  &SSLCipherSuites,
4470 #ifdef USE_OPENSSL
4471  "HIGH:MEDIUM:+3DES:!aNULL",
4472 #else
4473  "none",
4474 #endif
4475  NULL, NULL, NULL
4476  },
4477 
4478  {
4479  {"ssl_ecdh_curve", PGC_SIGHUP, CONN_AUTH_SSL,
4480  gettext_noop("Sets the curve to use for ECDH."),
4481  NULL,
4482  GUC_SUPERUSER_ONLY
4483  },
4484  &SSLECDHCurve,
4485 #ifdef USE_SSL
4486  "prime256v1",
4487 #else
4488  "none",
4489 #endif
4490  NULL, NULL, NULL
4491  },
4492 
4493  {
4494  {"ssl_dh_params_file", PGC_SIGHUP, CONN_AUTH_SSL,
4495  gettext_noop("Location of the SSL DH parameters file."),
4496  NULL,
4497  GUC_SUPERUSER_ONLY
4498  },
4499  &ssl_dh_params_file,
4500  "",
4501  NULL, NULL, NULL
4502  },
4503 
4504  {
4505  {"ssl_passphrase_command", PGC_SIGHUP, CONN_AUTH_SSL,
4506  gettext_noop("Command to obtain passphrases for SSL."),
4507  NULL,
4508  GUC_SUPERUSER_ONLY
4509  },
4510  &ssl_passphrase_command,
4511  "",
4512  NULL, NULL, NULL
4513  },
4514 
4515  {
4516  {"application_name", PGC_USERSET, LOGGING_WHAT,
4517  gettext_noop("Sets the application name to be reported in statistics and logs."),
4518  NULL,
4519  GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE
4520  },
4521  &application_name,
4522  "",
4523  check_application_name, assign_application_name, NULL
4524  },
4525 
4526  {
4527  {"cluster_name", PGC_POSTMASTER, PROCESS_TITLE,
4528  gettext_noop("Sets the name of the cluster, which is included in the process title."),
4529  NULL,
4530  GUC_IS_NAME
4531  },
4532  &cluster_name,
4533  "",
4534  check_cluster_name, NULL, NULL
4535  },
4536 
4537  {
4538  {"wal_consistency_checking", PGC_SUSET, DEVELOPER_OPTIONS,
4539  gettext_noop("Sets the WAL resource managers for which WAL consistency checks are done."),
4540  gettext_noop("Full-page images will be logged for all data blocks and cross-checked against the results of WAL replay."),
4541  GUC_LIST_INPUT | GUC_NOT_IN_SAMPLE
4542  },
4543  &wal_consistency_checking_string,
4544  "",
4545  check_wal_consistency_checking, assign_wal_consistency_checking, NULL
4546  },
4547 
4548  {
4549  {"jit_provider", PGC_POSTMASTER, CLIENT_CONN_PRELOAD,
4550  gettext_noop("JIT provider to use."),
4551  NULL,
4552  GUC_SUPERUSER_ONLY
4553  },
4554  &jit_provider,
4555  "llvmjit",
4556  NULL, NULL, NULL
4557  },
4558 
4559  {
4560  {"backtrace_functions", PGC_SUSET, DEVELOPER_OPTIONS,
4561  gettext_noop("Log backtrace for errors in these functions."),
4562  NULL,
4563  GUC_NOT_IN_SAMPLE
4564  },
4565  &backtrace_functions,
4566  "",
4567  check_backtrace_functions, assign_backtrace_functions, NULL
4568  },
4569 
4570  {
4571  {"debug_io_direct", PGC_POSTMASTER, DEVELOPER_OPTIONS,
4572  gettext_noop("Use direct I/O for file access."),
4573  NULL,
4574  GUC_LIST_INPUT | GUC_NOT_IN_SAMPLE
4575  },
4576  &io_direct_string,
4577  "",
4578  check_io_direct, assign_io_direct, NULL
4579  },
4580 
4581  /* End-of-list marker */
4582  {
4583  {NULL, 0, 0, NULL, NULL}, NULL, NULL, NULL, NULL, NULL
4584  }
4585 };
4586 
4587 
4588 struct config_enum ConfigureNamesEnum[] =
4589 {
4590  {
4591  {"backslash_quote", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
4592  gettext_noop("Sets whether \"\\'\" is allowed in string literals."),
4593  NULL
4594  },
4595  &backslash_quote,
4596  BACKSLASH_QUOTE_SAFE_ENCODING, backslash_quote_options,
4597  NULL, NULL, NULL
4598  },
4599 
4600  {
4601  {"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
4602  gettext_noop("Sets the output format for bytea."),
4603  NULL
4604  },
4605  &bytea_output,
4606  BYTEA_OUTPUT_HEX, bytea_output_options,
4607  NULL, NULL, NULL
4608  },
4609 
4610  {
4611  {"client_min_messages", PGC_USERSET, CLIENT_CONN_STATEMENT,
4612  gettext_noop("Sets the message levels that are sent to the client."),
4613  gettext_noop("Each level includes all the levels that follow it. The later"
4614  " the level, the fewer messages are sent.")
4615  },
4616  &client_min_messages,
4617  NOTICE, client_message_level_options,
4618  NULL, NULL, NULL
4619  },
4620 
4621  {
4622  {"compute_query_id", PGC_SUSET, STATS_MONITORING,
4623  gettext_noop("Enables in-core computation of query identifiers."),
4624  NULL
4625  },
4626  &compute_query_id,
4627  COMPUTE_QUERY_ID_AUTO, compute_query_id_options,
4628  NULL, NULL, NULL
4629  },
4630 
4631  {
4632  {"constraint_exclusion", PGC_USERSET, QUERY_TUNING_OTHER,
4633  gettext_noop("Enables the planner to use constraints to optimize queries."),
4634  gettext_noop("Table scans will be skipped if their constraints"
4635  " guarantee that no rows match the query."),
4636  GUC_EXPLAIN
4637  },
4638  &constraint_exclusion,
4639  CONSTRAINT_EXCLUSION_PARTITION, constraint_exclusion_options,
4640  NULL, NULL, NULL
4641  },
4642 
4643  {
4644  {"default_toast_compression", PGC_USERSET, CLIENT_CONN_STATEMENT,
4645  gettext_noop("Sets the default compression method for compressible values."),
4646  NULL
4647  },
4648  &default_toast_compression,
4649  TOAST_PGLZ_COMPRESSION,
4650  default_toast_compression_options,
4651  NULL, NULL, NULL
4652  },
4653 
4654  {
4655  {"default_transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
4656  gettext_noop("Sets the transaction isolation level of each new transaction."),
4657  NULL
4658  },
4659  &DefaultXactIsoLevel,
4660  XACT_READ_COMMITTED, isolation_level_options,
4661  NULL, NULL, NULL
4662  },
4663 
4664  {
4665  {"transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
4666  gettext_noop("Sets the current transaction's isolation level."),
4667  NULL,
4668  GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4669  },
4670  &XactIsoLevel,
4671  XACT_READ_COMMITTED, isolation_level_options,
4672  check_transaction_isolation, NULL, NULL
4673  },
4674 
4675  {
4676  {"IntervalStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
4677  gettext_noop("Sets the display format for interval values."),
4678  NULL,
4679  GUC_REPORT
4680  },
4681  &IntervalStyle,
4682  INTSTYLE_POSTGRES, intervalstyle_options,
4683  NULL, NULL, NULL
4684  },
4685 
4686  {
4687  {"icu_validation_level", PGC_USERSET, CLIENT_CONN_LOCALE,
4688  gettext_noop("Log level for reporting invalid ICU locale strings."),
4689  NULL
4690  },
4691  &icu_validation_level,
4692  WARNING, icu_validation_level_options,
4693  NULL, NULL, NULL
4694  },
4695 
4696  {
4697  {"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
4698  gettext_noop("Sets the verbosity of logged messages."),
4699  NULL
4700  },
4701  &Log_error_verbosity,
4702  PGERROR_DEFAULT, log_error_verbosity_options,
4703  NULL, NULL, NULL
4704  },
4705 
4706  {
4707  {"log_min_messages", PGC_SUSET, LOGGING_WHEN,
4708  gettext_noop("Sets the message levels that are logged."),
4709  gettext_noop("Each level includes all the levels that follow it. The later"
4710  " the level, the fewer messages are sent.")
4711  },
4712  &log_min_messages,
4713  WARNING, server_message_level_options,
4714  NULL, NULL, NULL
4715  },
4716 
4717  {
4718  {"log_min_error_statement", PGC_SUSET, LOGGING_WHEN,
4719  gettext_noop("Causes all statements generating error at or above this level to be logged."),
4720  gettext_noop("Each level includes all the levels that follow it. The later"
4721  " the level, the fewer messages are sent.")
4722  },
4723  &log_min_error_statement,
4724  ERROR, server_message_level_options,
4725  NULL, NULL, NULL
4726  },
4727 
4728  {
4729  {"log_statement", PGC_SUSET, LOGGING_WHAT,
4730  gettext_noop("Sets the type of statements logged."),
4731  NULL
4732  },
4733  &log_statement,
4734  LOGSTMT_NONE, log_statement_options,
4735  NULL, NULL, NULL
4736  },
4737 
4738  {
4739  {"syslog_facility", PGC_SIGHUP, LOGGING_WHERE,
4740  gettext_noop("Sets the syslog \"facility\" to be used when syslog enabled."),
4741  NULL
4742  },
4743  &syslog_facility,
4744  DEFAULT_SYSLOG_FACILITY,
4745  syslog_facility_options,
4746  NULL, assign_syslog_facility, NULL
4747  },
4748 
4749  {
4750  {"session_replication_role", PGC_SUSET, CLIENT_CONN_STATEMENT,
4751  gettext_noop("Sets the session's behavior for triggers and rewrite rules."),
4752  NULL
4753  },
4754  &SessionReplicationRole,
4755  SESSION_REPLICATION_ROLE_ORIGIN, session_replication_role_options,
4756  NULL, assign_session_replication_role, NULL
4757  },
4758 
4759  {
4760  {"synchronous_commit", PGC_USERSET, WAL_SETTINGS,
4761  gettext_noop("Sets the current transaction's synchronization level."),
4762  NULL
4763  },
4764  &synchronous_commit,
4765  SYNCHRONOUS_COMMIT_ON, synchronous_commit_options,
4766  NULL, assign_synchronous_commit, NULL
4767  },
4768 
4769  {
4770  {"archive_mode", PGC_POSTMASTER, WAL_ARCHIVING,
4771  gettext_noop("Allows archiving of WAL files using archive_command."),
4772  NULL
4773  },
4774  &XLogArchiveMode,
4775  ARCHIVE_MODE_OFF, archive_mode_options,
4776  NULL, NULL, NULL
4777  },
4778 
4779  {
4780  {"recovery_target_action", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4781  gettext_noop("Sets the action to perform upon reaching the recovery target."),
4782  NULL
4783  },
4784  &recoveryTargetAction,
4785  RECOVERY_TARGET_ACTION_PAUSE, recovery_target_action_options,
4786  NULL, NULL, NULL
4787  },
4788 
4789  {
4790  {"trace_recovery_messages", PGC_SIGHUP, DEVELOPER_OPTIONS,
4791  gettext_noop("Enables logging of recovery-related debugging information."),
4792  gettext_noop("Each level includes all the levels that follow it. The later"
4793  " the level, the fewer messages are sent."),
4794  GUC_NOT_IN_SAMPLE,
4795  },
4796  &trace_recovery_messages,
4797 
4798  /*
4799  * client_message_level_options allows too many values, really, but
4800  * it's not worth having a separate options array for this.
4801  */
4802  LOG, client_message_level_options,
4803  NULL, NULL, NULL
4804  },
4805 
4806  {
4807  {"track_functions", PGC_SUSET, STATS_CUMULATIVE,
4808  gettext_noop("Collects function-level statistics on database activity."),
4809  NULL
4810  },
4811  &pgstat_track_functions,
4812  TRACK_FUNC_OFF, track_function_options,
4813  NULL, NULL, NULL
4814  },
4815 
4816 
4817  {
4818  {"stats_fetch_consistency", PGC_USERSET, STATS_CUMULATIVE,
4819  gettext_noop("Sets the consistency of accesses to statistics data."),
4820  NULL
4821  },
4822  &pgstat_fetch_consistency,
4823  PGSTAT_FETCH_CONSISTENCY_CACHE, stats_fetch_consistency,
4824  NULL, assign_stats_fetch_consistency, NULL
4825  },
4826 
4827  {
4828  {"wal_compression", PGC_SUSET, WAL_SETTINGS,
4829  gettext_noop("Compresses full-page writes written in WAL file with specified method."),
4830  NULL
4831  },
4832  &wal_compression,
4833  WAL_COMPRESSION_NONE, wal_compression_options,
4834  NULL, NULL, NULL
4835  },
4836 
4837  {
4838  {"wal_level", PGC_POSTMASTER, WAL_SETTINGS,
4839  gettext_noop("Sets the level of information written to the WAL."),
4840  NULL
4841  },
4842  &wal_level,
4843  WAL_LEVEL_REPLICA, wal_level_options,
4844  NULL, NULL, NULL
4845  },
4846 
4847  {
4848  {"dynamic_shared_memory_type", PGC_POSTMASTER, RESOURCES_MEM,
4849  gettext_noop("Selects the dynamic shared memory implementation used."),
4850  NULL
4851  },
4852  &dynamic_shared_memory_type,
4853  DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE, dynamic_shared_memory_options,
4854  NULL, NULL, NULL
4855  },
4856 
4857  {
4858  {"shared_memory_type", PGC_POSTMASTER, RESOURCES_MEM,
4859  gettext_noop("Selects the shared memory implementation used for the main shared memory region."),
4860  NULL
4861  },
4862  &shared_memory_type,
4863  DEFAULT_SHARED_MEMORY_TYPE, shared_memory_options,
4864  NULL, NULL, NULL
4865  },
4866 
4867  {
4868  {"wal_sync_method", PGC_SIGHUP, WAL_SETTINGS,
4869  gettext_noop("Selects the method used for forcing WAL updates to disk."),
4870  NULL
4871  },
4872  &sync_method,
4873  DEFAULT_SYNC_METHOD, sync_method_options,
4874  NULL, assign_xlog_sync_method, NULL
4875  },
4876 
4877  {
4878  {"xmlbinary", PGC_USERSET, CLIENT_CONN_STATEMENT,
4879  gettext_noop("Sets how binary values are to be encoded in XML."),
4880  NULL
4881  },
4882  &xmlbinary,
4883  XMLBINARY_BASE64, xmlbinary_options,
4884  NULL, NULL, NULL
4885  },
4886 
4887  {
4888  {"xmloption", PGC_USERSET, CLIENT_CONN_STATEMENT,
4889  gettext_noop("Sets whether XML data in implicit parsing and serialization "
4890  "operations is to be considered as documents or content fragments."),
4891  NULL
4892  },
4893  &xmloption,
4894  XMLOPTION_CONTENT, xmloption_options,
4895  NULL, NULL, NULL
4896  },
4897 
4898  {
4899  {"huge_pages", PGC_POSTMASTER, RESOURCES_MEM,
4900  gettext_noop("Use of huge pages on Linux or Windows."),
4901  NULL
4902  },
4903  &huge_pages,
4904  HUGE_PAGES_TRY, huge_pages_options,
4905  NULL, NULL, NULL
4906  },
4907 
4908  {
4909  {"recovery_prefetch", PGC_SIGHUP, WAL_RECOVERY,
4910  gettext_noop("Prefetch referenced blocks during recovery."),
4911  gettext_noop("Look ahead in the WAL to find references to uncached data.")
4912  },
4913  &recovery_prefetch,
4914  RECOVERY_PREFETCH_TRY, recovery_prefetch_options,
4915  check_recovery_prefetch, assign_recovery_prefetch, NULL
4916  },
4917 
4918  {
4919  {"debug_parallel_query", PGC_USERSET, DEVELOPER_OPTIONS,
4920  gettext_noop("Forces the planner's use parallel query nodes."),
4921  gettext_noop("This can be useful for testing the parallel query infrastructure "
4922  "by forcing the planner to generate plans which contains nodes "
4923  "which perform tuple communication between workers and the main process."),
4924  GUC_NOT_IN_SAMPLE | GUC_EXPLAIN
4925  },
4926  &debug_parallel_query,
4927  DEBUG_PARALLEL_OFF, debug_parallel_query_options,
4928  NULL, NULL, NULL
4929  },
4930 
4931  {
4932  {"password_encryption", PGC_USERSET, CONN_AUTH_AUTH,
4933  gettext_noop("Chooses the algorithm for encrypting passwords."),
4934  NULL
4935  },
4936  &Password_encryption,
4937  PASSWORD_TYPE_SCRAM_SHA_256, password_encryption_options,
4938  NULL, NULL, NULL
4939  },
4940 
4941  {
4942  {"plan_cache_mode", PGC_USERSET, QUERY_TUNING_OTHER,
4943  gettext_noop("Controls the planner's selection of custom or generic plan."),
4944  gettext_noop("Prepared statements can have custom and generic plans, and the planner "
4945  "will attempt to choose which is better. This can be set to override "
4946  "the default behavior."),
4947  GUC_EXPLAIN
4948  },
4949  &plan_cache_mode,
4950  PLAN_CACHE_MODE_AUTO, plan_cache_mode_options,
4951  NULL, NULL, NULL
4952  },
4953 
4954  {
4955  {"ssl_min_protocol_version", PGC_SIGHUP, CONN_AUTH_SSL,
4956  gettext_noop("Sets the minimum SSL/TLS protocol version to use."),
4957  NULL,
4958  GUC_SUPERUSER_ONLY
4959  },
4960  &ssl_min_protocol_version,
4961  PG_TLS1_2_VERSION,
4962  ssl_protocol_versions_info + 1, /* don't allow PG_TLS_ANY */
4963  NULL, NULL, NULL
4964  },
4965 
4966  {
4967  {"ssl_max_protocol_version", PGC_SIGHUP, CONN_AUTH_SSL,
4968  gettext_noop("Sets the maximum SSL/TLS protocol version to use."),
4969  NULL,
4970  GUC_SUPERUSER_ONLY
4971  },
4972  &ssl_max_protocol_version,
4973  PG_TLS_ANY,
4974  ssl_protocol_versions_info,
4975  NULL, NULL, NULL
4976  },
4977 
4978  {
4979  {"recovery_init_sync_method", PGC_SIGHUP, ERROR_HANDLING_OPTIONS,
4980  gettext_noop("Sets the method for synchronizing the data directory before crash recovery."),
4981  },
4982  &recovery_init_sync_method,
4983  RECOVERY_INIT_SYNC_METHOD_FSYNC, recovery_init_sync_method_options,
4984  NULL, NULL, NULL
4985  },
4986 
4987  {
4988  {"logical_replication_mode", PGC_USERSET, DEVELOPER_OPTIONS,
4989  gettext_noop("Controls when to replicate or apply each change."),
4990  gettext_noop("On the publisher, it allows streaming or serializing each change in logical decoding. "
4991  "On the subscriber, it allows serialization of all changes to files and notifies the "
4992  "parallel apply workers to read and apply them at the end of the transaction."),
4993  GUC_NOT_IN_SAMPLE
4994  },
4995  &logical_replication_mode,
4996  LOGICAL_REP_MODE_BUFFERED, logical_replication_mode_options,
4997  NULL, NULL, NULL
4998  },
4999 
5000  /* End-of-list marker */
5001  {
5002  {NULL, 0, 0, NULL, NULL}, NULL, 0, NULL, NULL, NULL, NULL
5003  }
5004 };
geqo_threshold
int geqo_threshold
Definition: allpaths.c:83
enable_geqo
bool enable_geqo
Definition: allpaths.c:82
min_parallel_index_scan_size
int min_parallel_index_scan_size
Definition: allpaths.c:85
min_parallel_table_scan_size
int min_parallel_table_scan_size
Definition: allpaths.c:84
archive_module.h
Array_nulls
bool Array_nulls
Definition: arrayfuncs.c:42
Trace_notify
bool Trace_notify
Definition: async.c:443
scram_sha_256_iterations
int scram_sha_256_iterations
Definition: auth-scram.c:197
pg_krb_server_keyfile
char * pg_krb_server_keyfile
Definition: auth.c:166
pg_krb_caseins_users
bool pg_krb_caseins_users
Definition: auth.c:167
pg_gss_accept_delegation
bool pg_gss_accept_delegation
Definition: auth.c:168
autovacuum_multixact_freeze_max_age
int autovacuum_multixact_freeze_max_age
Definition: autovacuum.c:127
autovacuum_naptime
int autovacuum_naptime
Definition: autovacuum.c:119
autovacuum_vac_scale
double autovacuum_vac_scale
Definition: autovacuum.c:121
Log_autovacuum_min_duration
int Log_autovacuum_min_duration
Definition: autovacuum.c:132
autovacuum_anl_thresh
int autovacuum_anl_thresh
Definition: autovacuum.c:124
check_autovacuum_work_mem
bool check_autovacuum_work_mem(int *newval, void **extra, GucSource source)
Definition: autovacuum.c:3460
autovacuum_vac_cost_limit
int autovacuum_vac_cost_limit
Definition: autovacuum.c:130
autovacuum_max_workers
int autovacuum_max_workers
Definition: autovacuum.c:117
autovacuum_freeze_max_age
int autovacuum_freeze_max_age
Definition: autovacuum.c:126
autovacuum_vac_cost_delay
double autovacuum_vac_cost_delay
Definition: autovacuum.c:129
autovacuum_vac_thresh
int autovacuum_vac_thresh
Definition: autovacuum.c:120
autovacuum_work_mem
int autovacuum_work_mem
Definition: autovacuum.c:118
autovacuum_anl_scale
double autovacuum_anl_scale
Definition: autovacuum.c:125
autovacuum_vac_ins_thresh
int autovacuum_vac_ins_thresh
Definition: autovacuum.c:122
autovacuum_start_daemon
bool autovacuum_start_daemon
Definition: autovacuum.c:116
autovacuum_vac_ins_scale
double autovacuum_vac_ins_scale
Definition: autovacuum.c:123
check_default_tablespace
bool check_default_tablespace(char **newval, void **extra, GucSource source)
Definition: tablespace.c:1097
assign_temp_tablespaces
void assign_temp_tablespaces(const char *newval, void *extra)
Definition: tablespace.c:1312
check_temp_tablespaces
bool check_temp_tablespaces(char **newval, void **extra, GucSource source)
Definition: tablespace.c:1204
allow_in_place_tablespaces
bool allow_in_place_tablespaces
Definition: tablespace.c:91
show_unix_socket_permissions
const char * show_unix_socket_permissions(void)
Definition: variable.c:1133
assign_application_name
void assign_application_name(const char *newval, void *extra)
Definition: variable.c:1051
check_bonjour
bool check_bonjour(bool *newval, void **extra, GucSource source)
Definition: variable.c:1148
check_maintenance_io_concurrency
bool check_maintenance_io_concurrency(int *newval, void **extra, GucSource source)
Definition: variable.c:1189
assign_session_authorization
void assign_session_authorization(const char *newval, void *extra)
Definition: variable.c:861
check_transaction_deferrable
bool check_transaction_deferrable(bool *newval, void **extra, GucSource source)
Definition: variable.c:620
check_canonical_path
bool check_canonical_path(char **newval, void **extra, GucSource source)
Definition: variable.c:1004
show_timezone
const char * show_timezone(void)
Definition: variable.c:390
check_transaction_isolation
bool check_transaction_isolation(int *newval, void **extra, GucSource source)
Definition: variable.c:583
check_default_with_oids
bool check_default_with_oids(bool *newval, void **extra, GucSource source)
Definition: variable.c:1161
assign_timezone_abbreviations
void assign_timezone_abbreviations(const char *newval, void *extra)
Definition: variable.c:517
check_effective_io_concurrency
bool check_effective_io_concurrency(int *newval, void **extra, GucSource source)
Definition: variable.c:1176
check_application_name
bool check_application_name(char **newval, void **extra, GucSource source)
Definition: variable.c:1025
assign_timezone
void assign_timezone(const char *newval, void *extra)
Definition: variable.c:381
check_role
bool check_role(char **newval, void **extra, GucSource source)
Definition: variable.c:883
check_cluster_name
bool check_cluster_name(char **newval, void **extra, GucSource source)
Definition: variable.c:1061
show_log_timezone
const char * show_log_timezone(void)
Definition: variable.c:463
check_session_authorization
bool check_session_authorization(char **newval, void **extra, GucSource source)
Definition: variable.c:802
check_transaction_read_only
bool check_transaction_read_only(bool *newval, void **extra, GucSource source)
Definition: variable.c:544
assign_maintenance_io_concurrency
void assign_maintenance_io_concurrency(int newval, void *extra)
Definition: variable.c:1087
check_timezone_abbreviations
bool check_timezone_abbreviations(char **newval, void **extra, GucSource source)
Definition: variable.c:485
assign_client_encoding
void assign_client_encoding(const char *newval, void *extra)
Definition: variable.c:756
assign_role
void assign_role(const char *newval, void *extra)
Definition: variable.c:971
check_timezone
bool check_timezone(char **newval, void **extra, GucSource source)
Definition: variable.c:261
show_random_seed
const char * show_random_seed(void)
Definition: variable.c:669
check_ssl
bool check_ssl(bool *newval, void **extra, GucSource source)
Definition: variable.c:1202
assign_datestyle
void assign_datestyle(const char *newval, void *extra)
Definition: variable.c:244
assign_random_seed
void assign_random_seed(double newval, void *extra)
Definition: variable.c:660
check_log_timezone
bool check_log_timezone(char **newval, void **extra, GucSource source)
Definition: variable.c:416
check_random_seed
bool check_random_seed(double *newval, void **extra, GucSource source)
Definition: variable.c:648
show_role
const char * show_role(void)
Definition: variable.c:979
check_datestyle
bool check_datestyle(char **newval, void **extra, GucSource source)
Definition: variable.c:52
check_client_encoding
bool check_client_encoding(char **newval, void **extra, GucSource source)
Definition: variable.c:680
show_log_file_mode
const char * show_log_file_mode(void)
Definition: variable.c:1121
show_data_directory_mode
const char * show_data_directory_mode(void)
Definition: variable.c:1109
assign_log_timezone
void assign_log_timezone(const char *newval, void *extra)
Definition: variable.c:454
log_startup_progress_interval
int log_startup_progress_interval
Definition: startup.c:78
pgstat_track_activities
bool pgstat_track_activities
Definition: backend_status.c:45
pgstat_track_activity_query_size
int pgstat_track_activity_query_size
Definition: backend_status.c:46
ssl_crl_dir
char * ssl_crl_dir
Definition: be-secure.c:43
ssl_dh_params_file
char * ssl_dh_params_file
Definition: be-secure.c:44
ssl_min_protocol_version
int ssl_min_protocol_version
Definition: be-secure.c:61
ssl_cert_file
char * ssl_cert_file
Definition: be-secure.c:39
SSLPreferServerCiphers
bool SSLPreferServerCiphers
Definition: be-secure.c:59
ssl_library
char * ssl_library
Definition: be-secure.c:38
ssl_max_protocol_version
int ssl_max_protocol_version
Definition: be-secure.c:62
ssl_passphrase_command
char * ssl_passphrase_command
Definition: be-secure.c:45
ssl_passphrase_command_supports_reload
bool ssl_passphrase_command_supports_reload
Definition: be-secure.c:46
SSLCipherSuites
char * SSLCipherSuites
Definition: be-secure.c:53
SSLECDHCurve
char * SSLECDHCurve
Definition: be-secure.c:56
ssl_key_file
char * ssl_key_file
Definition: be-secure.c:40
ssl_crl_file
char * ssl_crl_file
Definition: be-secure.c:42
ssl_ca_file
char * ssl_ca_file
Definition: be-secure.c:41
bgworker_internals.h
MAX_PARALLEL_WORKER_LIMIT
#define MAX_PARALLEL_WORKER_LIMIT
Definition: bgworker_internals.h:24
BgWriterDelay
int BgWriterDelay
Definition: bgwriter.c:61
track_io_timing
bool track_io_timing
Definition: bufmgr.c:138
zero_damaged_pages
bool zero_damaged_pages
Definition: bufmgr.c:135
bgwriter_flush_after
int bgwriter_flush_after
Definition: bufmgr.c:160
checkpoint_flush_after
int checkpoint_flush_after
Definition: bufmgr.c:159
bgwriter_lru_multiplier
double bgwriter_lru_multiplier
Definition: bufmgr.c:137
backend_flush_after
int backend_flush_after
Definition: bufmgr.c:161
maintenance_io_concurrency
int maintenance_io_concurrency
Definition: bufmgr.c:153
effective_io_concurrency
int effective_io_concurrency
Definition: bufmgr.c:146
bgwriter_lru_maxpages
int bgwriter_lru_maxpages
Definition: bufmgr.c:136
MAX_IO_CONCURRENCY
#define MAX_IO_CONCURRENCY
Definition: bufmgr.h:149
DEFAULT_EFFECTIVE_IO_CONCURRENCY
#define DEFAULT_EFFECTIVE_IO_CONCURRENCY
Definition: bufmgr.h:130
DEFAULT_MAINTENANCE_IO_CONCURRENCY
#define DEFAULT_MAINTENANCE_IO_CONCURRENCY
Definition: bufmgr.h:131
BYTEA_OUTPUT_HEX
@ BYTEA_OUTPUT_HEX
Definition: bytea.h:22
BYTEA_OUTPUT_ESCAPE
@ BYTEA_OUTPUT_ESCAPE
Definition: bytea.h:21
Min
#define Min(x, y)
Definition: c.h:988
gettext_noop
#define gettext_noop(x)
Definition: c.h:1204
lengthof
#define lengthof(array)
Definition: c.h:772
CheckPointCompletionTarget
double CheckPointCompletionTarget
Definition: checkpointer.c:146
CheckPointWarning
int CheckPointWarning
Definition: checkpointer.c:145
CheckPointTimeout
int CheckPointTimeout
Definition: checkpointer.c:144
default_statistics_target
int default_statistics_target
Definition: analyze.c:83
track_commit_timestamp
bool track_commit_timestamp
Definition: commit_ts.c:102
commit_ts.h
DEFAULT_PARALLEL_TUPLE_COST
#define DEFAULT_PARALLEL_TUPLE_COST
Definition: cost.h:29
DEFAULT_PARALLEL_SETUP_COST
#define DEFAULT_PARALLEL_SETUP_COST
Definition: cost.h:30
CONSTRAINT_EXCLUSION_OFF
@ CONSTRAINT_EXCLUSION_OFF
Definition: cost.h:38
CONSTRAINT_EXCLUSION_PARTITION
@ CONSTRAINT_EXCLUSION_PARTITION
Definition: cost.h:40
CONSTRAINT_EXCLUSION_ON
@ CONSTRAINT_EXCLUSION_ON
Definition: cost.h:39
DEFAULT_CPU_INDEX_TUPLE_COST
#define DEFAULT_CPU_INDEX_TUPLE_COST
Definition: cost.h:27
DEFAULT_CPU_TUPLE_COST
#define DEFAULT_CPU_TUPLE_COST
Definition: cost.h:26
DEFAULT_RANDOM_PAGE_COST
#define DEFAULT_RANDOM_PAGE_COST
Definition: cost.h:25
DEFAULT_RECURSIVE_WORKTABLE_FACTOR
#define DEFAULT_RECURSIVE_WORKTABLE_FACTOR
Definition: cost.h:33
DEFAULT_EFFECTIVE_CACHE_SIZE
#define DEFAULT_EFFECTIVE_CACHE_SIZE
Definition: cost.h:34
DEFAULT_SEQ_PAGE_COST
#define DEFAULT_SEQ_PAGE_COST
Definition: cost.h:24
DEFAULT_CPU_OPERATOR_COST
#define DEFAULT_CPU_OPERATOR_COST
Definition: cost.h:28
random_page_cost
double random_page_cost
Definition: costsize.c:121
cpu_operator_cost
double cpu_operator_cost
Definition: costsize.c:124
enable_partitionwise_aggregate
bool enable_partitionwise_aggregate
Definition: costsize.c:150
enable_seqscan
bool enable_seqscan
Definition: costsize.c:135
max_parallel_workers_per_gather
int max_parallel_workers_per_gather
Definition: costsize.c:133
enable_memoize
bool enable_memoize
Definition: costsize.c:145
parallel_setup_cost
double parallel_setup_cost
Definition: costsize.c:126
recursive_worktable_factor
double recursive_worktable_factor
Definition: costsize.c:127
enable_gathermerge
bool enable_gathermerge
Definition: costsize.c:148
parallel_tuple_cost
double parallel_tuple_cost
Definition: costsize.c:125
enable_indexonlyscan
bool enable_indexonlyscan
Definition: costsize.c:137
enable_tidscan
bool enable_tidscan
Definition: costsize.c:139
cpu_tuple_cost
double cpu_tuple_cost
Definition: costsize.c:122
enable_material
bool enable_material
Definition: costsize.c:144
enable_hashjoin
bool enable_hashjoin
Definition: costsize.c:147
enable_mergejoin
bool enable_mergejoin
Definition: costsize.c:146
enable_presorted_aggregate
bool enable_presorted_aggregate
Definition: costsize.c:154
enable_parallel_hash
bool enable_parallel_hash
Definition: costsize.c:152
enable_partitionwise_join
bool enable_partitionwise_join
Definition: costsize.c:149
enable_async_append
bool enable_async_append
Definition: costsize.c:155
seq_page_cost
double seq_page_cost
Definition: costsize.c:120
enable_parallel_append
bool enable_parallel_append
Definition: costsize.c:151
enable_nestloop
bool enable_nestloop
Definition: costsize.c:143
enable_bitmapscan
bool enable_bitmapscan
Definition: costsize.c:138
enable_hashagg
bool enable_hashagg
Definition: costsize.c:142
enable_partition_pruning
bool enable_partition_pruning
Definition: costsize.c:153
enable_sort
bool enable_sort
Definition: costsize.c:140
effective_cache_size
int effective_cache_size
Definition: costsize.c:129
cpu_index_tuple_cost
double cpu_index_tuple_cost
Definition: costsize.c:123
enable_indexscan
bool enable_indexscan
Definition: costsize.c:136
enable_incremental_sort
bool enable_incremental_sort
Definition: costsize.c:141
PASSWORD_TYPE_SCRAM_SHA_256
@ PASSWORD_TYPE_SCRAM_SHA_256
Definition: crypt.h:31
PASSWORD_TYPE_MD5
@ PASSWORD_TYPE_MD5
Definition: crypt.h:30
MINS_PER_HOUR
#define MINS_PER_HOUR
Definition: timestamp.h:128
SECS_PER_MINUTE
#define SECS_PER_MINUTE
Definition: timestamp.h:127
HOURS_PER_DAY
#define HOURS_PER_DAY
Definition: timestamp.h:117
Dynamic_library_path
char * Dynamic_library_path
Definition: dfmgr.c:76
min_dynamic_shared_memory
int min_dynamic_shared_memory
Definition: dsm_impl.c:115
dynamic_shared_memory_type
int dynamic_shared_memory_type
Definition: dsm_impl.c:112
DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE
#define DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE
Definition: dsm_impl.h:36
assign_syslog_facility
void assign_syslog_facility(int newval, void *extra)
Definition: elog.c:2293
assign_syslog_ident
void assign_syslog_ident(const char *newval, void *extra)
Definition: elog.c:2261
syslog_split_messages
bool syslog_split_messages
Definition: elog.c:116
assign_backtrace_functions
void assign_backtrace_functions(const char *newval, void *extra)
Definition: elog.c:2181
Log_error_verbosity
int Log_error_verbosity
Definition: elog.c:111
check_backtrace_functions
bool check_backtrace_functions(char **newval, void **extra, GucSource source)
Definition: elog.c:2122
check_log_destination
bool check_log_destination(char **newval, void **extra, GucSource source)
Definition: elog.c:2190
syslog_sequence_numbers
bool syslog_sequence_numbers
Definition: elog.c:115
Log_destination_string
char * Log_destination_string
Definition: elog.c:114
Log_line_prefix
char * Log_line_prefix
Definition: elog.c:112
assign_log_destination
void assign_log_destination(const char *newval, void *extra)
Definition: elog.c:2252
PGERROR_VERBOSE
@ PGERROR_VERBOSE
Definition: elog.h:481
PGERROR_DEFAULT
@ PGERROR_DEFAULT
Definition: elog.h:480
PGERROR_TERSE
@ PGERROR_TERSE
Definition: elog.h:479
LOG
#define LOG
Definition: elog.h:31
DEBUG3
#define DEBUG3
Definition: elog.h:28
FATAL
#define FATAL
Definition: elog.h:41
WARNING
#define WARNING
Definition: elog.h:36
DEBUG2
#define DEBUG2
Definition: elog.h:29
PANIC
#define PANIC
Definition: elog.h:42
DEBUG1
#define DEBUG1
Definition: elog.h:30
ERROR
#define ERROR
Definition: elog.h:39
NOTICE
#define NOTICE
Definition: elog.h:35
INFO
#define INFO
Definition: elog.h:34
DEBUG5
#define DEBUG5
Definition: elog.h:26
DEBUG4
#define DEBUG4
Definition: elog.h:27
max_files_per_process
int max_files_per_process
Definition: fd.c:146
recovery_init_sync_method
int recovery_init_sync_method
Definition: fd.c:165
check_io_direct
bool check_io_direct(char **newval, void **extra, GucSource source)
Definition: fd.c:3839
data_sync_retry
bool data_sync_retry
Definition: fd.c:162
assign_io_direct
void assign_io_direct(const char *newval, void *extra)
Definition: fd.c:3921
RECOVERY_INIT_SYNC_METHOD_SYNCFS
@ RECOVERY_INIT_SYNC_METHOD_SYNCFS
Definition: fd.h:52
RECOVERY_INIT_SYNC_METHOD_FSYNC
@ RECOVERY_INIT_SYNC_METHOD_FSYNC
Definition: fd.h:51
extra_float_digits
int extra_float_digits
Definition: float.c:43
DEFAULT_GEQO_EFFORT
#define DEFAULT_GEQO_EFFORT
Definition: geqo.h:55
MAX_GEQO_EFFORT
#define MAX_GEQO_EFFORT
Definition: geqo.h:57
MAX_GEQO_SELECTION_BIAS
#define MAX_GEQO_SELECTION_BIAS
Definition: geqo.h:67
MIN_GEQO_EFFORT
#define MIN_GEQO_EFFORT
Definition: geqo.h:56
DEFAULT_GEQO_SELECTION_BIAS
#define DEFAULT_GEQO_SELECTION_BIAS
Definition: geqo.h:65
MIN_GEQO_SELECTION_BIAS
#define MIN_GEQO_SELECTION_BIAS
Definition: geqo.h:66
Geqo_pool_size
int Geqo_pool_size
Definition: geqo_main.c:40
Geqo_seed
double Geqo_seed
Definition: geqo_main.c:43
Geqo_generations
int Geqo_generations
Definition: geqo_main.c:41
Geqo_effort
int Geqo_effort
Definition: geqo_main.c:39
Geqo_selection_bias
double Geqo_selection_bias
Definition: geqo_main.c:42
gin_pending_list_limit
int gin_pending_list_limit
Definition: ginfast.c:39
GinFuzzySearchLimit
int GinFuzzySearchLimit
Definition: ginget.c:27
hash_mem_multiplier
double hash_mem_multiplier
Definition: globals.c:126
VacuumCostLimit
int VacuumCostLimit
Definition: globals.c:148
max_parallel_maintenance_workers
int max_parallel_maintenance_workers
Definition: globals.c:128
NBuffers
int NBuffers
Definition: globals.c:136
enableFsync
bool enableFsync
Definition: globals.c:123
VacuumCostPageMiss
int VacuumCostPageMiss
Definition: globals.c:146
MaxConnections
int MaxConnections
Definition: globals.c:137
data_directory_mode
int data_directory_mode
Definition: globals.c:72
allowSystemTableMods
bool allowSystemTableMods
Definition: globals.c:124
maintenance_work_mem
int maintenance_work_mem
Definition: globals.c:127
max_parallel_workers
int max_parallel_workers
Definition: globals.c:139
VacuumCostPageDirty
int VacuumCostPageDirty
Definition: globals.c:147
ExitOnAnyError
bool ExitOnAnyError
Definition: globals.c:117
IntervalStyle
int IntervalStyle
Definition: globals.c:121
work_mem
int work_mem
Definition: globals.c:125
VacuumBufferUsageLimit
int VacuumBufferUsageLimit
Definition: globals.c:143
VacuumCostPageHit
int VacuumCostPageHit
Definition: globals.c:145
VacuumCostDelay
double VacuumCostDelay
Definition: globals.c:149
max_worker_processes
int max_worker_processes
Definition: globals.c:138
GUC_UNIT_MB
#define GUC_UNIT_MB
Definition: guc.h:228
GUC_EXPLAIN
#define GUC_EXPLAIN
Definition: guc.h:213
GUC_SUPERUSER_ONLY
#define GUC_SUPERUSER_ONLY
Definition: guc.h:218
GUC_NO_RESET_ALL
#define GUC_NO_RESET_ALL
Definition: guc.h:212
GUC_NO_RESET
#define GUC_NO_RESET
Definition: guc.h:211
GUC_LIST_QUOTE
#define GUC_LIST_QUOTE
Definition: guc.h:209
GUC_UNIT_MS
#define GUC_UNIT_MS
Definition: guc.h:232
GUC_NOT_WHILE_SEC_REST
#define GUC_NOT_WHILE_SEC_REST
Definition: guc.h:220
GUC_UNIT_BLOCKS
#define GUC_UNIT_BLOCKS
Definition: guc.h:226
GUC_UNIT_XBLOCKS
#define GUC_UNIT_XBLOCKS
Definition: guc.h:227
GUC_IS_NAME
#define GUC_IS_NAME
Definition: guc.h:219
GUC_DISALLOW_IN_FILE
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:216
GUC_LIST_INPUT
#define GUC_LIST_INPUT
Definition: guc.h:208
GUC_RUNTIME_COMPUTED
#define GUC_RUNTIME_COMPUTED
Definition: guc.h:223
PGC_S_SESSION
@ PGC_S_SESSION
Definition: guc.h:122
GUC_NO_SHOW_ALL
#define GUC_NO_SHOW_ALL
Definition: guc.h:210
GUC_DISALLOW_IN_AUTO_FILE
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:221
PGC_SUSET
@ PGC_SUSET
Definition: guc.h:74
PGC_INTERNAL
@ PGC_INTERNAL
Definition: guc.h:69
PGC_USERSET
@ PGC_USERSET
Definition: guc.h:75
PGC_SU_BACKEND
@ PGC_SU_BACKEND
Definition: guc.h:72
PGC_POSTMASTER
@ PGC_POSTMASTER
Definition: guc.h:70
PGC_SIGHUP
@ PGC_SIGHUP
Definition: guc.h:71
PGC_BACKEND
@ PGC_BACKEND
Definition: guc.h:73
GUC_UNIT_BYTE
#define GUC_UNIT_BYTE
Definition: guc.h:229
GUC_NOT_IN_SAMPLE
#define GUC_NOT_IN_SAMPLE
Definition: guc.h:215
GUC_UNIT_S
#define GUC_UNIT_S
Definition: guc.h:233
GUC_REPORT
#define GUC_REPORT
Definition: guc.h:214
MAX_KILOBYTES
#define MAX_KILOBYTES
Definition: guc.h:25
GUC_UNIT_KB
#define GUC_UNIT_KB
Definition: guc.h:225
GUC_UNIT_MIN
#define GUC_UNIT_MIN
Definition: guc.h:234
guc_hooks.h
recovery_target_lsn_string
static char * recovery_target_lsn_string
Definition: guc_tables.c:607
log_statement_stats
bool log_statement_stats
Definition: guc_tables.c:495
client_encoding_string
static char * client_encoding_string
Definition: guc_tables.c:564
segment_size
static int segment_size
Definition: guc_tables.c:589
timezone_abbreviations_string
static char * timezone_abbreviations_string
Definition: guc_tables.c:582
stats_fetch_consistency
static const struct config_enum_entry stats_fetch_consistency[]
Definition: guc_tables.c:253
Debug_print_plan
bool Debug_print_plan
Definition: guc_tables.c:487
event_source
char * event_source
Definition: guc_tables.c:498
check_function_bodies
bool check_function_bodies
Definition: guc_tables.c:501
num_temp_buffers
int num_temp_buffers
Definition: guc_tables.c:525
client_min_messages
int client_min_messages
Definition: guc_tables.c:512
ignore_checksum_failure
bool ignore_checksum_failure
Definition: bufpage.c:27
locale_collate
static char * locale_collate
Definition: guc_tables.c:566
max_identifier_length
static int max_identifier_length
Definition: guc_tables.c:587
password_encryption_options
static const struct config_enum_entry password_encryption_options[]
Definition: guc_tables.c:402
ssl_protocol_versions_info
static const struct config_enum_entry ssl_protocol_versions_info[]
Definition: guc_tables.c:408
recovery_target_action_options
const struct config_enum_entry recovery_target_action_options[]
Definition: xlogrecovery.c:74
io_direct_string
static char * io_direct_string
Definition: guc_tables.c:571
default_with_oids
bool default_with_oids
Definition: guc_tables.c:507
ignore_invalid_pages
bool ignore_invalid_pages
Definition: xlogutils.c:37
ConfigureNamesString
struct config_string ConfigureNamesString[]
Definition: guc_tables.c:3801
CommitDelay
int CommitDelay
Definition: xlog.c:135
timezone_string
static char * timezone_string
Definition: guc_tables.c:580
PG_KRB_SRVTAB
#define PG_KRB_SRVTAB
Definition: guc_tables.c:89
debug_parallel_query_options
static const struct config_enum_entry debug_parallel_query_options[]
Definition: guc_tables.c:382
server_version_string
static char * server_version_string
Definition: guc_tables.c:569
log_min_error_statement
int log_min_error_statement
Definition: guc_tables.c:510
data_checksums
static bool data_checksums
Definition: guc_tables.c:593
syslog_facility_options
static const struct config_enum_entry syslog_facility_options[]
Definition: guc_tables.c:227
icu_validation_level_options
static const struct config_enum_entry icu_validation_level_options[]
Definition: guc_tables.c:169
recovery_prefetch_options
static const struct config_enum_entry recovery_prefetch_options[]
Definition: guc_tables.c:369
recovery_init_sync_method_options
static const struct config_enum_entry recovery_init_sync_method_options[]
Definition: guc_tables.c:426
tcp_keepalives_idle
int tcp_keepalives_idle
Definition: guc_tables.c:537
HbaFileName
char * HbaFileName
Definition: guc_tables.c:529
temp_file_limit
int temp_file_limit
Definition: guc_tables.c:523
GucContext_Names
const char *const GucContext_Names[]
Definition: guc_tables.c:621
ssl_renegotiation_limit
int ssl_renegotiation_limit
Definition: guc_tables.c:548
syslog_facility
static int syslog_facility
Definition: guc_tables.c:578
max_function_args
static int max_function_args
Definition: guc_tables.c:585
tcp_keepalives_interval
int tcp_keepalives_interval
Definition: guc_tables.c:538
max_index_keys
static int max_index_keys
Definition: guc_tables.c:586
backslash_quote_options
static const struct config_enum_entry backslash_quote_options[]
Definition: guc_tables.c:285
syslog_ident_str
static char * syslog_ident_str
Definition: guc_tables.c:562
DEFAULT_SYSLOG_FACILITY
#define DEFAULT_SYSLOG_FACILITY
Definition: guc_tables.c:576
CommitSiblings
int CommitSiblings
Definition: xlog.c:136
GucSource_Names
const char *const GucSource_Names[]
Definition: guc_tables.c:640
ConfigFileName
char * ConfigFileName
Definition: guc_tables.c:528
locale_ctype
static char * locale_ctype
Definition: guc_tables.c:567
pgstat_temp_directory
char * pgstat_temp_directory
Definition: guc_tables.c:533
log_parser_stats
bool log_parser_stats
Definition: guc_tables.c:492
block_size
static int block_size
Definition: guc_tables.c:588
tcp_keepalives_count
int tcp_keepalives_count
Definition: guc_tables.c:539
log_xact_sample_rate
double log_xact_sample_rate
Definition: guc_tables.c:519
DEFAULT_ASSERT_ENABLED
#define DEFAULT_ASSERT_ENABLED
Definition: guc_tables.c:599
shared_memory_options
static const struct config_enum_entry shared_memory_options[]
Definition: guc_tables.c:434
ConfigureNamesInt
struct config_int ConfigureNamesInt[]
Definition: guc_tables.c:2012
config_type_names
const char *const config_type_names[]
Definition: guc_tables.c:766
Debug_pretty_print
bool Debug_pretty_print
Definition: guc_tables.c:490
role_string
char * role_string
Definition: guc_tables.c:610
server_encoding_string
static char * server_encoding_string
Definition: guc_tables.c:568
logical_replication_mode_options
static const struct config_enum_entry logical_replication_mode_options[]
Definition: guc_tables.c:417
wal_block_size
static int wal_block_size
Definition: guc_tables.c:592
log_statement_options
static const struct config_enum_entry log_statement_options[]
Definition: guc_tables.c:198
plan_cache_mode_options
static const struct config_enum_entry plan_cache_mode_options[]
Definition: guc_tables.c:395
temp_tablespaces
char * temp_tablespaces
Definition: tablespace.c:90
huge_pages
int huge_pages
Definition: guc_tables.c:554
wal_compression_options
static const struct config_enum_entry wal_compression_options[]
Definition: guc_tables.c:455
datestyle_string
static char * datestyle_string
Definition: guc_tables.c:565
recovery_target_timeline_string
static char * recovery_target_timeline_string
Definition: guc_tables.c:603
trace_recovery_messages
int trace_recovery_messages
Definition: guc_tables.c:520
log_parameter_max_length_on_error
int log_parameter_max_length_on_error
Definition: guc_tables.c:516
dynamic_shared_memory_options
const struct config_enum_entry dynamic_shared_memory_options[]
Definition: dsm_impl.c:95
sync_method_options
const struct config_enum_entry sync_method_options[]
Definition: xlog.c:174
xmlbinary_options
static const struct config_enum_entry xmlbinary_options[]
Definition: guc_tables.c:263
log_min_duration_statement
int log_min_duration_statement
Definition: guc_tables.c:514
recovery_target_xid_string
static char * recovery_target_xid_string
Definition: guc_tables.c:605
log_min_duration_sample
int log_min_duration_sample
Definition: guc_tables.c:513
log_btree_build_stats
bool log_btree_build_stats
Definition: guc_tables.c:497
log_planner_stats
bool log_planner_stats
Definition: guc_tables.c:493
ConfigureNamesBool
struct config_bool ConfigureNamesBool[]
Definition: guc_tables.c:806
bytea_output_options
static const struct config_enum_entry bytea_output_options[]
Definition: guc_tables.c:115
row_security
bool row_security
Definition: guc_tables.c:500
archive_mode_options
const struct config_enum_entry archive_mode_options[]
Definition: xlog.c:194
huge_pages_options
static const struct config_enum_entry huge_pages_options[]
Definition: guc_tables.c:356
synchronous_commit_options
static const struct config_enum_entry synchronous_commit_options[]
Definition: guc_tables.c:337
recovery_target_string
static char * recovery_target_string
Definition: guc_tables.c:604
cluster_name
char * cluster_name
Definition: guc_tables.c:527
assert_enabled
static bool assert_enabled
Definition: guc_tables.c:601
session_auth_is_superuser
bool session_auth_is_superuser
Definition: guc_tables.c:508
default_toast_compression_options
static const struct config_enum_entry default_toast_compression_options[]
Definition: guc_tables.c:447
log_timezone_string
static char * log_timezone_string
Definition: guc_tables.c:581
session_authorization_string
static char * session_authorization_string
Definition: guc_tables.c:584
in_hot_standby_guc
bool in_hot_standby_guc
Definition: guc_tables.c:613
Debug_print_rewritten
bool Debug_print_rewritten
Definition: guc_tables.c:489
shared_memory_size_in_huge_pages
static int shared_memory_size_in_huge_pages
Definition: guc_tables.c:591
isolation_level_options
static const struct config_enum_entry isolation_level_options[]
Definition: guc_tables.c:209
log_error_verbosity_options
static const struct config_enum_entry log_error_verbosity_options[]
Definition: guc_tables.c:188
server_version_num
static int server_version_num
Definition: guc_tables.c:570
Debug_print_parse
bool Debug_print_parse
Definition: guc_tables.c:488
application_name
char * application_name
Definition: guc_tables.c:535
intervalstyle_options
static const struct config_enum_entry intervalstyle_options[]
Definition: guc_tables.c:161
log_parameter_max_length
int log_parameter_max_length
Definition: guc_tables.c:515
ConfigureNamesReal
struct config_real ConfigureNamesReal[]
Definition: guc_tables.c:3520
IdentFileName
char * IdentFileName
Definition: guc_tables.c:530
wal_level_options
const struct config_enum_entry wal_level_options[]
Definition: xlogdesc.c:27
ConfigureNamesEnum
struct config_enum ConfigureNamesEnum[]
Definition: guc_tables.c:4588
client_message_level_options
static const struct config_enum_entry client_message_level_options[]
Definition: guc_tables.c:129
tcp_user_timeout
int tcp_user_timeout
Definition: guc_tables.c:540
default_tablespace
char * default_tablespace
Definition: tablespace.c:89
constraint_exclusion_options
static const struct config_enum_entry constraint_exclusion_options[]
Definition: guc_tables.c:320
server_message_level_options
static const struct config_enum_entry server_message_level_options[]
Definition: guc_tables.c:144
compute_query_id_options
static const struct config_enum_entry compute_query_id_options[]
Definition: guc_tables.c:302
recovery_target_name_string
static char * recovery_target_name_string
Definition: guc_tables.c:606
huge_page_size
int huge_page_size
Definition: guc_tables.c:555
data_directory
static char * data_directory
Definition: guc_tables.c:583
StaticAssertDecl
StaticAssertDecl(lengthof(bytea_output_options)==(BYTEA_OUTPUT_HEX+2), "array length mismatch")
log_statement_sample_rate
double log_statement_sample_rate
Definition: guc_tables.c:518
log_duration
bool log_duration
Definition: guc_tables.c:486
config_group_names
const char *const config_group_names[]
Definition: guc_tables.c:664
integer_datetimes
static bool integer_datetimes
Definition: guc_tables.c:594
Log_disconnections
bool Log_disconnections
Definition: postgres.c:91