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