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